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
