async def new_blockchain_boot(self):
self.log.info('Fresh blockchain boot.')
await self.parameters.refresh()
self.nbn_socket_book.sync_sockets()
self.delegate_work_socket_book.sync_sockets()
while len(self.tx_batcher.queue) == 0 and len(self.nbn_inbox.q) == 0:
if not self.running:
return
await asyncio.sleep(0)
if len(self.tx_batcher.queue) > 0:
msg = canonical.dict_to_msg_block(canonical.get_genesis_block())
## SEND OUT VIA SOCKETS CLASS
sends = await self.nbn_socket_book.send_to_peers(msg=msg)
self.log.info(f'{sends}')
# await multicast(self.ctx, msg, self.nbn_sockets())
if len(self.contacts.masternodes) > 1:
self.driver.set_latest_block_num(1)
await self.process_blocks()
async def run():
await asyncio.sleep(0.3)
self.assertEqual(d.driver.latest_block_num, 0)
await mock_master.send_new_block_to_socket()
# Assert Block num 1
await asyncio.sleep(0.3)
self.assertEqual(d.driver.latest_block_num, 1)
await mock_master.send_to_work_socket()
w = await mock_master.mn_agg.recv_multipart()
b = canonical.get_genesis_block()
b['blockNum'] = 2
await mock_master.send_new_block_to_socket(b)
# Assert Block num 2
await asyncio.sleep(0.3)
self.assertEqual(d.driver.latest_block_num, 2)
d.nbn_inbox.stop()
d.work_inbox.stop()
d.stop()
self.loop.stop()
def test_new_blockchain_boot_sends_genesis_block_if_tx_batch(self):
m = Masternode(
wallet=mnw1,
ctx=self.ctx,
socket_base='ipc:///tmp/n1',
bootnodes=bootnodes,
constitution=constitution,
webserver_port=8080,
overwrite=True
)
m.parameters.sockets = {
dw1.verifying_key().hex(): 'ipc:///tmp/n2'
}
# For mocking
async def add_tx_batch():
m.tx_batcher.queue.append(b'123')
async def recv_tx_batch():
socket = self.ctx.socket(zmq.ROUTER)
socket.bind('ipc:///tmp/n2/block_notifications')
_id, msg = await socket.recv_multipart()
return msg
tasks = asyncio.gather(
m.new_blockchain_boot(),
add_tx_batch(),
recv_tx_batch()
)
_, _, msg = self.loop.run_until_complete(tasks)
self.assertEqual(msg, canonical.dict_to_msg_block(canonical.get_genesis_block()))
def test_run_single_block_mock(self):
b = Delegate(socket_base='ipc:///tmp/n2',
wallet=Wallet(),
ctx=self.ctx,
bootnodes=bootnodes,
constitution=constitution)
gb = canonical.get_genesis_block()
gb = canonical.dict_to_capnp_block(gb)
# Put the genesis block in here so we start immediately
b.nbn_inbox.q.append(gb)
b.running = True
# Add a single peer that we control
b.parameters.sockets = {mnw1.verifying_key().hex(): 'ipc:///tmp/n1'}
put_test_contract(self.client)
b.work_inbox.work[mnw1.verifying_key().hex()] = get_tx_batch()
async def stop():
await asyncio.sleep(1)
b.running = False
b.nbn_inbox.q.append(gb)
loop = asyncio.get_event_loop()
tasks = asyncio.gather(b.run(), stop())
loop.run_until_complete(tasks)
def __init__(self, webserver_port=8080, *args, **kwargs):
super().__init__(store=True, *args, **kwargs)
# Services
self.block_server = BlockServer(
wallet=self.wallet,
socket_base=self.socket_base,
network_parameters=self.network_parameters,
blocks=self.blocks)
self.block_fetcher.blocks = self.blocks
self.webserver = WebServer(contracting_client=self.client,
driver=self.driver,
blocks=self.blocks,
wallet=self.wallet,
port=webserver_port)
self.tx_batcher = TransactionBatcher(wallet=self.wallet, queue=[])
self.current_nbn = canonical.get_genesis_block()
self.aggregator = Aggregator(socket_id=self.network_parameters.resolve(
self.socket_base,
service_type=ServiceType.BLOCK_AGGREGATOR,
bind=True),
ctx=self.ctx,
driver=self.driver,
wallet=self.wallet)
# Network upgrade flag
self.active_upgrade = False
self.nbn_socket_book = Peers(
wallet=self.wallet,
ctx=self.ctx,
parameters=self.parameters,
service_type=ServiceType.BLOCK_NOTIFICATIONS,
node_type=ALL)
self.delegate_work_socket_book = Peers(
wallet=self.wallet,
ctx=self.ctx,
parameters=self.parameters,
service_type=ServiceType.INCOMING_WORK,
node_type=DEL)
self.masternode_contract = self.client.get_contract('masternodes')
async def find_valid_block(self, sockets, i, latest_hash):
if i == 0:
block = get_genesis_block()
block['blockNum'] = i
block['blockOwners'] = []
return block
block_found = False
block = None
while not block_found:
# Fire off requests to masternodes on the network
socket = random.choice(sockets)
block = await self.get_block_from_master(i, socket)
self.log.info(f'Got Block {i}')
self.log.info(f'Previous Hash: {latest_hash}')
self.log.info(f'Block.Hash: {block.hash}')
if block.hash == latest_hash:
break
block_found = verify_block(subblocks=block.subBlocks,
previous_hash=latest_hash,
proposed_hash=block.hash,
block_num=i)
if block is not None:
# block_dict = {
# 'hash': block.hash,
# 'blockNum': i,
# 'blockOwners': [],
# 'previous': latest_hash,
# 'subBlocks': [s for s in block.subBlocks]
# }
return block.to_dict()
async def send_new_block_to_socket(self, b=None):
if b is None:
b = canonical.get_genesis_block()
await self.delegate_nbn.send(canonical.dict_to_msg_block(b))