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)