def make_tx_packed(sender, server, contract_name, function_name, kwargs={}, stamps=10_000): wallet = Wallet(seed=sender) nonce_req = requests.get('{}/nonce/{}'.format( server, wallet.verifying_key().hex())) nonce = nonce_req.json()['nonce'] processor = bytes.fromhex(nonce_req.json()['processor']) batch = TransactionBuilder(sender=wallet.verifying_key(), contract=contract_name, function=function_name, kwargs=kwargs, stamps=stamps, processor=processor, nonce=nonce) batch.sign(sender) b = batch.serialize() return b
def test_sending_transfer_of_most_money_doesnt_fail_if_enough_stamps(self): self.nonce_manager.set_var('stamp_cost', 'S', ['value'], value=3000) w = Wallet() expected_processor = secrets.token_bytes(32) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) self.nonce_manager.set(balances_key, 500000) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 499990, 'to': 'jeff'}, stamps=3000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def test_submission_prepended_with_con_succeeds(self): w = Wallet() expected_processor = secrets.token_bytes(32) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) self.nonce_manager.set(balances_key, 500000) tx = TransactionBuilder(w.verifying_key(), contract='submission', function='submit_contract', kwargs={'name': 'con_bad_name', 'code': 'blah'}, stamps=3000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def make_tx(processor, contract_name, function_name, kwargs={}): w = Wallet() batch = TransactionBuilder(sender=w.verifying_key(), contract=contract_name, function=function_name, kwargs=kwargs, stamps=10000, processor=processor, nonce=0) batch.sign(w.signing_key()) b = batch.serialize() tx = transaction_capnp.Transaction.from_bytes_packed(b) currency_contract = 'currency' balances_hash = 'balances' balances_key = '{}{}{}{}{}'.format(currency_contract, config.INDEX_SEPARATOR, balances_hash, config.DELIMITER, w.verifying_key().hex()) driver = ContractDriver() driver.set(balances_key, 1_000_000) driver.commit() return tx
def random_packed_tx(nonce=0, processor=None, give_stamps=False): w = Wallet() processor = secrets.token_bytes(32) if processor is None else processor stamps = random.randint(100_000, 1_000_000) if give_stamps: balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) N.set(balances_key, stamps + 1000) tx = TransactionBuilder( w.verifying_key(), contract=secrets.token_hex(8), function=secrets.token_hex(8), kwargs={secrets.token_hex(8): secrets.token_hex(8)}, stamps=stamps, processor=processor, nonce=nonce) tx.sign(w.signing_key()) #tx.proof = b'\x00' * 32 #tx.proof_generated = True packed_tx = transaction_capnp.Transaction.from_bytes_packed(tx.serialize()) return packed_tx
def test_peer_table_updated_on_join_command(self): # Network params issue w1 = Wallet() p1 = Network(wallet=w1, socket_base='tcp://127.0.0.1', ctx=self.ctx) w2 = Wallet() d = DiscoveryServer(wallet=w2, socket_id=_socket('tcp://127.0.0.1:19000'), pepper=PEPPER.encode(), ctx=self.ctx, linger=200) # 1. start network # 2. start discovery of other side # 3. send join request # 4. check to see if the data has been added join_message = ['join', (w2.verifying_key().hex(), 'tcp://127.0.0.1')] join_message = json.dumps(join_message).encode() tasks = asyncio.gather( p1.peer_service.serve(), d.serve(), services.get(_socket('tcp://127.0.0.1:10002'), msg=join_message, ctx=self.ctx, timeout=1000), stop_server(p1.peer_service, 0.3), stop_server(d, 0.3)) loop = asyncio.get_event_loop() loop.run_until_complete(tasks) self.assertEqual(p1.peer_service.table[w2.verifying_key().hex()], 'tcp://127.0.0.1')
def test_peer_server_returns_peer_when_asked_ipc(self): w1 = Wallet() p1 = Network(wallet=w1, socket_base='ipc:///tmp', ctx=self.ctx) w2 = Wallet() p1.peer_service.table[w2.verifying_key().hex()] = 'inproc://goodtimes' find_message = ['find', w2.verifying_key().hex()] find_message = json.dumps(find_message).encode() tasks = asyncio.gather( p1.peer_service.serve(), stop_server(p1.peer_service, 0.3), services.get(_socket('ipc:///tmp/peers'), msg=find_message, ctx=self.ctx, timeout=300)) loop = asyncio.get_event_loop() res = loop.run_until_complete(tasks) response = res[-1] response = response.decode() response = json.loads(response) self.assertEqual(response.get(w2.verifying_key().hex()), 'inproc://goodtimes')
def test_nonce_minus_pending_nonce_equal_tx_per_block_fails(self): w = Wallet() expected_processor = secrets.token_bytes(32) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) self.nonce_manager.set(balances_key, 500000) self.nonce_manager.set_nonce(processor=expected_processor, sender=w.verifying_key(), nonce=1) self.nonce_manager.set_pending_nonce(processor=expected_processor, sender=w.verifying_key(), nonce=16) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=16) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) with self.assertRaises(transaction.TransactionTooManyPendingException): transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager)
def test_bootstrap_nodes_ipc(self): w = Wallet() w1 = Wallet() w2 = Wallet() w3 = Wallet() w4 = Wallet() bootnodes = [ _socket('ipc:///tmp/n1/discovery'), _socket('ipc:///tmp/n2/discovery'), _socket('ipc:///tmp/n3/discovery'), _socket('ipc:///tmp/n4/discovery') ] d1 = DiscoveryServer(socket_id=bootnodes[0], wallet=w1, pepper=PEPPER.encode(), ctx=self.ctx, linger=1000, poll_timeout=1000) d2 = DiscoveryServer(socket_id=bootnodes[1], wallet=w2, pepper=PEPPER.encode(), ctx=self.ctx, linger=1000, poll_timeout=1000) d3 = DiscoveryServer(socket_id=bootnodes[2], wallet=w3, pepper=PEPPER.encode(), ctx=self.ctx, linger=1000, poll_timeout=1000) d4 = DiscoveryServer(socket_id=bootnodes[3], wallet=w4, pepper=PEPPER.encode(), ctx=self.ctx, linger=1000, poll_timeout=1000) n = Network(wallet=w, ctx=self.ctx, bootnodes=bootnodes) tasks = asyncio.gather(d1.serve(), d2.serve(), d3.serve(), d4.serve(), stop_server(d1, 1), stop_server(d2, 1), stop_server(d3, 1), stop_server(d4, 1), n.discover_bootnodes(bootnodes)) loop = asyncio.get_event_loop() loop.run_until_complete(tasks) expected_dict = { w.verifying_key().hex(): 'tcp://0.0.0.0', w1.verifying_key().hex(): 'ipc:///tmp/n1', w2.verifying_key().hex(): 'ipc:///tmp/n2', w3.verifying_key().hex(): 'ipc:///tmp/n3', w4.verifying_key().hex(): 'ipc:///tmp/n4' } self.assertDictEqual(n.peer_service.table, expected_dict)
def test_event_service_triggered_when_new_node_added_ipc(self): # Create Network service w1 = Wallet() p1 = Network(wallet=w1, ctx=self.ctx, socket_base='ipc:///tmp') n1 = '/tmp/n1' try: os.mkdir('/tmp/n1') except: pass # Create Discovery Server w2 = Wallet() d = DiscoveryServer(wallet=w2, socket_id=_socket('ipc:///tmp/n1/discovery'), pepper=PEPPER.encode(), ctx=self.ctx, poll_timeout=2000, linger=200) # Create raw subscriber subscriber = self.ctx.socket(zmq.SUB) subscriber.setsockopt(zmq.SUBSCRIBE, b'') subscriber.connect('ipc:///tmp/events') # TCP takes a bit longer to bind and is prone to dropping messages... sleep(0.3) # Construct the join RPC message join_message = ['join', (w2.verifying_key().hex(), 'ipc:///tmp/n1')] join_message = json.dumps(join_message).encode() # Wrap recv() in an async async def recv(): msg = await subscriber.recv() return msg tasks = asyncio.gather( p1.peer_service.start( ), # Start the PeerService which will process RPC and emit events d.serve( ), # Start Discovery so PeerService can verify they are online services.get(_socket('ipc:///tmp/peers'), msg=join_message, ctx=self.ctx, timeout=3000), # Push out a join request stop_server(p1.peer_service, 1), stop_server(d, 1), recv() # Collect the subscription result ) loop = asyncio.get_event_loop() res = loop.run_until_complete(tasks) expected_list = ['join', [w2.verifying_key().hex(), 'ipc:///tmp/n1']] got_list = json.loads(res[-1].decode()) self.assertListEqual(expected_list, got_list)
def test_network_start(self): # 4 nodes # 2 bootnodes # 2 mns, 2 delegates bootnodes = ['ipc:///tmp/n1', 'ipc:///tmp/n3'] mnw1 = Wallet() mnw2 = Wallet() masternodes = [mnw1.verifying_key().hex(), mnw2.verifying_key().hex()] dw1 = Wallet() dw2 = Wallet() delegates = [dw1.verifying_key().hex(), dw2.verifying_key().hex()] n1 = '/tmp/n1' make_ipc(n1) mn1 = Network(wallet=mnw1, ctx=self.ctx, socket_base=f'ipc://{n1}', bootnodes=bootnodes, mn_to_find=masternodes, del_to_find=delegates) n2 = '/tmp/n2' make_ipc(n2) mn2 = Network(wallet=mnw2, ctx=self.ctx, socket_base=f'ipc://{n2}', bootnodes=bootnodes, mn_to_find=masternodes, del_to_find=delegates) n3 = '/tmp/n3' make_ipc(n3) d1 = Network(wallet=dw1, ctx=self.ctx, socket_base=f'ipc://{n3}', bootnodes=bootnodes, mn_to_find=masternodes, del_to_find=delegates) n4 = '/tmp/n4' make_ipc(n4) d2 = Network(wallet=dw2, ctx=self.ctx, socket_base=f'ipc://{n4}', bootnodes=bootnodes, mn_to_find=masternodes, del_to_find=delegates) # should test to see all ready signals are recieved tasks = asyncio.gather(mn1.start(), mn2.start(), d1.start(), d2.start()) loop = asyncio.get_event_loop() loop.run_until_complete(tasks)
def test_resync_adds_new_contacts(self): p1 = Network(wallet=self.wallet, ctx=self.ctx, socket_base='tcp://127.0.0.1') p1.peer_service.table = self.peer_table p = Peers(wallet=self.wallet, ctx=self.ctx, parameters=self.paramaters, node_type=MN, service_type=ServiceType.INCOMING_WORK) self.authenticator.sync_certs() async def late_refresh(): await asyncio.sleep(0.3) await self.paramaters.refresh() p.sync_sockets() async def stop(): await asyncio.sleep(0.5) p1.stop() tasks = asyncio.gather(p1.start(discover=False), late_refresh(), stop()) self.loop.run_until_complete(tasks) socket_1 = p.sockets.get(self.test_wallet_1.verifying_key().hex()) self.assertIsNotNone(socket_1) new_wallet = Wallet() p1.peer_service.table[ new_wallet.verifying_key().hex()] = 'ipc:///tmp/n3' self.contacts.masternodes.append(new_wallet.verifying_key().hex()) self.authenticator.sync_certs() async def late_refresh(): await asyncio.sleep(0.3) await self.paramaters.refresh() p.sync_sockets() async def stop(): await asyncio.sleep(0.5) p1.stop() tasks = asyncio.gather(p1.start(discover=False), late_refresh(), stop()) self.loop.run_until_complete(tasks) socket_1 = p.sockets.get(new_wallet.verifying_key().hex()) self.assertIsNotNone(socket_1)
def test_verifying_key_as_bytes(self): w = Wallet() _w = w.verifying_key() self.assertTrue(isinstance(_w, bytes)) _h = w.verifying_key(as_hex=True) self.assertTrue(isinstance(_h, str))
def get_tx_batch(): w = Wallet() tx = TransactionBuilder( sender='stu', contract='testing', function='set', kwargs={'var': 'howdy'}, stamps=100_000, processor=b'\x00' * 32, nonce=0 ) tx.sign(w.signing_key()) tx.serialize() currency_contract = 'currency' balances_hash = 'balances' balances_key = '{}{}{}{}{}'.format(currency_contract, config.INDEX_SEPARATOR, balances_hash, config.DELIMITER, w.verifying_key().hex()) driver = BlockchainDriver() driver.set(balances_key, 1_000_000) driver.commit() w = Wallet() tx2 = TransactionBuilder( sender='stu', contract='testing', function='get', kwargs={}, stamps=100_000, processor=b'\x00' * 32, nonce=0 ) tx2.sign(Wallet().signing_key()) tx2.serialize() currency_contract = 'currency' balances_hash = 'balances' balances_key = '{}{}{}{}{}'.format(currency_contract, config.INDEX_SEPARATOR, balances_hash, config.DELIMITER, w.verifying_key().hex()) driver = BlockchainDriver() driver.set(balances_key, 1_000_000) driver.commit() return transaction_list_to_transaction_batch([tx.struct, tx2.struct], wallet=Wallet())
def test_get_nonce_pending_nonce_is_none_returns_0(self): w2 = Wallet() _, response = self.ws.app.test_client.get('/nonce/{}'.format( w2.verifying_key().hex())) expected = { 'nonce': 0, 'processor': self.w.verifying_key().hex(), 'sender': w2.verifying_key().hex() } self.assertDictEqual(response.json, expected)
def test_serialize_returns_bytes(self): w = Wallet() tx = TransactionBuilder(sender=w.verifying_key().hex(), stamps=1000000, contract='currency', function='transfer', kwargs={'amount': 'b'}, processor=b'\x00'*32, nonce=0) tx.sign(w.signing_key()) tx_packed = tx.serialize() self.assertTrue(verify_packed_tx(w.verifying_key(), tx_packed))
def test_other_peers_add_new_nodes_when_join_event_occurs_ipc(self): # N3 runs discovery server and pings N1 # N1 checks to see if N3 is valid, and if so, adds to their table and pings N2 about the new join # Create Network service w1 = Wallet() p1 = Network(wallet=w1, ctx=self.ctx, socket_base='ipc:///tmp/n1') # Create Network service w2 = Wallet() p2 = Network(wallet=w2, ctx=self.ctx, socket_base='ipc:///tmp/n2') p2.peer_service.event_service.add_subscription( _socket('ipc:///tmp/n1/events')) # Create Discovery Server w3 = Wallet() d = DiscoveryServer(wallet=w3, socket_id=_socket('ipc:///tmp/n3/discovery'), pepper=PEPPER.encode(), ctx=self.ctx, poll_timeout=2000, linger=2000) # TCP takes a bit longer to bind and is prone to dropping messages... sleep(1) # Construct the join RPC message join_message = ['join', (w3.verifying_key().hex(), 'ipc:///tmp/n3')] join_message = json.dumps(join_message).encode() tasks = asyncio.gather( p1.peer_service.start(), p2.peer_service.start(), d.serve(), services.get(_socket('ipc:///tmp/n1/peers'), msg=join_message, ctx=self.ctx, timeout=1000), stop_server(p1.peer_service, 2), stop_server(p2.peer_service, 2), stop_server(d, 2), ) loop = asyncio.get_event_loop() loop.run_until_complete(tasks) self.assertTrue(w3.verifying_key().hex() in p2.peer_service.table)
def test_all_valid_with_stamps_when_balance_is_set(self): w = Wallet() expected_processor = secrets.token_bytes(32) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, tx.payload.sender.hex()) self.nonce_manager.set(balances_key, 500000) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager) balance = self.nonce_manager.get(balances_key) or 0 self.assertEqual(balance, 500000)
def test_discover_works_with_ipc_sockets(self): wallet = Wallet() d = DiscoveryServer(_socket('ipc:///tmp/discovery'), wallet, b'CORRECT_PEPPER', ctx=self.ctx) success_task = ping(_socket('ipc:///tmp/discovery'), pepper=b'CORRECT_PEPPER', ctx=self.ctx, timeout=300) failure_task = ping(_socket('tcp://127.0.0.1:20999'), pepper=b'CORRECT_PEPPER', ctx=self.ctx, timeout=300) async def stop_server(timeout): await asyncio.sleep(timeout) d.stop() tasks = asyncio.gather(success_task, failure_task, d.serve(), stop_server(0.3)) loop = asyncio.get_event_loop() results = loop.run_until_complete(tasks) vk_ip1, vk_ip2, _, _ = results _, vk1 = vk_ip1 _, vk2 = vk_ip2 self.assertEqual(vk1.hex(), wallet.verifying_key().hex()) self.assertIsNone(vk2)
def test_processor_and_nonce_correct_but_not_enough_stamps_returns_false(self): w = Wallet() expected_processor = secrets.token_bytes(32) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) with self.assertRaises(transaction.TransactionSenderTooFewStamps): transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, tx.payload.sender.hex()) balance = self.nonce_manager.get(balances_key) or 0 self.assertEqual(balance, 0)
def test_current_contacts_joins_mn_seed(self): n1 = '/tmp/n1' make_ipc(n1) mnw1 = Wallet() mn1 = Network(wallet=mnw1, ctx=self.ctx, socket_base=f'ipc://{n1}') mn1.peer_service.table = {'a': 'b', 'c': 'd', 'e': 'f'} mnw2 = Wallet() n2 = '/tmp/n2' make_ipc(n2) mn2 = Network(wallet=mnw2, ctx=self.ctx, socket_base=f'ipc://{n2}', mn_seed='ipc:///tmp/n1') tasks = asyncio.gather(mn1.peer_service.start(), mn2.discovery_server.serve(), stop_server(mn2.discovery_server, 0.3), stop_server(mn1.peer_service, 0.3), mn2.get_current_contacts()) loop = asyncio.get_event_loop() loop.run_until_complete(tasks) self.assertEqual(mn1.peer_service.table[mnw2.verifying_key().hex()], 'ipc:///tmp/n2')
def test_find_node_gets_node_from_self_if_asked_from_self_and_has_it_as_peer_ipc( self): # Create Network service w1 = Wallet() p1 = Network(wallet=w1, ctx=self.ctx, socket_base='ipc:///tmp') w2 = Wallet() p1.peer_service.table[w2.verifying_key().hex()] = 'ipc:///tmp123' async def get(): return await p1.find_node(p1.peer_service_address, w2.verifying_key().hex()) loop = asyncio.get_event_loop() res = loop.run_until_complete(get()) self.assertEqual(res.get(w2.verifying_key().hex()), 'ipc:///tmp123')
def test_verify_vk_pepper_wrong_vk_pepper_message(self): wallet = Wallet() vk = wallet.verifying_key() pepper = b'TESTING_PEPPER' pepper_msg = vk + wallet.sign(pepper) self.assertFalse(verify_vk_pepper(pepper_msg, b'WRONG_PEPPER'))
def test_verify_vk_pepper_correct_vk_pepper_message(self): wallet = Wallet() vk = wallet.verifying_key() pepper = b'TESTING_PEPPER' pepper_msg = vk + wallet.sign(pepper) self.assertTrue(verify_vk_pepper(pepper_msg, pepper))
def test_retreived_subblocks_serialize_to_block_properly_single_block(self): bootnodes = ['ipc:///tmp/n2', 'ipc:///tmp/n3'] mnw1 = Wallet() dw1 = Wallet() constitution = { "masternodes": { "vk_list": [ mnw1.verifying_key().hex(), ], "min_quorum": 1 }, "delegates": { "vk_list": [ dw1.verifying_key().hex(), ], "min_quorum": 1 }, "witnesses": {}, "schedulers": {}, "notifiers": {}, "enable_stamps": False, "enable_nonces": False } n1 = '/tmp/n1' make_ipc(n1) m = Masternode( wallet=mnw1, ctx=self.ctx, socket_base=f'ipc://{n1}', bootnodes=bootnodes, constitution=constitution, webserver_port=8080, overwrite=True ) input_hash = secrets.token_bytes(32) sbc = random_txs.sbc_from_txs(input_hash, b'\x00' * 32, w=dw1, idx=0, poisoned_sig=b'\x00' * 64) b = m.sbcs_to_block([sbc]) print(b)
def test_init(self): w = Wallet() TransactionBuilder(sender=w.verifying_key().hex(), stamps=1000000, contract='currency', function='transfer', kwargs={'amount': 'b'}, processor=b'\x00' * 32, nonce=0)
def build_nodes(num_nodes=1) -> list: nodes = [] for i in range(num_nodes): i = Wallet() nodes.append({ 'sk': i.signing_key(as_hex=True), 'vk': i.verifying_key(as_hex=True) }) print(nodes)
def test_passing_float_in_contract_kwargs_raises_assertion(self): w = Wallet() with self.assertRaises(AssertionError): TransactionBuilder(sender=w.verifying_key().hex(), stamps=1000000, contract='currency', function='transfer', kwargs={'amount': 123.00}, processor=b'\x00' * 32, nonce=0)
def test_non_strict_fails_if_same_nonce(self): w = Wallet() expected_processor = secrets.token_bytes(32) balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) self.nonce_manager.set(balances_key, 500000) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager, strict=False) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={'amount': 10, 'to': 'jeff'}, stamps=500000, processor=expected_processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() tx_struct = transaction_capnp.NewTransaction.from_bytes_packed(tx_bytes) with self.assertRaises(transaction.TransactionNonceInvalid): transaction_is_valid(tx=tx_struct, expected_processor=expected_processor, driver=self.nonce_manager, strict=False)
def make_good_tx(processor): w = Wallet() balances_key = '{}{}{}{}{}'.format('currency', config.INDEX_SEPARATOR, 'balances', config.DELIMITER, w.verifying_key().hex()) n.set(balances_key, 500000) tx = TransactionBuilder(w.verifying_key(), contract='currency', function='transfer', kwargs={ 'amount': 10, 'to': 'jeff' }, stamps=500000, processor=processor, nonce=0) tx.sign(w.signing_key()) tx_bytes = tx.serialize() return tx_bytes