def random_tx():
import random
MAX_AMT = 1000
s = wallet.new()
r = wallet.new()
return StandardTransactionBuilder.create_tx(s[0], s[1], r[1],
random.randint(1, MAX_AMT))
def create_tx_struct(amount):
"""
Helper method to create and return a valid transaction struct with a random sender/receiever and
the specified amount
"""
s = wallet.new()
r = wallet.new()
return StandardTransactionBuilder.create_tx_struct(
s[0], s[1], r[1], amount)
def _convenience_build_standard_transaction(self):
"""These transactions get POSTed directly to masternodes by TAU wallet software"""
STU = (wallet.new())
DAVIS = (wallet.new())
DENTON = (wallet.new())
FALCON = (wallet.new())
KNOWN_ADRS = (STU, DAVIS, DENTON, FALCON)
amount = 10
tx = StandardTransactionBuilder.create_tx(STU[0], STU[1], DAVIS[1], amount)
return tx
def random_tx():
import random
MULT = 1000
negative = True if random.random() > 0.5 else False
amount = int(random.random() * MULT)
if negative:
amount *= -1
s = wallet.new()
r = wallet.new()
return StampTransactionBuilder.create_tx(s[0], s[1], r[1], amount)
def test_create_currency_tx(self):
sk, vk = wallet.new()
sk2, vk2 = wallet.new()
amount = 9000
currency_code = ContractTemplate.interpolate_template('currency',
amount=amount,
receiver=vk2)
contract_tx = ContractTransactionBuilder.create_currency_tx(
sender_sk=sk, receiver_vk=vk2, amount=amount)
self.assertEquals(contract_tx.sender, vk)
self.assertEquals(contract_tx.code, currency_code)
def test_validate_bad_metadata(self):
meta = b'lol'
message = self._default_msg()
sk, vk = wallet.new()
sk2, vk2 = wallet.new()
signature = EnvelopeAuth.seal(signing_key=sk,
meta=meta,
message=message)
seal = Seal.create(signature=signature, verifying_key=vk2)
self.assertRaises(Exception, Envelope._create_from_objects, seal, meta,
message.serialize())
def create_tx_struct(amount, h=None, e=None):
"""
Helper method to create and return a valid transaction struct with a random sender/receiver and
the specified amount
"""
hashlock = h if h is not None else secrets.token_bytes(32)
expiration = e if e is not None else int(time.time()) + (60 * 60 * 24)
s = wallet.new()
r = wallet.new()
return SwapTransactionBuilder.create_tx_struct(s[0], s[1], r[1],
amount, hashlock,
expiration)
def random_tx():
import random
MULT = 1000
import secrets
import time
tomorrow = int(time.time()) + (60 * 60 * 24)
s = wallet.new()
r = wallet.new()
return SwapTransactionBuilder.create_tx(s[0], s[1], r[1],
int(random.random() * MULT),
secrets.token_hex(32),
tomorrow)
def test_validate_bad_message(self):
meta = self._default_meta()
message = 'lol'
sk, vk = wallet.new()
self.assertRaises(Exception, EnvelopeAuth.seal, sk, meta,
message) # auth fails b/c message is not string
def random_envelope():
sk, vk = wallet.new()
tx = StandardTransactionBuilder.random_tx()
sender = 'me'
return Envelope.create_from_message(message=tx,
signing_key=sk,
sender_id=sender)
def random_tx():
import secrets
s = wallet.new()
return VoteTransactionBuilder.create_tx(s[0], s[1],
secrets.token_hex(8),
secrets.token_hex(8))
def test_invalid_sender_wrong_sender(self):
"""
Tests that an error is raised during creation if an invalid sender field is passed in. A sender should be a
64 character hex string verifying key.
"""
# Test an error is thrown when MerkleSignature created with a sender that is not the correct public key
msg = b'this is a pretend merkle tree hash'
sk, vk = wallet.new()
signature = wallet.sign(sk, msg)
timestamp = 'now'
vk_bad = wallet.new()[1] # different verifying (public) key
bad_public_key = MerkleSignature.create(sig_hex=signature,
timestamp=timestamp,
sender=vk_bad)
self.assertRaises(Exception, bad_public_key)
def create_tx_struct():
"""
Helper method to create and return a valid transaction struct with a random sender/receiever and
the specified amount
"""
s = wallet.new()
return RedeemTransactionBuilder.create_tx_struct(
s[0], s[1], secrets.token_hex(32))
def test_create_from_message_bad_msg(self):
"""
Tests create_from_message with invalid message
"""
sk, vk = wallet.new()
msg = 'hi im a bad message'
self.assertRaises(Exception, Envelope.create_from_message, msg, sk, vk)
def gen_keypair(url):
"""
Computes a wallet key pair as a deterministic function of url
"""
from cilantro.protocol import wallet
h = hashlib.sha256()
h.update(url.encode())
return wallet.new(seed=h.digest())
def test_validate_bad_seal(self):
meta = self._default_meta()
message = self._default_msg()
sk, vk = wallet.new()
sk2, vk2 = wallet.new()
signature = EnvelopeAuth.seal(signing_key=sk,
meta=meta,
message=message)
seal = Seal.create(signature=signature, verifying_key=vk2)
env = Envelope._create_from_objects(seal=seal,
meta=meta,
message=message.serialize())
self.assertFalse(env.verify_seal())
def test_creation(self):
sk, vk = wallet.new()
code = 'while True: do_that_thing'
contract_tx = ContractTransactionBuilder.create_contract_tx(
sender_sk=sk, code_str=code)
self.assertEquals(contract_tx.sender, vk)
self.assertEquals(contract_tx.code, code)
def test_valid_sender(self):
# Confirm no error when correct public key is used
msg = b'this is a pretend merkle tree hash'
sk, vk = wallet.new()
signature = wallet.sign(sk, msg)
timestamp = 'now'
MerkleSignature.create(sig_hex=signature,
timestamp=timestamp,
sender=vk) # no error thrown
def test_invalid_signature_bad_length(self):
# Test signature incorrect length (but valid hex)
sk, vk = wallet.new()
timestamp = 'now'
sig = ''.join(('A' for _ in range(100)))
wrong_len = MerkleSignature.create(sig_hex=sig,
timestamp=timestamp,
sender=vk,
validate=False)
self.assertRaises(Exception, wrong_len.validate)
def test_create_from_message_bad_keypair(self):
"""
test create_from_message passing in sk does and incorrect vk
"""
sk, vk = wallet.new()
sk1, vk1 = wallet.new()
msg = self._default_msg()
sender = 'dat boi'
env = Envelope.create_from_message(message=msg,
signing_key=sk,
verifying_key=vk) # no error
self.assertEqual(env.seal.verifying_key, vk)
self.assertRaises(Exception, Envelope.create_from_message, msg, sk,
sender, vk1)
self.assertNotEqual(env.seal.verifying_key, vk1)
def random_tx():
import secrets
import random
method = 0 if random.random() > 0.5 else 1
s = wallet.new()
return ElectionTransactionBuilder.create_tx(s[0], s[1],
secrets.token_hex(8),
method)
def run_mgmt():
from cilantro.logger import get_logger
from cilantro.utils.test import MPComposer
log = get_logger(__name__)
sk = masternodes[0]['sk']
vk = wallet.get_vk(sk)
s, v = wallet.new()
mpc = MPComposer(name='mgmt', sk=s)
mpc.add_sub(filter='a', vk=vk)
def test_validate_catches_bad_sig(self):
# test that validate is called by default and throws an exception with bad sig
sk, vk = wallet.new()
sig = ''.join(('X' for _ in range(128)))
timestamp = 'now'
self.assertRaises(Exception,
MerkleSignature.create,
sig_hex=sig,
timestamp=timestamp,
sender=vk)
def test_create_from_message(self):
"""
Tests create_from_message with valid args (no vk passed) creates an envelope valid signature and expected fields
"""
sk, vk = wallet.new()
msg = self._default_msg()
env = Envelope.create_from_message(message=msg, signing_key=sk)
self.assertTrue(env.verify_seal())
self.assertEqual(env.message, msg)
self.assertEqual(env.seal.verifying_key, vk)
def _create_merkle_sig(self, msg: bytes):
"""
Helper method to create a MerkleSignature and wallet keys
:return: A tuple container (MerkleSignature, signing_key, verifying_key)
"""
assert type(msg) == bytes, "Must pass in bytes"
sk, vk = wallet.new()
signature = wallet.sign(sk, msg)
ms = MerkleSignature.create(sig_hex=signature, timestamp=TIMESTAMP, sender=vk)
return ms, sk, vk
def test_serialize_from_objects(self):
"""
Tests that serialize/deserialize are inverse operations with from_objects factory function
"""
sk, vk = wallet.new()
message = self._default_msg()
env = Envelope.create_from_message(message=message,
signing_key=sk,
verifying_key=vk)
self.assertEqual(env, Envelope.from_bytes(env.serialize()))
def test_create_with_envelope(self):
"""
Tests creating a message with an envelope produces an object with the expected properties
"""
sk, vk = wallet.new()
tx = StandardTransactionBuilder.random_tx()
sender = 'me'
env = Envelope.create_from_message(message=tx, signing_key=sk)
cmd = ReactorCommand.create_cmd('some_cls', 'some_func', envelope=env)
self.assertTrue(ReactorCommand.envelope, env)
def test_creation(self):
"""
Tests that a created block data reply has the expected properties
"""
sk = wallet.new()[0]
contracts = [
ContractTransactionBuilder.create_contract_tx(sk, code_str) \
for code_str in ['some random binary', 'some deterministic binary', 'While True: self.eatAss()']
]
tx_binaries = [c.serialize() for c in contracts]
bdr = TransactionReply.create(tx_binaries)
self.assertEqual(contracts, bdr.transactions)
def test_deserialization_bad_sk_hex(self):
# Test valid json but signature (private key) not proper hex
msg = b'this is a pretend merkle tree hash'
sk, vk = wallet.new()
sig = ''.join(('Z' for _ in range(128)))
d = {
MerkleSignature.SIG: sig,
MerkleSignature.TS: 'now',
MerkleSignature.SENDER: vk
}
binary = json.dumps(d).encode()
self.assertRaises(Exception, MerkleSignature.from_bytes, binary)
def test_deserialization_valid_json(self):
# Test valid json throws no errors
msg = b'this is a pretend merkle tree hash'
sk, vk = wallet.new()
signature = wallet.sign(sk, msg)
d = {
MerkleSignature.SIG: signature,
MerkleSignature.TS: 'now',
MerkleSignature.SENDER: vk
}
binary = json.dumps(d).encode()
MerkleSignature.from_bytes(binary)
