def test_block_bodies_msg_from_bodies_bytes(self):
txs = []
txs_bytes = []
txs_hashes = []
tx_count = 10
for i in range(1, tx_count):
tx = mock_eth_messages.get_dummy_transaction(1)
txs.append(tx)
tx_bytes = rlp.encode(tx, Transaction)
txs_bytes.append(tx_bytes)
tx_hash = tx.hash()
txs_hashes.append(tx_hash)
uncles = [
mock_eth_messages.get_dummy_block_header(2),
mock_eth_messages.get_dummy_block_header(3),
]
block_body = TransientBlockBody(txs, uncles)
block_body_bytes = memoryview(
rlp.encode(TransientBlockBody.serialize(block_body)))
block_bodies_msg = BlockBodiesEthProtocolMessage.from_body_bytes(
block_body_bytes)
self.assertEqual(1, len(block_bodies_msg.get_blocks()))
self.assertEqual(1, len(block_bodies_msg.get_block_bodies_bytes()))
self.assertEqual(block_body, block_bodies_msg.get_blocks()[0])
self.assertEqual(block_body_bytes,
block_bodies_msg.get_block_bodies_bytes()[0])
def test_new_block_parts_to_new_block_message(self):
txs = []
txs_bytes = []
txs_hashes = []
tx_count = 10
for i in range(1, tx_count):
tx = mock_eth_messages.get_dummy_transaction(1)
txs.append(tx)
tx_bytes = rlp.encode(tx, Transaction)
txs_bytes.append(tx_bytes)
tx_hash = tx.hash()
txs_hashes.append(tx_hash)
block_header = mock_eth_messages.get_dummy_block_header(1)
uncles = [
mock_eth_messages.get_dummy_block_header(2),
mock_eth_messages.get_dummy_block_header(3),
]
block = Block(block_header, txs, uncles)
dummy_chain_difficulty = 10
new_block_msg = NewBlockEthProtocolMessage(None, block,
dummy_chain_difficulty)
self.assertTrue(new_block_msg.rawbytes())
block_body = TransientBlockBody(txs, uncles)
block_bytes = rlp.encode(Block.serialize(block))
block_header_bytes = memoryview(
rlp.encode(BlockHeader.serialize(block_header)))
block_body_bytes = memoryview(
rlp.encode(TransientBlockBody.serialize(block_body)))
self.assertEqual(len(block_bytes),
len(block_header_bytes) + len(block_body_bytes))
internal_new_block_msg = InternalEthBlockInfo.from_new_block_msg(
new_block_msg)
new_block_parts = internal_new_block_msg.to_new_block_parts()
new_block_msg_from_block_parts = NewBlockEthProtocolMessage.from_new_block_parts(
new_block_parts, dummy_chain_difficulty)
self.assertEqual(len(new_block_msg.rawbytes()),
len(new_block_msg_from_block_parts.rawbytes()))
self.assertEqual(new_block_msg.rawbytes(),
new_block_msg_from_block_parts.rawbytes())
self.assertEqual(new_block_msg_from_block_parts.get_chain_difficulty(),
dummy_chain_difficulty)
def test_new_block_internal_eth_message_to_from_new_block_parts(self):
txs = []
txs_bytes = []
txs_hashes = []
tx_count = 10
for i in range(1, tx_count):
tx = mock_eth_messages.get_dummy_transaction(1)
txs.append(tx)
tx_bytes = rlp.encode(tx, Transaction)
txs_bytes.append(tx_bytes)
tx_hash = tx.hash()
txs_hashes.append(tx_hash)
block_header = mock_eth_messages.get_dummy_block_header(1)
uncles = [
mock_eth_messages.get_dummy_block_header(2),
mock_eth_messages.get_dummy_block_header(3),
]
block_number = 100000
block_body = TransientBlockBody(txs, uncles)
block_header_bytes = memoryview(
rlp.encode(BlockHeader.serialize(block_header)))
block_body_bytes = memoryview(
rlp.encode(TransientBlockBody.serialize(block_body)))
new_block_parts = NewBlockParts(block_header_bytes, block_body_bytes,
block_number)
new_block_internal_eth_msg = InternalEthBlockInfo.from_new_block_parts(
new_block_parts)
self.assertIsNotNone(new_block_internal_eth_msg)
self.assertTrue(new_block_internal_eth_msg.rawbytes())
parsed_new_block_parts = new_block_internal_eth_msg.to_new_block_parts(
)
self.assertIsInstance(parsed_new_block_parts, NewBlockParts)
self.assertEqual(block_header_bytes,
parsed_new_block_parts.block_header_bytes)
self.assertEqual(block_body_bytes,
parsed_new_block_parts.block_body_bytes)
self.assertEqual(block_number, parsed_new_block_parts.block_number)
def test_complete_header_body_recovery(self):
self.node.block_processing_service.queue_block_for_processing = MagicMock()
self.node.block_queuing_service_manager.push = MagicMock()
self.node.on_block_seen_by_blockchain_node = MagicMock(return_value=False)
self.sut.is_valid_block_timestamp = MagicMock(return_value=True)
header = mock_eth_messages.get_dummy_block_header(1)
block = mock_eth_messages.get_dummy_block(1, header)
block_hash = header.hash_object()
new_block_hashes_message = NewBlockHashesEthProtocolMessage.from_block_hash_number_pair(
block_hash, 1
)
header_message = BlockHeadersEthProtocolMessage(None, [header])
bodies_message = BlockBodiesEthProtocolMessage(None, [TransientBlockBody(block.transactions, block.uncles)])
self.sut.msg_new_block_hashes(new_block_hashes_message)
self.node.on_block_seen_by_blockchain_node.assert_called_once()
self.assertEqual(1, len(self.sut.pending_new_block_parts.contents))
self.assertEqual(2, len(self.enqueued_messages))
self.node.on_block_seen_by_blockchain_node.reset_mock()
self.node.on_block_seen_by_blockchain_node = MagicMock(return_value=True)
self.sut.msg_block_headers(header_message)
self.sut.msg_block_bodies(bodies_message)
self.assertEqual(1, len(gateway_bdn_performance_stats_service.interval_data.blockchain_node_to_bdn_stats))
for stats in gateway_bdn_performance_stats_service.interval_data.blockchain_node_to_bdn_stats.values():
self.assertEqual(1, stats.new_blocks_received_from_blockchain_node)
self.assertEqual(0, stats.new_blocks_received_from_bdn)
self.node.on_block_seen_by_blockchain_node.assert_called_once()
self.node.block_queuing_service_manager.push.assert_not_called()
self.node.block_processing_service.queue_block_for_processing.assert_not_called()
def get_dummy_transient_block_body(nonce):
return TransientBlockBody([
get_dummy_transaction(nonce),
get_dummy_transaction(2 * nonce),
get_dummy_transaction(3 * nonce)
], [get_dummy_block_header(nonce),
get_dummy_block_header(2 * nonce)])
def test_block_bodies_msg__get_block_transactions(self):
txs = []
txs_bytes = []
txs_hashes = []
tx_count = 10
for i in range(1, tx_count):
tx = mock_eth_messages.get_dummy_transaction(1)
txs.append(tx)
tx_bytes = rlp.encode(tx, Transaction)
txs_bytes.append(tx_bytes)
tx_hash = tx.hash()
txs_hashes.append(tx_hash)
uncles = [
mock_eth_messages.get_dummy_block_header(2),
mock_eth_messages.get_dummy_block_header(3),
]
block_body = TransientBlockBody(txs, uncles)
block_body_bytes = memoryview(
rlp.encode(TransientBlockBody.serialize(block_body)))
block_bodies_msg = BlockBodiesEthProtocolMessage.from_body_bytes(
block_body_bytes)
parsed_txs_bytes = block_bodies_msg.get_block_transaction_bytes(0)
self.assertEqual(len(parsed_txs_bytes), len(txs_hashes))
for index, parsed_tx_bytes in enumerate(parsed_txs_bytes):
self.assertEqual(convert.bytes_to_hex(parsed_tx_bytes),
convert.bytes_to_hex(txs_bytes[index]))
parsed_txs_hashes = block_bodies_msg.get_block_transaction_hashes(0)
self.assertEqual(len(parsed_txs_hashes), len(txs_hashes))
for index, parsed_tx_hash in enumerate(parsed_txs_hashes):
self.assertEqual(parsed_tx_hash, txs_hashes[index])
def test_new_block_parts(self):
txs = []
txs_bytes = []
txs_hashes = []
tx_count = 10
for i in range(1, tx_count):
tx = mock_eth_messages.get_dummy_transaction(1)
txs.append(tx)
tx_bytes = rlp.encode(tx, Transaction)
txs_bytes.append(tx_bytes)
tx_hash = tx.hash()
txs_hashes.append(tx_hash)
block_header = mock_eth_messages.get_dummy_block_header(1)
uncles = [
mock_eth_messages.get_dummy_block_header(2),
mock_eth_messages.get_dummy_block_header(3),
]
block_number = 100000
block_body = TransientBlockBody(txs, uncles)
block_header_bytes = memoryview(
rlp.encode(BlockHeader.serialize(block_header)))
block_body_bytes = memoryview(
rlp.encode(TransientBlockBody.serialize(block_body)))
new_block_parts = NewBlockParts(block_header_bytes, block_body_bytes,
block_number)
self.assertIsInstance(new_block_parts.get_block_hash(), Sha256Hash)
self.assertIsInstance(new_block_parts.get_previous_block_hash(),
Sha256Hash)
self.assertEqual(1, new_block_parts.get_block_difficulty())
def test_complete_header_body_fetch(self):
self.node.block_processing_service.queue_block_for_processing = MagicMock()
self.sut.is_valid_block_timestamp = MagicMock(return_value=True)
header = mock_eth_messages.get_dummy_block_header(1)
block = mock_eth_messages.get_dummy_block(1, header)
block_hash = header.hash_object()
new_block_hashes_message = NewBlockHashesEthProtocolMessage.from_block_hash_number_pair(
block_hash, 1
)
header_message = BlockHeadersEthProtocolMessage(None, [header])
bodies_message = BlockBodiesEthProtocolMessage(None, [TransientBlockBody(block.transactions, block.uncles)])
self.sut.msg_new_block_hashes(new_block_hashes_message)
self.assertEqual(1, len(self.sut.pending_new_block_parts.contents))
self.assertEqual(2, len(self.enqueued_messages))
self.sut.msg_block_headers(header_message)
self.sut.msg_block_bodies(bodies_message)
self.node.block_processing_service.queue_block_for_processing.assert_called_once()
