def test_acquire_work_2_masters_gathers_tx_batches_pads_work_and_waits_if_missing(
self):
ips = ['tcp://127.0.0.1:18001', 'tcp://127.0.0.1:18002']
dw = Wallet()
mw = Wallet()
mw2 = Wallet()
self.authenticator.add_verifying_key(mw.verifying_key)
self.authenticator.add_verifying_key(dw.verifying_key)
self.authenticator.configure()
mn = masternode.Masternode(socket_base=ips[0],
ctx=self.ctx,
wallet=mw,
constitution={
'masternodes':
[mw.verifying_key, mw2.verifying_key],
'delegates': [dw.verifying_key]
},
driver=ContractDriver(driver=InMemDriver()))
dl = delegate.Delegate(socket_base=ips[1],
ctx=self.ctx,
wallet=dw,
constitution={
'masternodes':
[mw.verifying_key, mw2.verifying_key],
'delegates': [dw.verifying_key]
},
driver=ContractDriver(driver=InMemDriver()))
peers = {
mw.verifying_key: ips[0],
dw.verifying_key: ips[1],
mw2.verifying_key: 'tpc://127.0.0.1:18003'
}
mn.network.peers = peers
dl.network.peers = peers
tasks = asyncio.gather(
mn.router.serve(),
dl.router.serve(),
mn.send_work(),
dl.acquire_work(),
stop_server(mn.router, 1),
stop_server(dl.router, 1),
)
_, _, _, w, _, _ = self.loop.run_until_complete(tasks)
self.assertEqual(len(w), 2)
self.assertEqual(w[0]['sender'], mw.verifying_key)
self.assertEqual(w[1]['sender'], mw2.verifying_key)
self.assertEqual(w[1]['input_hash'], mw2.verifying_key)
self.assertEqual(w[1]['signature'], '0' * 128)
def make_network(masternodes,
delegates,
ctx,
mn_min_quorum=2,
del_min_quorum=2):
mn_wallets = [Wallet() for _ in range(masternodes)]
dl_wallets = [Wallet() for _ in range(delegates)]
constitution = {
'masternodes': [mn.verifying_key().hex() for mn in mn_wallets],
'delegates': [dl.verifying_key().hex() for dl in dl_wallets],
'masternode_min_quorum': mn_min_quorum,
'delegate_min_quorum': del_min_quorum,
}
mns = []
dls = []
bootnodes = None
node_count = 0
for wallet in mn_wallets:
driver = BlockchainDriver(driver=InMemDriver())
# driver = IsolatedDriver()
ipc = f'/tmp/n{node_count}'
make_ipc(ipc)
if bootnodes is None:
bootnodes = [f'ipc://{ipc}']
mn = Masternode(wallet=wallet,
ctx=ctx,
socket_base=f'ipc://{ipc}',
bootnodes=bootnodes,
constitution=deepcopy(constitution),
webserver_port=18080 + node_count,
driver=driver)
mns.append(mn)
node_count += 1
for wallet in dl_wallets:
driver = BlockchainDriver(driver=InMemDriver())
# driver = IsolatedDriver()
ipc = f'/tmp/n{node_count}'
make_ipc(ipc)
dl = Delegate(wallet=wallet,
ctx=ctx,
socket_base=f'ipc://{ipc}',
constitution=deepcopy(constitution),
bootnodes=bootnodes,
driver=driver)
dls.append(dl)
node_count += 1
return mns, dls
def test_masternode_delegate_single_loop_works(self):
ips = [
'tcp://127.0.0.1:18001',
'tcp://127.0.0.1:18002'
]
dw = Wallet()
mw = Wallet()
self.authenticator.add_verifying_key(mw.verifying_key)
self.authenticator.add_verifying_key(dw.verifying_key)
self.authenticator.configure()
mn = masternode.Masternode(
socket_base=ips[0],
ctx=self.ctx,
wallet=mw,
constitution={
'masternodes': [mw.verifying_key],
'delegates': [dw.verifying_key]
},
driver=ContractDriver(driver=InMemDriver())
)
dl = delegate.Delegate(
socket_base=ips[1],
ctx=self.ctx,
wallet=dw,
constitution={
'masternodes': [mw.verifying_key],
'delegates': [dw.verifying_key]
},
driver=ContractDriver(driver=InMemDriver())
)
peers = {
mw.verifying_key: ips[0],
dw.verifying_key: ips[1]
}
mn.network.peers = peers
dl.network.peers = peers
tasks = asyncio.gather(
mn.router.serve(),
dl.router.serve(),
mn.loop(),
dl.loop(),
stop_server(mn.router, 1),
stop_server(dl.router, 1),
)
self.loop.run_until_complete(tasks)
def test_process_new_work_processes_tx_batch(self):
ips = ['tcp://127.0.0.1:18001', 'tcp://127.0.0.1:18002']
dw = Wallet()
mw = Wallet()
self.authenticator.add_verifying_key(mw.verifying_key)
self.authenticator.add_verifying_key(dw.verifying_key)
self.authenticator.configure()
mn = masternode.Masternode(socket_base=ips[0],
ctx=self.ctx,
wallet=mw,
constitution={
'masternodes': [mw.verifying_key],
'delegates': [dw.verifying_key]
},
driver=ContractDriver(driver=InMemDriver()))
mnq = router.QueueProcessor()
mn.router.add_service(base.CONTENDER_SERVICE, mnq)
dl = delegate.Delegate(socket_base=ips[1],
ctx=self.ctx,
wallet=dw,
constitution={
'masternodes': [mw.verifying_key],
'delegates': [dw.verifying_key]
},
driver=ContractDriver(driver=InMemDriver()))
peers = {mw.verifying_key: ips[0], dw.verifying_key: ips[1]}
mn.network.peers = peers
dl.network.peers = peers
tasks = asyncio.gather(
mn.router.serve(),
dl.router.serve(),
mn.send_work(),
dl.process_new_work(),
stop_server(mn.router, 1),
stop_server(dl.router, 1),
)
self.loop.run_until_complete(tasks)
sbc = mnq.q.pop(0)
self.assertEqual(len(sbc), 1)
self.assertEqual(sbc[0]['previous'], '0' * 64)
self.assertEqual(sbc[0]['signer'], dw.verifying_key)
def test_get_masternode_peers_gets_masternodes(self):
mn_wallet = Wallet()
dl_wallet = Wallet()
mn_bootnode = 'tcp://127.0.0.1:18001'
dl_bootnode = 'tcp://127.0.0.1:18002'
constitution = {
'masternodes': [mn_wallet.verifying_key],
'delegates': [dl_wallet.verifying_key]
}
bootnodes = {
mn_wallet.verifying_key: mn_bootnode,
dl_wallet.verifying_key: dl_bootnode
}
node_w = Wallet()
driver = ContractDriver(driver=InMemDriver())
node = base.Node(socket_base='tcp://127.0.0.1:18003',
ctx=self.ctx,
wallet=node_w,
constitution=constitution,
driver=driver,
store=False,
bootnodes=bootnodes)
# Assume caught up state
node.network.peers = bootnodes
m = node.get_masternode_peers()
self.assertEqual(m, {mn_wallet.verifying_key: mn_bootnode})
def test_process_new_block_cleans_nbn(self):
blocks = generate_blocks(2)
driver = ContractDriver(driver=InMemDriver())
node = base.Node(
socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes': [Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver,
store=True,
blocks=self.blocks,
)
# Add one old and one new block.
# Function should only delete the old one
node.new_block_processor.q.append(blocks[0])
node.new_block_processor.q.append(blocks[1])
node.process_new_block(blocks[0])
block = node.new_block_processor.q[0]
self.assertEqual(block, blocks[1])
self.assertEqual(len(node.new_block_processor.q), 1)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
self.driver = ContractDriver(driver=InMemDriver())
asyncio.set_event_loop(self.loop)
self.authenticator = authentication.SocketAuthenticator(
client=ContractingClient(driver=self.driver), ctx=self.ctx)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
self.driver = ContractDriver(driver=InMemDriver())
self.client = ContractingClient(driver=self.driver)
self.client.flush()
asyncio.set_event_loop(self.loop)
def test_broadcast_new_chain_sends_messages_to_all_peers(self):
mn_wallet = Wallet()
mn_bootnode = 'tcp://127.0.0.1:18001'
mn_router = router.Router(wallet=mn_wallet,
socket_id=mn_bootnode,
ctx=self.ctx,
secure=True)
dl_wallet = Wallet()
dl_bootnode = 'tcp://127.0.0.1:18002'
dl_router = router.Router(wallet=dl_wallet,
socket_id=dl_bootnode,
ctx=self.ctx,
secure=True)
driver = ContractDriver(driver=InMemDriver())
node = masternode.Masternode(socket_base='tcp://127.0.0.1:18003',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes':
[mn_wallet.verifying_key],
'delegates':
[dl_wallet.verifying_key]
},
driver=driver)
node.client.set_var(contract='masternodes',
variable='S',
arguments=['members'],
value=[mn_wallet.verifying_key])
node.client.set_var(contract='delegates',
variable='S',
arguments=['members'],
value=[dl_wallet.verifying_key])
node.socket_authenticator.refresh_governance_sockets()
node.network.peers = {
mn_wallet.verifying_key: mn_bootnode,
dl_wallet.verifying_key: dl_bootnode
}
node.tx_batcher.queue.append('MOCK TX')
tasks = asyncio.gather(mn_router.serve(), dl_router.serve(),
node.broadcast_new_blockchain_started(),
stop_server(mn_router, 0.2),
stop_server(dl_router, 0.2))
self.loop.run_until_complete(tasks)
def test_hang_returns_if_not_running(self):
driver = ContractDriver(driver=InMemDriver())
node = masternode.Masternode(socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes':
[Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver)
self.loop.run_until_complete(node.hang())
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.blocks = storage.BlockStorage()
self.driver = ContractDriver(driver=InMemDriver())
self.b = masternode.BlockService(blocks=self.blocks,
driver=self.driver)
self.blocks.drop_collections()
self.driver.flush()
self.authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
def test_send_work_returns_if_no_one_online(self):
driver = ContractDriver(driver=InMemDriver())
node_wallet = Wallet()
node = masternode.Masternode(socket_base='tcp://127.0.0.1:18003',
ctx=self.ctx,
wallet=node_wallet,
constitution={
'masternodes':
[Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver)
r = self.loop.run_until_complete(node.send_work())
self.assertFalse(r)
def test_should_process_block_true_if_expected_block_equal_to_block(self):
block = canonical.block_from_subblocks(subblocks=[],
previous_hash='0' * 64,
block_num=1)
driver = ContractDriver(driver=InMemDriver())
node = base.Node(socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes': [Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver)
self.assertTrue(node.should_process(block))
def test_broadcast_new_chain_does_nothing_if_no_tx(self):
driver = ContractDriver(driver=InMemDriver())
node = masternode.Masternode(socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes':
[Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver)
node.client.set_var(contract='masternodes',
variable='S',
arguments=['members'],
value=['stu', 'jeff'])
def test_catchup_with_nbn_added(self):
driver = ContractDriver(driver=InMemDriver())
mn_bootnode = 'tcp://127.0.0.1:18001'
mn_wallet = Wallet()
mn_router = router.Router(socket_id=mn_bootnode,
ctx=self.ctx,
secure=True,
wallet=mn_wallet)
mn_router.add_service(base.BLOCK_SERVICE, self.b)
nw = Wallet()
dlw = Wallet()
node = base.Node(socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=nw,
constitution={
'masternodes': [mn_wallet.verifying_key],
'delegates': [dlw.verifying_key]
},
driver=driver)
self.authenticator.add_verifying_key(mn_wallet.verifying_key)
self.authenticator.add_verifying_key(nw.verifying_key)
self.authenticator.add_verifying_key(dlw.verifying_key)
self.authenticator.configure()
blocks = generate_blocks(4)
self.blocks.store_block(blocks[0])
self.blocks.store_block(blocks[1])
self.blocks.store_block(blocks[2])
storage.set_latest_block_height(3, self.driver)
node.new_block_processor.q.append(blocks[3])
tasks = asyncio.gather(
mn_router.serve(),
node.catchup('tcp://127.0.0.1:18001', mn_wallet.verifying_key),
stop_server(mn_router, 1))
self.loop.run_until_complete(tasks)
self.assertEqual(storage.get_latest_block_height(node.driver), 4)
def test_should_process_block_false_if_previous_if_not_current_hash(self):
block = {
'hash': 'a' * 64,
'number': 1,
'previous': 'b' * 64,
'subblocks': []
}
driver = ContractDriver(driver=InMemDriver())
node = base.Node(socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes': [Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver)
self.assertFalse(node.should_process(block))
def test_process_new_block_updates_state(self):
block = canonical.block_from_subblocks(subblocks=[],
previous_hash='0' * 64,
block_num=1)
driver = ContractDriver(driver=InMemDriver())
node = base.Node(socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes': [Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver)
node.process_new_block(block)
self.assertEqual(storage.get_latest_block_height(node.driver), 1)
self.assertEqual(storage.get_latest_block_hash(node.driver),
block['hash'])
def test_hang_until_nbn_has_block(self):
driver = ContractDriver(driver=InMemDriver())
node = masternode.Masternode(socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes':
[Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver)
node.running = True
async def late_tx(timeout=0.2):
await asyncio.sleep(timeout)
node.new_block_processor.q.append('MOCK BLOCK')
tasks = asyncio.gather(node.hang(), late_tx())
self.loop.run_until_complete(tasks)
def test_process_new_block_stores_block_if_should_store(self):
block = canonical.block_from_subblocks(subblocks=[],
previous_hash='0' * 64,
block_num=1)
driver = ContractDriver(driver=InMemDriver())
node = base.Node(
socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes': [Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver,
store=True,
blocks=self.blocks,
)
node.process_new_block(block)
b = node.blocks.get_block(1)
self.assertEqual(b, block)
def test_process_new_block_clears_cache(self):
block = canonical.block_from_subblocks(subblocks=[],
previous_hash='0' * 64,
block_num=1)
driver = ContractDriver(driver=InMemDriver())
node = base.Node(
socket_base='tcp://127.0.0.1:18002',
ctx=self.ctx,
wallet=Wallet(),
constitution={
'masternodes': [Wallet().verifying_key],
'delegates': [Wallet().verifying_key]
},
driver=driver,
store=True,
blocks=self.blocks,
)
node.driver.cache['test'] = 123
node.process_new_block(block)
self.assertIsNone(node.driver.cache.get('test'))
def setUp(self):
self.d = InMemDriver()
self.d.flush()
class TestInMemDriver(TestCase):
# Flush this sucker every test
def setUp(self):
self.d = InMemDriver()
self.d.flush()
def tearDown(self):
self.d.flush()
def test_get_set(self):
for v in TEST_DATA:
self.d.set('b', v)
b = self.d.get('b')
self.assertEqual(
v, b) if not isinstance(v, dict) else self.assertDictEqual(
v, b)
def test_delete(self):
for v in TEST_DATA:
self.d.set('b', v)
b = self.d.get('b')
self.assertEqual(
v, b) if not isinstance(v, dict) else self.assertDictEqual(
v, b)
self.d.delete('b')
b = self.d.get('b')
self.assertIsNone(b)
def test_iter(self):
prefix_1_keys = [
'b77aa343e339bed781c7c2be1267cd597',
'bc22ede6e6fb4046d78bf2f9d1f8afdb6',
'b93dbb37d993846d70b8a92779cbfbfe9',
'be1a2783019de6ea7ef169cc55e48a3ae',
'b1fe8db32b9185d628f4c346f0455023e',
'bef918f83b6a0d1e4f980013342807cf8',
'b004cb9235acb5f689d20904692bc026e',
'b869ff9519d67354816af90867f4a5425',
'bcd8e9100dcb601f65e849c147e3e972e',
'b0111919a698f9816862b4ae662a6ed06',
]
prefix_2_keys = [
'x37fbab0bd2e60563c79469e5be41e515',
'x30c6eb2ad176773b5ce6d590d2472dfe',
'x3d4fc9480f0a07b28aa7646d5066b54d',
'x387c3d4ab7f0c1c6ef549198fc14b525',
'x5c74dc83e132e435e8512599e1075bc0',
'x1472425d0d9bb5ff511e132896d54b13',
'x2cedb5c52163c22a0b5f179001959dd2',
'x6223f65e553280cd25cadeac6657555c',
'xeae18af37c223dde92a71fef55e64afe',
'xb8810784ffb360cd3ffc57b1d088e537',
]
keys = prefix_1_keys + prefix_2_keys
random.shuffle(keys)
for k in keys:
self.d.set(k, k)
p1 = []
for k in self.d.iter(prefix='b'):
p1.append(k)
prefix_1_keys.sort()
p1.sort()
self.assertListEqual(prefix_1_keys, p1)
p2 = []
for k in self.d.iter(prefix='x'):
p2.append(k)
prefix_2_keys.sort()
p2.sort()
self.assertListEqual(prefix_2_keys, p2)
def test_set_object_returns_properly(self):
thing = {'a': 123, 'b': False, 'x': None}
self.d.set('thing', thing)
t = self.d.get('thing')
self.assertDictEqual(thing, t)
def test_set_none_deletes(self):
t = 123
self.d.set('t', t)
self.assertEqual(self.d.get('t'), 123)
self.d.set('t', None)
self.assertEqual(self.d.get('t'), None)
def test_delete_sets_to_none(self):
t = 123
self.d.set('t', t)
self.assertEqual(self.d.get('t'), 123)
self.d.delete('t')
self.assertEqual(self.d.get('t'), None)
def test_getitem_works_like_get(self):
thing = {'a': 123, 'b': False, 'x': None}
self.d.set('thing', thing)
t = self.d['thing']
self.assertDictEqual(thing, t)
def test_setitem_works_like_set(self):
thing = {'a': 123, 'b': False, 'x': None}
self.d['thing'] = thing
t = self.d['thing']
self.assertDictEqual(thing, t)
def test_delitem_works_like_del(self):
t = 123
self.d.set('t', t)
self.assertEqual(self.d.get('t'), 123)
del self.d['t']
self.assertEqual(self.d.get('t'), None)
def test_iter_with_length_returns_list_of_size_l(self):
prefix_1_keys = [
'b77aa343e339bed781c7c2be1267cd597',
'bc22ede6e6fb4046d78bf2f9d1f8afdb6',
'b93dbb37d993846d70b8a92779cbfbfe9',
'be1a2783019de6ea7ef169cc55e48a3ae',
'b1fe8db32b9185d628f4c346f0455023e',
'bef918f83b6a0d1e4f980013342807cf8',
'b004cb9235acb5f689d20904692bc026e',
'b869ff9519d67354816af90867f4a5425',
'bcd8e9100dcb601f65e849c147e3e972e',
'b0111919a698f9816862b4ae662a6ed06',
]
prefix_2_keys = [
'x37fbab0bd2e60563c79469e5be41e515',
'x30c6eb2ad176773b5ce6d590d2472dfe',
'x3d4fc9480f0a07b28aa7646d5066b54d',
'x387c3d4ab7f0c1c6ef549198fc14b525',
'x5c74dc83e132e435e8512599e1075bc0',
'x1472425d0d9bb5ff511e132896d54b13',
'x2cedb5c52163c22a0b5f179001959dd2',
'x6223f65e553280cd25cadeac6657555c',
'xeae18af37c223dde92a71fef55e64afe',
'xb8810784ffb360cd3ffc57b1d088e537',
]
keys = prefix_1_keys + prefix_2_keys
random.shuffle(keys)
for k in keys:
self.d.set(k, k)
p1 = []
for k in self.d.iter(prefix='b', length=3):
p1.append(k)
prefix_1_keys.sort()
p1.sort()
self.assertListEqual(prefix_1_keys[:3], p1)
p2 = []
for k in self.d.iter(prefix='x', length=5):
p2.append(k)
prefix_2_keys.sort()
p2.sort()
self.assertListEqual(prefix_2_keys[:5], p2)
def test_key_error_if_getitem_doesnt_exist(self):
with self.assertRaises(KeyError):
print(self.d['thing'])
def test_keys_returns_all_keys(self):
prefix_1_keys = [
'b77aa343e339bed781c7c2be1267cd597',
'bc22ede6e6fb4046d78bf2f9d1f8afdb6',
'b93dbb37d993846d70b8a92779cbfbfe9',
'be1a2783019de6ea7ef169cc55e48a3ae',
'b1fe8db32b9185d628f4c346f0455023e',
'bef918f83b6a0d1e4f980013342807cf8',
'b004cb9235acb5f689d20904692bc026e',
'b869ff9519d67354816af90867f4a5425',
'bcd8e9100dcb601f65e849c147e3e972e',
'b0111919a698f9816862b4ae662a6ed06',
]
prefix_2_keys = [
'x37fbab0bd2e60563c79469e5be41e515',
'x30c6eb2ad176773b5ce6d590d2472dfe',
'x3d4fc9480f0a07b28aa7646d5066b54d',
'x387c3d4ab7f0c1c6ef549198fc14b525',
'x5c74dc83e132e435e8512599e1075bc0',
'x1472425d0d9bb5ff511e132896d54b13',
'x2cedb5c52163c22a0b5f179001959dd2',
'x6223f65e553280cd25cadeac6657555c',
'xeae18af37c223dde92a71fef55e64afe',
'xb8810784ffb360cd3ffc57b1d088e537',
]
keys = prefix_1_keys + prefix_2_keys
random.shuffle(keys)
for k in keys:
self.d.set(k, k)
keys.sort()
got_keys = self.d.keys()
self.assertListEqual(keys, got_keys)
def test_tx_network_bootup(self):
bootnodes = ['ipc:///tmp/n1', 'ipc:///tmp/n3']
mnw1 = Wallet()
mnw2 = Wallet()
dw1 = Wallet()
dw2 = Wallet()
constitution = {
'masternodes': [mnw1.verifying_key, mnw2.verifying_key],
'delegates': [dw1.verifying_key, dw2.verifying_key],
'witnesses': [],
'schedulers': [],
'notifiers': [],
'enable_stamps': False,
'enable_nonces': False,
'masternode_min_quorum': 2,
'delegate_min_quorum': 2,
'witness_min_quorum': 0,
'notifier_min_quorum': 0,
'scheduler_min_quorum': 0
}
md1 = StateDriver(driver=InMemDriver())
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,
driver=md1)
md2 = StateDriver(driver=InMemDriver())
n2 = '/tmp/n2'
make_ipc(n2)
mn2 = Masternode(wallet=mnw2,
ctx=self.ctx,
socket_base=f'ipc://{n2}',
bootnodes=bootnodes,
constitution=constitution,
webserver_port=8081,
driver=md2)
dd1 = StateDriver(driver=InMemDriver())
n3 = '/tmp/n3'
make_ipc(n3)
d1 = Delegate(wallet=dw1,
ctx=self.ctx,
socket_base=f'ipc://{n3}',
constitution=constitution,
bootnodes=bootnodes,
driver=dd1)
dd2 = StateDriver(driver=InMemDriver())
n4 = '/tmp/n4'
make_ipc(n4)
d2 = Delegate(wallet=dw2,
ctx=self.ctx,
socket_base=f'ipc://{n4}',
constitution=constitution,
bootnodes=bootnodes,
driver=dd2)
# should test to see all ready signals are recieved
tasks = asyncio.gather(mn1.start(), mn2.start(), d1.start(),
d2.start())
async def run():
await tasks
async with aiohttp.ClientSession() as session:
r = await session.post('http://127.0.0.1:8081/',
data=make_tx_packed(
mnw2.verifying_key,
'testing',
'test',
drivers=[md1, md2, dd1, dd2]))
res = await r.json()
print(res)
#self.assertEqual(res['success'], 'Transaction successfully submitted to the network.')
await asyncio.sleep(10)
mn1.stop()
mn2.stop()
d1.stop()
d2.stop()
loop = asyncio.get_event_loop()
loop.run_until_complete(run())
def test_start_boots_up_normally(self):
# This MN will also provide 'catch up' services
mn_bootnode = 'tcp://127.0.0.1:18001'
mn_wallet = Wallet()
mn_router = router.Router(socket_id=mn_bootnode,
ctx=self.ctx,
secure=True,
wallet=mn_wallet)
mn_network = network.Network(wallet=mn_wallet,
ip_string=mn_bootnode,
ctx=self.ctx,
router=mn_router)
blocks = generate_blocks(4)
self.blocks.store_block(blocks[0])
self.blocks.store_block(blocks[1])
self.blocks.store_block(blocks[2])
storage.set_latest_block_height(3, self.driver)
mn_router.add_service(
base.BLOCK_SERVICE,
masternode.BlockService(self.blocks, self.driver))
dl_bootnode = 'tcp://127.0.0.1:18002'
dl_wallet = Wallet()
dl_router = router.Router(socket_id=dl_bootnode,
ctx=self.ctx,
secure=True,
wallet=dl_wallet)
dl_network = network.Network(wallet=dl_wallet,
ip_string=dl_bootnode,
ctx=self.ctx,
router=dl_router)
constitution = {
'masternodes': [mn_wallet.verifying_key],
'delegates': [dl_wallet.verifying_key]
}
bootnodes = {
mn_wallet.verifying_key: mn_bootnode,
dl_wallet.verifying_key: dl_bootnode
}
node_w = Wallet()
driver = ContractDriver(driver=InMemDriver())
node = base.Node(socket_base='tcp://127.0.0.1:18003',
ctx=self.ctx,
wallet=node_w,
constitution=constitution,
driver=driver,
store=False,
bootnodes=bootnodes)
self.authenticator.add_verifying_key(mn_wallet.verifying_key)
self.authenticator.add_verifying_key(dl_wallet.verifying_key)
self.authenticator.add_verifying_key(node_w.verifying_key)
self.authenticator.configure()
vks = [mn_wallet.verifying_key, dl_wallet.verifying_key]
tasks = asyncio.gather(
mn_router.serve(),
dl_router.serve(),
mn_network.start(bootnodes, vks),
dl_network.start(bootnodes, vks),
stop_server(mn_router, 0.2),
stop_server(dl_router, 0.2),
)
self.loop.run_until_complete(tasks)
tasks = asyncio.gather(mn_router.serve(), dl_router.serve(),
node.start(), stop_server(mn_router, 1),
stop_server(dl_router, 1),
stop_server(node.router, 1))
self.loop.run_until_complete(tasks)
self.assertEqual(storage.get_latest_block_height(node.driver), 3)
self.assertEqual(storage.get_latest_block_hash(node.driver),
blocks[2]['hash'])
def test_masternode_delegate_single_loop_updates_block_num(self):
ips = [
'tcp://127.0.0.1:18001',
'tcp://127.0.0.1:18002'
]
dw = Wallet()
mw = Wallet()
self.authenticator.add_verifying_key(mw.verifying_key)
self.authenticator.add_verifying_key(dw.verifying_key)
self.authenticator.configure()
mnd = ContractDriver(driver=InMemDriver())
mn = masternode.Masternode(
socket_base=ips[0],
ctx=self.ctx,
wallet=mw,
constitution={
'masternodes': [mw.verifying_key],
'delegates': [dw.verifying_key]
},
driver=mnd
)
sender = Wallet()
mnd.set_var(contract='currency', variable='balances', arguments=[sender.verifying_key], value=1_000_000)
dld = ContractDriver(driver=InMemDriver())
dld.set_var(contract='currency', variable='balances', arguments=[sender.verifying_key], value=1_000_000)
dl = delegate.Delegate(
socket_base=ips[1],
ctx=self.ctx,
wallet=dw,
constitution={
'masternodes': [mw.verifying_key],
'delegates': [dw.verifying_key]
},
driver=dld
)
tx = transaction.build_transaction(
wallet=sender,
contract='currency',
function='transfer',
kwargs={
'amount': 1338,
'to': 'jeff'
},
stamps=5000,
nonce=0,
processor=mw.verifying_key
)
tx_decoded = decode(tx)
mn.tx_batcher.queue.append(tx_decoded)
peers = {
mw.verifying_key: ips[0],
dw.verifying_key: ips[1]
}
mn.network.peers = peers
dl.network.peers = peers
tasks = asyncio.gather(
mn.router.serve(),
dl.router.serve(),
mn.loop(),
dl.loop(),
stop_server(mn.router, 1),
stop_server(dl.router, 1),
)
self.loop.run_until_complete(tasks)
dh = storage.get_latest_block_height(dld)
mh = storage.get_latest_block_height(mnd)
self.assertEqual(dh, 1)
self.assertEqual(mh, 1)
