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_block_to_bx_block__empty_block_success(self):
block = Block(mock_eth_messages.get_dummy_block_header(8), [], [])
dummy_chain_difficulty = 10
block_msg = NewBlockEthProtocolMessage(None, block, dummy_chain_difficulty)
self.assertTrue(block_msg.rawbytes())
internal_new_block_msg = InternalEthBlockInfo.from_new_block_msg(block_msg)
bx_block_msg, block_info = self.eth_message_converter.block_to_bx_block(
internal_new_block_msg, self.tx_service, True, 0
)
self.assertEqual(0, block_info.txn_count)
self.assertEqual(convert.bytes_to_hex(block.header.prev_hash), block_info.prev_block_hash)
self.assertTrue(bx_block_msg)
self.assertIsInstance(bx_block_msg, memoryview)
block_offsets = compact_block_short_ids_serializer.get_bx_block_offsets(bx_block_msg)
_, short_ids_len = compact_block_short_ids_serializer.deserialize_short_ids_from_buffer(
bx_block_msg,
block_offsets.short_id_offset
)
compact_block = rlp.decode(
bx_block_msg[block_offsets.block_begin_offset: block_offsets.short_id_offset].tobytes(),
CompactBlock
)
self.assertTrue(compact_block)
self.assertIsInstance(compact_block, CompactBlock)
self._assert_values_equal(compact_block.header, block.header)
self.assertEqual(0, len(compact_block.uncles))
self.assertEqual(0, len(compact_block.transactions))
self.assertEqual(compact_block.chain_difficulty, block_msg.chain_difficulty)
def get_dummy_block(nonce, header=None):
if header is None:
header = get_dummy_block_header(nonce)
return Block(header, [
get_dummy_transaction(1),
get_dummy_transaction(2),
get_dummy_transaction(3)
], [get_dummy_block_header(1),
get_dummy_block_header(2)])
def test_block_to_bx_block_then_bx_block_to_block__success(self):
txs = []
txs_bytes = []
txs_hashes = []
short_ids = []
tx_count = 150
for i in range(1, tx_count):
tx = mock_eth_messages.get_dummy_transaction(i)
txs.append(tx)
tx_bytes = rlp.encode(tx, Transaction)
txs_bytes.append(tx_bytes)
tx_hash = tx.hash()
txs_hashes.append(tx_hash)
self.tx_service.assign_short_id(tx_hash, i)
self.tx_service.set_transaction_contents(tx_hash, tx_bytes)
short_ids.append(i)
block = Block(mock_eth_messages.get_dummy_block_header(100), txs,
[mock_eth_messages.get_dummy_block_header(2)])
dummy_chain_difficulty = 40000000
block_msg = NewBlockEthProtocolMessage(None, block,
dummy_chain_difficulty)
block_msg_bytes = block_msg.rawbytes()
self.assertTrue(block_msg_bytes)
internal_new_block_msg = InternalEthBlockInfo.from_new_block_msg(
block_msg)
bx_block_msg, block_info = self.eth_message_converter.block_to_bx_block(
internal_new_block_msg, self.tx_service, True, 0)
self.assertIsNotNone(bx_block_msg)
self.assertEqual(len(txs), block_info.txn_count)
self.assertEqual(convert.bytes_to_hex(block.header.prev_hash),
block_info.prev_block_hash)
converted_block_msg, _, _, _ = self.eth_message_converter.bx_block_to_block(
bx_block_msg, self.tx_service)
self.assertIsNotNone(converted_block_msg)
converted_new_block_msg = converted_block_msg.to_new_block_msg()
converted_block_msg_bytes = converted_new_block_msg.rawbytes()
self.assertEqual(len(converted_block_msg_bytes), len(block_msg_bytes))
self.assertEqual(converted_block_msg_bytes, block_msg_bytes)
def test_new_block_internal_eth_message_to_from_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
block_msg = NewBlockEthProtocolMessage(None, block,
dummy_chain_difficulty)
self.assertTrue(block_msg.rawbytes())
new_block_internal_eth_msg = InternalEthBlockInfo.from_new_block_msg(
block_msg)
self.assertIsNotNone(new_block_internal_eth_msg)
self.assertTrue(new_block_internal_eth_msg.rawbytes())
parsed_new_block_message = new_block_internal_eth_msg.to_new_block_msg(
)
self.assertIsInstance(parsed_new_block_message,
NewBlockEthProtocolMessage)
self.assertEqual(len(block_msg.rawbytes()),
len(parsed_new_block_message.rawbytes()))
self.assertEqual(
convert.bytes_to_hex(block_msg.rawbytes()),
convert.bytes_to_hex(parsed_new_block_message.rawbytes()),
)
def test_block_to_bx_block__no_compressed_block(self):
txs = []
txs_bytes = []
txs_hashes = []
short_ids = []
used_short_ids = []
tx_count = 150
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)
short_ids.append(0)
block = Block(
mock_eth_messages.get_dummy_block_header(1),
txs,
[
mock_eth_messages.get_dummy_block_header(2),
mock_eth_messages.get_dummy_block_header(3),
]
)
dummy_chain_difficulty = 10
block_msg = NewBlockEthProtocolMessage(None, block, dummy_chain_difficulty)
self.assertTrue(block_msg.rawbytes())
internal_new_block_msg = InternalEthBlockInfo.from_new_block_msg(block_msg)
bx_block_msg, block_info = self.eth_message_converter.block_to_bx_block(
internal_new_block_msg, self.tx_service, False, 0
)
self.assertTrue(len(bx_block_msg) >= len(internal_new_block_msg.rawbytes()))
self.assertEqual(len(txs), block_info.txn_count)
self.assertEqual(convert.bytes_to_hex(block.header.prev_hash), block_info.prev_block_hash)
self.assertEqual(used_short_ids, list(block_info.short_ids))
self.assertTrue(bx_block_msg)
self.assertIsInstance(bx_block_msg, memoryview)
block_offsets = compact_block_short_ids_serializer.get_bx_block_offsets(bx_block_msg)
compact_block = rlp.decode(
bx_block_msg[block_offsets.block_begin_offset: block_offsets.short_id_offset].tobytes(),
CompactBlock
)
self.assertTrue(compact_block)
self.assertIsInstance(compact_block, CompactBlock)
self._assert_values_equal(compact_block.header, block.header)
self._assert_values_equal(compact_block.uncles, block.uncles)
self.assertEqual(len(compact_block.transactions), len(block.transactions))
for tx, short_tx, i in zip(block.transactions, compact_block.transactions, range(1, tx_count)):
self.assertIsInstance(tx, Transaction)
self.assertIsInstance(short_tx, ShortTransaction)
self.assertEqual(1, short_tx.full_transaction)
self.assertEqual(short_tx.transaction_bytes, txs_bytes[i - 1])
self.assertEqual(compact_block.chain_difficulty, block_msg.chain_difficulty)
converted_block_msg, _, _, _ = self.eth_message_converter.bx_block_to_block(bx_block_msg, self.tx_service)
self.assertIsNotNone(converted_block_msg)
