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)
driver = ContractDriver()
driver.set(balances_key, 1_000_000)
driver.commit()
return tx
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_execute_tx_returns_successful_output(self):
test_contract = '''
v = Variable()
@construct
def seed():
v.set('hello')
@export
def set(var: str):
v.set(var)
@export
def get():
return v.get()
'''
self.client.submit(test_contract, name='testing')
tx = TransactionBuilder(
sender='stu',
contract='testing',
function='set',
kwargs={'var': 'jeff'},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0
)
tx.sign(Wallet().signing_key)
tx.serialize()
result = execution.execute_tx(self.client, tx.struct)
print(result)
self.assertEqual(result.status, 0)
self.assertEqual(result.state[0].key, b'testing.v')
self.assertEqual(result.state[0].value, b'"jeff"')
self.assertEqual(result.stampsUsed, 0)
def test_send_to_delegates_doesnt_hang_if_one_is_not_online(self):
bootnodes = ['ipc:///tmp/n2', 'ipc:///tmp/n3']
mnw1 = Wallet()
mnw2 = Wallet()
dw1 = Wallet()
dw2 = Wallet()
dw3 = Wallet()
dw4 = Wallet()
constitution = {
"masternodes": {
"vk_list": [mnw1.verifying_key, mnw2.verifying_key],
"min_quorum": 1
},
"delegates": {
"vk_list": [
dw1.verifying_key, dw2.verifying_key, dw3.verifying_key,
dw4.verifying_key
],
"min_quorum":
1
},
"witnesses": {},
"schedulers": {},
"notifiers": {},
"enable_stamps": False,
"enable_nonces": False
}
n1 = '/tmp/n1'
make_ipc(n1)
mn1 = Masternode(wallet=mnw1,
ctx=self.ctx,
socket_base=f'ipc://{n1}',
bootnodes=bootnodes,
constitution=constitution,
webserver_port=8080,
overwrite=True)
masternodes = [mnw1.verifying_key, mnw2.verifying_key]
delegates = [
dw1.verifying_key, dw2.verifying_key, dw3.verifying_key,
dw4.verifying_key
]
contacts = MockContacts(masters=masternodes, delegates=delegates)
d1 = '/tmp/d1'
make_ipc(d1)
wi1 = WorkInbox(socket_id=_socket(f'ipc://{d1}/incoming_work'),
ctx=self.ctx,
contacts=contacts,
verify=False)
d2 = '/tmp/d2'
make_ipc(d2)
wi2 = WorkInbox(socket_id=_socket(f'ipc://{d2}/incoming_work'),
ctx=self.ctx,
contacts=contacts,
verify=False)
d3 = '/tmp/d3'
make_ipc(d3)
#wi3 = WorkInbox(socket_id=_socket(f'ipc://{d3}/incoming_work'), ctx=self.ctx, contacts=contacts, verify=False)
d4 = '/tmp/d4'
make_ipc(d4)
wi4 = WorkInbox(socket_id=_socket(f'ipc://{d4}/incoming_work'),
ctx=self.ctx,
contacts=contacts,
verify=False)
w = Wallet()
batch = TransactionBuilder(sender=w.verifying_key,
contract='test',
function='testing',
kwargs={},
stamps=1_000_000,
processor=mnw1.verifying_key,
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)
driver = StateDriver()
driver.set(balances_key, 1_000_000)
driver.commit()
mn1.tx_batcher.queue.append(tx)
mn1.network.peer_service.table.peers = {
dw1.verifying_key: f'ipc://{d1}',
dw2.verifying_key: f'ipc://{d2}',
dw3.verifying_key: f'ipc://{d3}',
dw4.verifying_key: f'ipc://{d4}'
}
async def late_send():
await asyncio.sleep(0.3)
await mn1.parameters.refresh()
return await mn1.send_batch_to_delegates()
async def stop():
await asyncio.sleep(0.5)
wi1.stop()
wi2.stop()
wi4.stop()
mn1.network.stop()
tasks = asyncio.gather(mn1.network.start(False), wi1.serve(),
wi2.serve(), wi4.serve(), late_send(), stop())
_, _, _, _, r, _ = self.loop.run_until_complete(tasks)
# Make sure the right socket failed
for rr in r:
if not rr[0]:
self.assertEqual(rr[1], f'ipc://{d3}/incoming_work')
self.assertTrue(wi1.work[mnw1.verifying_key])
self.assertTrue(wi2.work[mnw1.verifying_key])
self.assertTrue(wi4.work[mnw1.verifying_key])
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)
driver = StateDriver()
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)
driver = StateDriver()
driver.set(balances_key, 1_000_000)
driver.commit()
return transaction_list_to_transaction_batch([tx.struct, tx2.struct],
wallet=Wallet())
def test_execute_work_multiple_transaction_batches_works(self):
test_contract = '''
v = Variable()
@construct
def seed():
v.set('hello')
@export
def set(var):
v.set(var)
@export
def get():
return v.get()
'''
self.client.submit(test_contract, name='testing')
tx = TransactionBuilder(
sender='stu',
contract='testing',
function='set',
kwargs={'var': 'howdy'},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0
)
tx.sign(Wallet().signing_key)
tx.serialize()
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()
tx_batch_1 = transaction_list_to_transaction_batch([tx.struct, tx2.struct], wallet=Wallet())
tx = TransactionBuilder(
sender='stu',
contract='testing',
function='set',
kwargs={'var': '123'},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0
)
tx.sign(Wallet().signing_key)
tx.serialize()
tx2 = TransactionBuilder(
sender='jeff',
contract='testing',
function='set',
kwargs={'var': 'poo'},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0
)
tx2.sign(Wallet().signing_key)
tx2.serialize()
tx_batch_2 = transaction_list_to_transaction_batch([tx.struct, tx2.struct], wallet=Wallet())
work = [
(tx_batch_1.timestamp, tx_batch_1),
(tx_batch_2.timestamp, tx_batch_2)
]
sbc = execution.execute_work(self.client, MockDriver(), work, Wallet(), b'B'*32)
sb1, sb2 = sbc
td1, td2 = sb1.transactions
self.assertEqual(td1.status, 0)
self.assertEqual(td1.state[0].key, b'testing.v')
self.assertEqual(td1.state[0].value, b'"howdy"')
self.assertEqual(td1.stampsUsed, 0)
self.assertEqual(td2.status, 0)
self.assertEqual(len(td2.state), 0)
self.assertEqual(td2.stampsUsed, 0)
self.assertEqual(sb1.inputHash, tx_batch_1.inputHash)
self.assertEqual(sb1.subBlockNum, 0)
self.assertEqual(sb1.prevBlockHash, b'B'*32)
td1, td2 = sb2.transactions
self.assertEqual(td1.status, 0)
self.assertEqual(td1.state[0].key, b'testing.v')
self.assertEqual(td1.state[0].value, b'"123"')
self.assertEqual(td1.stampsUsed, 0)
self.assertEqual(td2.status, 0)
self.assertEqual(td2.state[0].key, b'testing.v')
self.assertEqual(td2.state[0].value, b'"poo"')
self.assertEqual(td2.stampsUsed, 0)
self.assertEqual(sb2.inputHash, tx_batch_2.inputHash)
self.assertEqual(sb2.subBlockNum, 1)
self.assertEqual(sb2.prevBlockHash, b'B' * 32)
def test_execute_tx_batch_returns_all_transactions(self):
test_contract = '''
v = Variable()
@construct
def seed():
v.set('hello')
@export
def set(var):
v.set(var)
@export
def get():
return v.get()
'''
self.client.submit(test_contract, name='testing')
tx = TransactionBuilder(
sender='stu',
contract='testing',
function='set',
kwargs={'var': 'howdy'},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0
)
tx.sign(Wallet().signing_key)
tx.serialize()
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()
tx_batch = transaction_list_to_transaction_batch([tx.struct, tx2.struct], wallet=Wallet())
results = execution.execute_tx_batch(self.client, MockDriver(), tx_batch, time.time(), b'A'*32)
td1, td2 = results
self.assertEqual(td1.status, 0)
self.assertEqual(td1.state[0].key, b'testing.v')
self.assertEqual(td1.state[0].value, b'"howdy"')
self.assertEqual(td1.stampsUsed, 0)
self.assertEqual(td2.status, 0)
self.assertEqual(len(td2.state), 0)
self.assertEqual(td2.stampsUsed, 0)