def test_broadcast_to_connection_type(self):
relay_all_conn = self._add_connection(0, 9000, ALL_NETWORK_NUM, ConnectionType.RELAY_ALL)
relay_block_conn = self._add_connection(1, 9001, ALL_NETWORK_NUM, ConnectionType.RELAY_BLOCK)
relay_transaction_conn = self._add_connection(2, 9002, ALL_NETWORK_NUM, ConnectionType.RELAY_TRANSACTION)
gateway_conn = self._add_connection(3, 9003, ALL_NETWORK_NUM, ConnectionType.EXTERNAL_GATEWAY)
block_message = BroadcastMessage(Sha256Hash(helpers.generate_hash()), ALL_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, False, helpers.generate_bytearray(250))
self.sut.broadcast(block_message, BroadcastOptions(connection_types=[ConnectionType.RELAY_BLOCK]))
tx_message = BroadcastMessage(Sha256Hash(helpers.generate_hash()), ALL_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, False, helpers.generate_bytearray(250))
self.sut.broadcast(tx_message, BroadcastOptions(connection_types=[ConnectionType.RELAY_TRANSACTION]))
gateway_message = BroadcastMessage(Sha256Hash(helpers.generate_hash()), ALL_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, False, helpers.generate_bytearray(250))
self.sut.broadcast(gateway_message, BroadcastOptions(connection_types=[ConnectionType.GATEWAY]))
self.assertIn(block_message, relay_all_conn.enqueued_messages)
self.assertIn(block_message, relay_block_conn.enqueued_messages)
self.assertNotIn(block_message, relay_transaction_conn.enqueued_messages)
self.assertNotIn(block_message, gateway_conn.enqueued_messages)
self.assertIn(tx_message, relay_all_conn.enqueued_messages)
self.assertNotIn(tx_message, relay_block_conn.enqueued_messages)
self.assertIn(tx_message, relay_transaction_conn.enqueued_messages)
self.assertNotIn(tx_message, gateway_conn.enqueued_messages)
self.assertNotIn(gateway_message, relay_all_conn.enqueued_messages)
self.assertNotIn(gateway_message, relay_block_conn.enqueued_messages)
self.assertNotIn(gateway_message, relay_transaction_conn.enqueued_messages)
self.assertIn(gateway_message, gateway_conn.enqueued_messages)
def test_msg_broadcast_duplicate_block_with_different_short_id(self):
# test scenario when first received block is compressed with unknown short ids,
# but second received block is compressed with known short ids
ont_block = self.ont_block()
block_hash = ont_block.block_hash()
transactions = self.bx_transactions()
unknown_sid_transaction_service = ExtensionTransactionService(MockNode(
gateway_helpers.get_gateway_opts(8999)), 0)
for i, transaction in enumerate(transactions):
unknown_sid_transaction_service.assign_short_id(transaction.tx_hash(), i)
unknown_sid_transaction_service.set_transaction_contents(transaction.tx_hash(), transaction.tx_val())
unknown_short_id_block = bytes(
self.gateway_node.message_converter.block_to_bx_block(
ont_block, unknown_sid_transaction_service, True, self.gateway_node.network.min_tx_age_seconds
)[0]
)
unknown_key, unknown_cipher = symmetric_encrypt(unknown_short_id_block)
unknown_block_hash = crypto.double_sha256(unknown_cipher)
unknown_message = BroadcastMessage(Sha256Hash(unknown_block_hash), self.TEST_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, False, bytearray(unknown_short_id_block))
unknown_key_message = KeyMessage(Sha256Hash(unknown_block_hash), self.TEST_NETWORK_NUM, "", unknown_key)
local_transaction_service = self.gateway_node.get_tx_service()
for i, transaction in enumerate(transactions):
local_transaction_service.assign_short_id(transaction.tx_hash(), i + 20)
local_transaction_service.set_transaction_contents(transaction.tx_hash(), transaction.tx_val())
known_short_id_block = bytes(
self.gateway_node.message_converter.block_to_bx_block(
ont_block, local_transaction_service, True, self.gateway_node.network.min_tx_age_seconds
)[0]
)
known_key, known_cipher = symmetric_encrypt(known_short_id_block)
known_block_hash = crypto.double_sha256(known_cipher)
known_message = BroadcastMessage(Sha256Hash(known_block_hash), self.TEST_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, False, bytearray(known_short_id_block))
known_key_message = KeyMessage(Sha256Hash(known_block_hash), self.TEST_NETWORK_NUM, "", known_key)
self.sut.msg_broadcast(unknown_message)
self.sut.msg_key(unknown_key_message)
self.assertEqual(1, len(self.gateway_node.block_queuing_service))
self.assertEqual(True, self.gateway_node.block_queuing_service._blocks_waiting_for_recovery[block_hash])
self.assertEqual(1, len(self.gateway_node.block_recovery_service._block_hash_to_bx_block_hashes))
self.assertNotIn(block_hash, self.gateway_node.blocks_seen.contents)
self.sut.msg_broadcast(known_message)
self.sut.msg_key(known_key_message)
self.gateway_node_sut.msg_get_data(GetDataOntMessage(self.magic, InventoryOntType.MSG_BLOCK.value, block_hash))
self.gateway_node.broadcast.assert_called()
self.assertEqual(0, len(self.gateway_node.block_queuing_service))
self.assertEqual(0, len(self.gateway_node.block_recovery_service._block_hash_to_bx_block_hashes))
self.assertIn(block_hash, self.gateway_node.blocks_seen.contents)
def test_msg_key_wait_for_broadcast(self):
ont_block = self.ont_block()
bx_block = self.bx_block(ont_block)
key, ciphertext = symmetric_encrypt(bx_block)
block_hash = crypto.double_sha256(ciphertext)
self.gateway_node.broadcast.assert_not_called()
key_message = KeyMessage(Sha256Hash(block_hash), self.TEST_NETWORK_NUM,
"", key)
self.sut.msg_key(key_message)
# handle duplicate broadcasts
self.sut.msg_key(key_message)
self.sut.msg_key(key_message)
self.assertEqual(1, len(self.gateway_node.in_progress_blocks))
broadcast_message = BroadcastMessage(Sha256Hash(block_hash),
self.TEST_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, True,
ciphertext)
self.sut.msg_broadcast(broadcast_message)
self._assert_block_sent(ont_block)
def test_bdn_stats_block_new_from_bdn_ignore_from_node(self):
block_msg = NewBlockEthProtocolMessage(
None,
_block_with_timestamp(time.time() + 1 - (
self.node.opts.blockchain_ignore_block_interval_count *
self.node.opts.blockchain_block_interval)), 10)
internal_new_block_msg = InternalEthBlockInfo.from_new_block_msg(
block_msg)
msg_bytes, block_info = self.node.message_converter.block_to_bx_block(
internal_new_block_msg, self.node._tx_service, True,
self.node.network.min_tx_age_seconds)
msg_hash = Sha256Hash(crypto.double_sha256(msg_bytes))
broadcast_msg = BroadcastMessage(message_hash=msg_hash,
network_num=1,
is_encrypted=False,
blob=msg_bytes)
self.relay_connection.msg_broadcast(broadcast_msg)
block_msg.serialize()
self.block_blockchain_connection_protocol.msg_block(block_msg)
self.assertEqual(
3,
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_bdn)
self.assertEqual(0, stats.new_blocks_received_from_blockchain_node)
def test_get_txs_block_recovery_encrypted(self):
block: BlockOntMessage = self.ont_block()
transactions: List[TxOntMessage] = self.ont_transactions(block)
# assign short ids that the local connection won't know about until it gets the txs message
remote_transaction_service = ExtensionTransactionService(
MockNode(gateway_helpers.get_gateway_opts(8999)), 0)
short_id_mapping = {}
for i, transaction in enumerate(transactions):
tx_hash = transaction.tx_hash()
remote_transaction_service.assign_short_id(tx_hash, i + 1)
remote_transaction_service.set_transaction_contents(
tx_hash, transaction.rawbytes())
short_id_mapping[tx_hash] = TransactionInfo(
tx_hash, transaction.rawbytes(), i + 1)
bx_block = bytes(
self.gateway_node.message_converter.block_to_bx_block(
block, remote_transaction_service)[0])
self.gateway_node.block_recovery_service.add_block = \
MagicMock(wraps=self.gateway_node.block_recovery_service.add_block)
self.gateway_node.send_msg_to_node = MagicMock()
self.gateway_node.broadcast = MagicMock()
key, ciphertext = symmetric_encrypt(bx_block)
block_hash = crypto.double_sha256(ciphertext)
key_message = KeyMessage(Sha256Hash(block_hash), DEFAULT_NETWORK_NUM,
"", key)
broadcast_message = BroadcastMessage(Sha256Hash(block_hash),
DEFAULT_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, True,
ciphertext)
self.sut.msg_broadcast(broadcast_message)
self.gateway_node.broadcast.reset_mock()
self.sut.msg_key(key_message)
self.gateway_node.block_recovery_service.add_block.assert_called_once()
self.assertEqual(2, self.gateway_node.broadcast.call_count)
recovery_broadcast = self.gateway_node.broadcast.call_args_list[0]
((gettxs_message, ), recovery_kwargs) = recovery_broadcast
self.assertIsInstance(gettxs_message, GetTxsMessage)
self.assertIn(ConnectionType.RELAY_TRANSACTION,
recovery_kwargs["connection_types"])
key_broadcast = self.gateway_node.broadcast.call_args_list[1]
((key_message, _conn), recovery_kwargs) = key_broadcast
self.assertIsInstance(key_message, KeyMessage)
self.assertIn(ConnectionType.GATEWAY,
recovery_kwargs["connection_types"])
txs = [tx for tx in short_id_mapping.values()]
txs_message = TxsMessage(txs=txs)
self.sut.msg_txs(txs_message)
self._assert_block_sent(block)
def _propagate_unencrypted_block_to_network(self, bx_block, connection,
block_info):
if block_info is None:
raise ValueError(
"Block info is required to propagate unencrypted block")
broadcast_message = BroadcastMessage(block_info.block_hash,
self._node.network_num,
is_encrypted=False,
blob=bx_block)
conns = self._node.broadcast(
broadcast_message,
connection,
connection_types=[ConnectionType.RELAY_BLOCK])
handling_duration = self._node.track_block_from_node_handling_ended(
block_info.block_hash)
block_stats.add_block_event_by_block_hash(
block_info.block_hash,
BlockStatEventType.ENC_BLOCK_SENT_FROM_GATEWAY_TO_NETWORK,
network_num=self._node.network_num,
requested_by_peer=False,
peers=conns,
more_info="Peers: {}; Unencrypted; {}; Handled in {}".format(
stats_format.connections(conns),
self._format_block_info_stats(block_info),
stats_format.duration(handling_duration)))
logger.info("Propagating block {} to the BDN.", block_info.block_hash)
return broadcast_message
def test_msg_broadcast_wait_for_key(self):
ont_block = self.ont_block()
bx_block = self.bx_block(ont_block)
key, ciphertext = symmetric_encrypt(bx_block)
block_hash = crypto.double_sha256(ciphertext)
broadcast_message = BroadcastMessage(Sha256Hash(block_hash),
self.TEST_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, True,
ciphertext)
self.sut.msg_broadcast(broadcast_message)
# handle duplicate messages
self.sut.msg_broadcast(broadcast_message)
self.sut.msg_broadcast(broadcast_message)
self.assertEqual(3, len(self.gateway_node.broadcast.call_args_list))
for call, conn_type in self.gateway_node.broadcast.call_args_list:
msg, conn = call
self.assertTrue(isinstance(msg, BlockReceivedMessage))
self.gateway_node.broadcast.reset_mock()
self.assertEqual(1, len(self.gateway_node.in_progress_blocks))
key_message = KeyMessage(Sha256Hash(block_hash), self.TEST_NETWORK_NUM,
"", key)
self.sut.msg_key(key_message)
self._assert_block_sent(ont_block)
def _propagate_encrypted_block_to_network(self, bx_block, connection,
block_info):
if block_info is None or block_info.block_hash is None:
block_hash = b"Unknown"
requested_by_peer = True
else:
block_hash = block_info.block_hash
requested_by_peer = False
encrypt_start_datetime = datetime.datetime.utcnow()
encrypt_start_timestamp = time.time()
encrypted_block, raw_cipher_hash = self._node.in_progress_blocks.encrypt_and_add_payload(
bx_block)
compressed_size = len(bx_block)
encrypted_size = len(encrypted_block)
encryption_details = "Encryption: {}; Size change: {}->{}bytes, {}".format(
stats_format.timespan(encrypt_start_timestamp, time.time()),
compressed_size, encrypted_size,
stats_format.ratio(encrypted_size, compressed_size))
block_stats.add_block_event_by_block_hash(
block_hash,
BlockStatEventType.BLOCK_ENCRYPTED,
start_date_time=encrypt_start_datetime,
end_date_time=datetime.datetime.utcnow(),
network_num=self._node.network_num,
matching_block_hash=convert.bytes_to_hex(raw_cipher_hash),
matching_block_type=StatBlockType.ENCRYPTED.value,
more_info=encryption_details)
cipher_hash = Sha256Hash(raw_cipher_hash)
broadcast_message = BroadcastMessage(cipher_hash,
self._node.network_num,
is_encrypted=True,
blob=encrypted_block)
conns = self._node.broadcast(
broadcast_message,
connection,
connection_types=[ConnectionType.RELAY_BLOCK])
handling_duration = self._node.track_block_from_node_handling_ended(
block_hash)
block_stats.add_block_event_by_block_hash(
cipher_hash,
BlockStatEventType.ENC_BLOCK_SENT_FROM_GATEWAY_TO_NETWORK,
network_num=self._node.network_num,
requested_by_peer=requested_by_peer,
peers=conns,
more_info="Peers: {}; {}; {}; Requested by peer: {}; Handled in {}"
.format(stats_format.connections(conns), encryption_details,
self._format_block_info_stats(block_info),
requested_by_peer,
stats_format.duration(handling_duration)))
self.register_for_block_receipts(cipher_hash, bx_block)
return broadcast_message
def test_broadcast_message(self):
block_hash = Sha256Hash(helpers.generate_bytes(crypto.SHA256_HASH_LEN))
blob = helpers.generate_bytes(250)
network_num = 1234
self._test_to_old_version_broadcast_message(BroadcastMessage(network_num=network_num, message_hash=block_hash,
source_id=NEW_VERSION_SOURCE_ID, blob=blob))
self._test_to_new_version_broadcast_message(BroadcastMessageV4(network_num=network_num, msg_hash=block_hash,
blob=blob))
def broadcast_message(self) -> BroadcastMessage:
return BroadcastMessage(
helpers.generate_object_hash(),
self.NETWORK_NUMBER,
self.NODE_ID,
self.BROADCAST_TYPE,
False,
helpers.generate_bytearray(500),
)
def test_get_connection_protocol_version__wrong_message(self):
wrong_message = BroadcastMessage(message_hash=Sha256Hash(
crypto.double_sha256(b"hello")),
network_num=1,
source_id="",
blob=bytearray(1))
input_buffer = InputBuffer()
input_buffer.add_bytes(wrong_message.rawbytes())
self.assertEqual(
3,
self.version_manager.get_connection_protocol_version(input_buffer))
def test_broadcast_to_network_numbers(self):
all_matching_network_num = self._add_connection(0, 9000, ALL_NETWORK_NUM)
matching_network_num = self._add_connection(1, 9001, 1)
not_matching_network_num = self._add_connection(2, 9002, 2)
message = BroadcastMessage(Sha256Hash(helpers.generate_hash()), 1, "", BroadcastMessageType.BLOCK, False,
helpers.generate_bytearray(250))
self.sut.broadcast(message, BroadcastOptions(connection_types=[MockConnection.CONNECTION_TYPE]))
self.assertIn(message, all_matching_network_num.enqueued_messages)
self.assertIn(message, matching_network_num.enqueued_messages)
self.assertNotIn(message, not_matching_network_num.enqueued_messages)
def test_msg_broadcast_encrypted(self, mock_handle_decrypted_block):
msg_bytes = helpers.generate_bytearray(50)
msg_hash = Sha256Hash(crypto.double_sha256(msg_bytes))
broadcast_msg = BroadcastMessage(message_hash=msg_hash, network_num=1, is_encrypted=True, blob=msg_bytes)
self.connection.msg_broadcast(broadcast_msg)
self.assertTrue(self.node.in_progress_blocks.has_ciphertext_for_hash(msg_hash))
self.assertEqual(1, len(self.node.broadcast_messages))
self.assertIsInstance(self.node.broadcast_messages[0][0], BlockReceivedMessage)
mock_handle_decrypted_block.assert_not_called()
def test_msg_broadcast_unencrypted(self, mock_handle_decrypted_block):
msg_bytes = helpers.generate_bytearray(50)
msg_hash = Sha256Hash(crypto.double_sha256(msg_bytes))
broadcast_msg = BroadcastMessage(message_hash=msg_hash, network_num=1, is_encrypted=False, blob=msg_bytes)
self.connection.msg_broadcast(broadcast_msg)
self.assertFalse(self.node.in_progress_blocks.has_ciphertext_for_hash(msg_hash))
self.assertEqual(0, len(self.node.broadcast_messages))
mock_handle_decrypted_block.assert_called_once()
def test_message_hash_preview_incomplete(self):
blob = bytearray(1 for _ in range(4))
broadcast_message = BroadcastMessage(self.HASH, 123, self.NODE_ID, True, blob)
is_full_message, msg_hash, network_num, node_id, payload_length = \
bloxroute_message_factory.get_broadcast_message_preview(
create_input_buffer_with_bytes(broadcast_message.rawbytes()
[:BX_HDR_COMMON_OFF + SHA256_HASH_LEN + NETWORK_NUM_LEN - 1]))
self.assertFalse(is_full_message)
self.assertIsNone(msg_hash)
self.assertIsNone(network_num)
self.assertIsNone(node_id)
self.assertIsNone(payload_length)
def broadcast_key_pair(short_ids=None, network_num=0):
if short_ids is None:
short_ids = [1, 10, 99, 187]
broadcast_message_hash = Sha256Hash(helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
broadcast_message_bytes = bytearray(constants.UL_ULL_SIZE_IN_BYTES)
broadcast_message_bytes.extend(helpers.generate_bytearray(500))
struct.pack_into("<Q", broadcast_message_bytes, 0, len(broadcast_message_bytes))
broadcast_message_bytes.extend(compact_block_short_ids_serializer.serialize_short_ids_into_bytes(short_ids))
key_bytes, enc_broadcast_message_bytes = crypto.symmetric_encrypt(bytes(broadcast_message_bytes))
broadcast_message = BroadcastMessage(broadcast_message_hash, network_num, "", True, enc_broadcast_message_bytes)
key_message = KeyMessage(broadcast_message_hash, network_num, "", key_bytes)
return broadcast_message, key_message
def test_broadcast_message_cut_through_to_old(self):
block_hash = Sha256Hash(helpers.generate_bytes(crypto.SHA256_HASH_LEN))
blob = helpers.generate_bytes(250)
network_num = 1234
new_message = BroadcastMessage(network_num=network_num,
message_hash=block_hash,
source_id=NEW_VERSION_SOURCE_ID,
blob=blob)
new_message_bytes = new_message.rawbytes()
old_message_bytes = bloxroute_version_manager.convert_message_first_bytes_to_older_version(
5, BroadcastMessage.MESSAGE_TYPE, new_message_bytes)
msg_type, payload_length = BroadcastMessageV5.unpack(old_message_bytes)
old_msg = BroadcastMessageV5.initialize_class(
BroadcastMessageV5, old_message_bytes, (msg_type, payload_length))
self._validate_messages_match(old_msg, new_message)
def test_peek_network_num(self):
network_num = 12345
hash_bytes = helpers.generate_bytearray(SHA256_HASH_LEN)
msg_hash = Sha256Hash(hash_bytes)
block_bytes = helpers.generate_bytearray(1234)
broadcast_msg = BroadcastMessage(message_hash=msg_hash, network_num=network_num, source_id="", blob=block_bytes)
msg_bytes = broadcast_msg.rawbytes()
input_buffer = InputBuffer()
input_buffer.add_bytes(msg_bytes)
peeked_network_num = BroadcastMessage.peek_network_num(input_buffer)
self.assertEqual(network_num, peeked_network_num)
def test_get_txs_block_recovery(self):
block: BlockOntMessage = self.ont_block()
transactions: List[TxOntMessage] = self.ont_transactions(block)
# assign short ids that the local connection won't know about until it gets the txs message
remote_transaction_service = ExtensionTransactionService(
MockNode(gateway_helpers.get_gateway_opts(8999)), 0)
short_id_mapping = {}
for i, transaction in enumerate(transactions):
tx_hash = transaction.tx_hash()
remote_transaction_service.assign_short_id(tx_hash, i + 1)
remote_transaction_service.set_transaction_contents(
tx_hash, transaction.rawbytes())
short_id_mapping[tx_hash] = TransactionInfo(
tx_hash, transaction.rawbytes(), i + 1)
bx_block = bytes(
self.gateway_node.message_converter.block_to_bx_block(
block, remote_transaction_service, True,
self.gateway_node.network.min_tx_age_seconds)[0])
self.gateway_node.block_recovery_service.add_block = \
MagicMock(wraps=self.gateway_node.block_recovery_service.add_block)
self.gateway_node.broadcast = MagicMock()
broadcast_message = BroadcastMessage(block.block_hash(),
DEFAULT_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, False,
bytearray(bx_block))
self.sut.msg_broadcast(broadcast_message)
self.gateway_node.block_recovery_service.add_block.assert_called_once()
self.assertEqual(1, self.gateway_node.broadcast.call_count)
recovery_broadcast = self.gateway_node.broadcast.call_args_list[0]
((gettxs_message, ), recovery_kwargs) = recovery_broadcast
self.assertIsInstance(gettxs_message, GetTxsMessage)
self.assertIn(ConnectionType.RELAY_TRANSACTION,
recovery_kwargs["connection_types"])
txs = [tx for tx in short_id_mapping.values()]
txs_message = TxsMessage(txs=txs)
self.sut.msg_txs(txs_message)
self._assert_block_sent(block)
def test_message_preview_success_all_types(self):
self.get_message_preview_successfully(HelloMessage(protocol_version=1, network_num=2),
HelloMessage.MESSAGE_TYPE,
VersionMessage.VERSION_MESSAGE_LENGTH + UL_INT_SIZE_IN_BYTES +
NODE_ID_SIZE_IN_BYTES - UL_INT_SIZE_IN_BYTES)
self.get_message_preview_successfully(AckMessage(), AckMessage.MESSAGE_TYPE, constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(PingMessage(), PingMessage.MESSAGE_TYPE, 9)
self.get_message_preview_successfully(PongMessage(), PongMessage.MESSAGE_TYPE, 9)
blob = bytearray(1 for _ in range(4))
self.get_message_preview_successfully(BroadcastMessage(self.HASH, 1, self.NODE_ID, True, blob),
BroadcastMessage.MESSAGE_TYPE,
SHA256_HASH_LEN + NETWORK_NUM_LEN + BLOCK_ENCRYPTED_FLAG_LEN +
constants.NODE_ID_SIZE_IN_BYTES + len(blob) + constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(TxMessage(self.HASH, 1, self.NODE_ID, 12, blob),
TxMessage.MESSAGE_TYPE,
SHA256_HASH_LEN + NETWORK_NUM_LEN + UL_INT_SIZE_IN_BYTES +
constants.NODE_ID_SIZE_IN_BYTES + len(blob) + constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(KeyMessage(self.HASH, 1, self.NODE_ID,
bytearray(1 for _ in range(KEY_SIZE))),
KeyMessage.MESSAGE_TYPE,
SHA256_HASH_LEN + KEY_SIZE + NETWORK_NUM_LEN +
constants.NODE_ID_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(BlockHoldingMessage(self.HASH, 1, self.NODE_ID),
BlockHoldingMessage.MESSAGE_TYPE,
SHA256_HASH_LEN + NETWORK_NUM_LEN + constants.NODE_ID_SIZE_IN_BYTES +
constants.CONTROL_FLAGS_LEN)
get_txs = [1, 2, 3]
self.get_message_preview_successfully(GetTxsMessage(get_txs), GetTxsMessage.MESSAGE_TYPE,
UL_INT_SIZE_IN_BYTES + UL_INT_SIZE_IN_BYTES * len(
get_txs) + constants.CONTROL_FLAGS_LEN)
txs = [TransactionInfo(crypto.double_sha256(b"123"), bytearray(4), 1),
TransactionInfo(crypto.double_sha256(b"234"), bytearray(8), 2)]
expected_length = (UL_INT_SIZE_IN_BYTES +
sum(UL_INT_SIZE_IN_BYTES + SHA256_HASH_LEN + UL_INT_SIZE_IN_BYTES +
len(tx.contents) for tx in txs) + constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(TxsMessage(txs), TxsMessage.MESSAGE_TYPE, expected_length)
def test_bdn_stats_block_new_from_bdn(self):
block_msg = mock_eth_messages.new_block_eth_protocol_message(21, 1017)
internal_new_block_msg = InternalEthBlockInfo.from_new_block_msg(
block_msg)
msg_bytes, block_info = self.node.message_converter.block_to_bx_block(
internal_new_block_msg, self.node._tx_service, True,
self.node.network.min_tx_age_seconds)
msg_hash = Sha256Hash(crypto.double_sha256(msg_bytes))
broadcast_msg = BroadcastMessage(message_hash=msg_hash,
network_num=1,
is_encrypted=False,
blob=msg_bytes)
self.relay_connection.msg_broadcast(broadcast_msg)
self.assertEqual(
3,
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_bdn)
def _propagate_unencrypted_block_to_network(self, bx_block, connection, block_info):
if block_info is None:
raise ValueError("Block info is required to propagate unencrypted block")
is_consensus_msg, = struct.unpack_from("?", bx_block[8:9])
broadcast_type = BroadcastMessageType.CONSENSUS if is_consensus_msg else BroadcastMessageType.BLOCK
broadcast_message = BroadcastMessage(block_info.block_hash, self._node.network_num,
broadcast_type=broadcast_type, is_encrypted=False, blob=bx_block)
conns = self._node.broadcast(broadcast_message, connection, connection_types=[ConnectionType.RELAY_BLOCK])
handling_duration = self._node.track_block_from_node_handling_ended(block_info.block_hash)
block_stats.add_block_event_by_block_hash(block_info.block_hash,
BlockStatEventType.ENC_BLOCK_SENT_FROM_GATEWAY_TO_NETWORK,
network_num=self._node.network_num,
broadcast_type=broadcast_type,
requested_by_peer=False,
peers=map(lambda conn: (conn.peer_desc, conn.CONNECTION_TYPE), conns),
more_info="Peers: {}; Unencrypted; {}; Handled in {}".format(
stats_format.connections(conns),
self._format_block_info_stats(block_info),
stats_format.duration(handling_duration)))
logger.info("Propagating block {} to the BDN.", block_info.block_hash)
return broadcast_message
def test_bx_block_to_block__full_txs_success(self):
tx_count = 150
txs = []
short_txs = []
short_ids = []
for i in range(1, tx_count):
tx = mock_eth_messages.get_dummy_transaction(1)
txs.append(tx)
tx_bytes = rlp.encode(tx, Transaction)
if i % 2 == 0:
tx_hash = hashlib.sha256(tx_bytes).digest()
self.tx_service.assign_short_id(tx_hash, i)
self.tx_service.set_transaction_contents(tx_hash, tx_bytes)
short_tx = ShortTransaction(0, bytes())
short_txs.append(short_tx)
short_ids.append(i)
else:
short_tx = ShortTransaction(1, tx_bytes)
short_txs.append(short_tx)
dummy_chain_difficulty = 20
dummy_block_number = 10
compact_block = CompactBlock(mock_eth_messages.get_dummy_block_header(8),
short_txs,
[
mock_eth_messages.get_dummy_block_header(2),
mock_eth_messages.get_dummy_block_header(3)
],
dummy_chain_difficulty,
dummy_block_number)
compact_block_msg_bytes = bytearray(constants.UL_ULL_SIZE_IN_BYTES)
compact_block_msg_bytes.extend(rlp.encode(compact_block, CompactBlock))
short_ids_offset = len(compact_block_msg_bytes)
struct.pack_into("<Q", compact_block_msg_bytes, 0, short_ids_offset)
compact_block_bytes = compact_block_short_ids_serializer.serialize_short_ids_into_bytes(short_ids)
compact_block_msg_bytes.extend(compact_block_bytes)
compact_block_hash_bytes = hashlib.sha256(compact_block_msg_bytes).digest()
compact_block_hash = Sha256Hash(compact_block_hash_bytes)
bx_block_msg = BroadcastMessage(compact_block_hash, self.test_network_num, is_encrypted=True,
blob=compact_block_msg_bytes)
block_msg, block_info, unknown_tx_sids, unknown_tx_hashes = self.eth_message_converter.bx_block_to_block(
bx_block_msg.blob(), self.tx_service)
self.assertTrue(block_msg)
self.assertIsInstance(block_msg, InternalEthBlockInfo)
new_block_msg = block_msg.to_new_block_msg()
block = new_block_msg.get_block()
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 block_tx, i in zip(block.transactions, range(0, tx_count - 1)):
self.assertIsInstance(block_tx, Transaction)
self._assert_values_equal(block_tx, txs[i])
self.assertEqual(compact_block.chain_difficulty, new_block_msg.chain_difficulty)
def test_message_hash_preview(self):
blob = bytearray(1 for _ in range(4))
self.get_hashed_message_preview_successfully(
BroadcastMessage(self.HASH, self.NETWORK_NUM, self.NODE_ID,
self.BROADCAST_TYPE, True, blob), self.HASH)
def test_create_message_success_all_types(self):
test_network_num = 10
test_protocol_version = bloxroute_version_manager.CURRENT_PROTOCOL_VERSION
hello_message = self.create_message_successfully(
HelloMessage(protocol_version=test_protocol_version,
network_num=test_network_num,
node_id=self.NODE_ID), HelloMessage)
self.assertEqual(test_protocol_version,
hello_message.protocol_version())
self.assertEqual(test_network_num, hello_message.network_num())
self.assertEqual(self.NODE_ID, hello_message.node_id())
self.create_message_successfully(AckMessage(), AckMessage)
self.create_message_successfully(PingMessage(), PingMessage)
self.create_message_successfully(PongMessage(), PongMessage)
blob = bytearray(4)
broadcast_message = self.create_message_successfully(
BroadcastMessage(self.HASH,
network_num=test_network_num,
is_encrypted=True,
source_id=self.NODE_ID,
blob=blob), BroadcastMessage)
self.assertEqual(self.HASH, broadcast_message.block_hash())
self.assertEqual(test_network_num, broadcast_message.network_num())
self.assertEqual(self.NODE_ID, broadcast_message.source_id())
self.assertTrue(broadcast_message.is_encrypted())
self.assertEqual(blob, broadcast_message.blob().tobytes())
sid = 12
tx_val = bytes(1 for _ in range(5))
tx_message = self.create_message_successfully(
TxMessage(self.HASH,
network_num=test_network_num,
source_id=self.NODE_ID,
short_id=sid,
tx_val=tx_val), TxMessage)
self.assertEqual(self.HASH, tx_message.tx_hash())
self.assertEqual(self.NODE_ID, tx_message.source_id())
self.assertEqual(sid, tx_message.short_id())
self.assertEqual(test_network_num, tx_message.network_num())
self.assertEqual(tx_val, tx_message.tx_val())
key = bytearray(1 for _ in range(KEY_SIZE))
key_message = self.create_message_successfully(
KeyMessage(self.HASH, test_network_num, self.NODE_ID,
bytearray(1 for _ in range(KEY_SIZE))), KeyMessage)
self.assertEqual(key, key_message.key())
self.assertEqual(self.NODE_ID, key_message.source_id())
self.assertEqual(test_network_num, key_message.network_num())
self.assertEqual(self.HASH, key_message.block_hash())
block_holding_message = self.create_message_successfully(
BlockHoldingMessage(self.HASH, test_network_num, self.NODE_ID),
BlockHoldingMessage)
self.assertEqual(self.NODE_ID, block_holding_message.source_id())
self.assertEqual(test_network_num, block_holding_message.network_num())
self.assertEqual(self.HASH, block_holding_message.block_hash())
get_txs = [1, 2, 3]
get_txs_message = self.create_message_successfully(
GetTxsMessage(get_txs), GetTxsMessage)
self.assertEqual(get_txs, get_txs_message.get_short_ids())
txs = [
TransactionInfo(Sha256Hash(crypto.double_sha256(b"123")),
bytearray(4), 1),
TransactionInfo(Sha256Hash(crypto.double_sha256(b"234")),
bytearray(8), 2)
]
txs_message = self.create_message_successfully(TxsMessage(txs),
TxsMessage)
result_txs = txs_message.get_txs()
for i, result_tx in enumerate(result_txs):
self.assertEqual(txs[i].hash, result_tx.hash)
self.assertEqual(txs[i].contents, result_tx.contents)
self.assertEqual(txs[i].short_id, result_tx.short_id)
get_tx_contents_message = self.create_message_successfully(
GetTxContentsMessage(test_network_num, sid), GetTxContentsMessage)
self.assertEqual(sid, get_tx_contents_message.get_short_id())
self.assertEqual(test_network_num,
get_tx_contents_message.network_num())
tx_info = TransactionInfo(Sha256Hash(crypto.double_sha256(b"123")),
bytearray(4), 1)
tx_contents_message = self.create_message_successfully(
TxContentsMessage(test_network_num, tx_info), TxContentsMessage)
self.assertEqual(test_network_num, tx_contents_message.network_num())
result_tx_info = tx_contents_message.get_tx_info()
self.assertEqual(tx_info.hash, result_tx_info.hash)
self.assertEqual(tx_info.contents, result_tx_info.contents)
self.assertEqual(tx_info.short_id, result_tx_info.short_id)
short_ids = [1, 2, 33, 4444, 1234]
block_hash = Sha256Hash(helpers.generate_bytearray(32))
get_block_txs_message: GetCompressedBlockTxsMessage = self.create_message_successfully(
GetCompressedBlockTxsMessage(self.NETWORK_NUM, block_hash,
short_ids),
GetCompressedBlockTxsMessage)
self.assertEqual(self.NETWORK_NUM, get_block_txs_message.network_num())
self.assertEqual(block_hash, get_block_txs_message.block_hash())
self.assertEqual(len(short_ids), len(get_block_txs_message))
self.assertEqual(short_ids, get_block_txs_message.get_short_ids())
txs_info = [
TransactionInfo(Sha256Hash(helpers.generate_bytearray(32)),
helpers.generate_bytearray(200), 111),
TransactionInfo(Sha256Hash(helpers.generate_bytearray(32)),
helpers.generate_bytearray(300), 222),
TransactionInfo(Sha256Hash(helpers.generate_bytearray(32)),
helpers.generate_bytearray(400), 333)
]
block_txs_message: CompressedBlockTxsMessage = self.create_message_successfully(
CompressedBlockTxsMessage(self.NETWORK_NUM, block_hash, txs_info),
CompressedBlockTxsMessage)
self.assertEqual(self.NETWORK_NUM, block_txs_message.network_num())
self.assertEqual(block_hash, block_txs_message.block_hash())
self.assertEqual(len(txs_info), len(block_txs_message))
parsed_txs = block_txs_message.get_txs()
for index in range(len(txs_info)):
self.assertEqual(parsed_txs[index].short_id,
txs_info[index].short_id)
self.assertEqual(parsed_txs[index].contents,
txs_info[index].contents)
self.assertEqual(parsed_txs[index].hash, txs_info[index].hash)
def test_message_preview_success_all_types(self):
self.get_message_preview_successfully(
HelloMessage(protocol_version=1,
network_num=2), HelloMessage.MESSAGE_TYPE,
VersionMessage.VERSION_MESSAGE_LENGTH + UL_INT_SIZE_IN_BYTES +
NODE_ID_SIZE_IN_BYTES - UL_INT_SIZE_IN_BYTES)
self.get_message_preview_successfully(AckMessage(),
AckMessage.MESSAGE_TYPE,
constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(PingMessage(),
PingMessage.MESSAGE_TYPE, 9)
self.get_message_preview_successfully(PongMessage(),
PongMessage.MESSAGE_TYPE, 17)
blob = bytearray(1 for _ in range(4))
self.get_message_preview_successfully(
BroadcastMessage(self.HASH, 1, self.NODE_ID, self.BROADCAST_TYPE,
True, blob), BroadcastMessage.MESSAGE_TYPE,
SHA256_HASH_LEN + NETWORK_NUM_LEN + constants.BROADCAST_TYPE_LEN +
BLOCK_ENCRYPTED_FLAG_LEN + constants.NODE_ID_SIZE_IN_BYTES +
len(blob) + constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(
TxMessage(self.HASH, 1, self.NODE_ID, 12,
blob), TxMessage.MESSAGE_TYPE, SHA256_HASH_LEN +
NETWORK_NUM_LEN + UL_INT_SIZE_IN_BYTES + TRANSACTION_FLAG_LEN +
constants.NODE_ID_SIZE_IN_BYTES + len(blob) +
constants.DOUBLE_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(
KeyMessage(self.HASH, 1, self.NODE_ID,
bytearray(1 for _ in range(KEY_SIZE))),
KeyMessage.MESSAGE_TYPE,
SHA256_HASH_LEN + KEY_SIZE + NETWORK_NUM_LEN +
constants.NODE_ID_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(
BlockHoldingMessage(self.HASH, 1, self.NODE_ID),
BlockHoldingMessage.MESSAGE_TYPE,
SHA256_HASH_LEN + NETWORK_NUM_LEN +
constants.NODE_ID_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN)
get_txs = [1, 2, 3]
self.get_message_preview_successfully(
GetTxsMessage(get_txs), GetTxsMessage.MESSAGE_TYPE,
UL_INT_SIZE_IN_BYTES + UL_INT_SIZE_IN_BYTES * len(get_txs) +
constants.CONTROL_FLAGS_LEN)
txs = [
TransactionInfo(Sha256Hash(crypto.double_sha256(b"123")),
bytearray(4), 1),
TransactionInfo(Sha256Hash(crypto.double_sha256(b"234")),
bytearray(8), 2)
]
expected_length = (UL_INT_SIZE_IN_BYTES +
sum(UL_INT_SIZE_IN_BYTES + SHA256_HASH_LEN +
UL_INT_SIZE_IN_BYTES + len(tx.contents)
for tx in txs) + constants.CONTROL_FLAGS_LEN)
self.get_message_preview_successfully(TxsMessage(txs),
TxsMessage.MESSAGE_TYPE,
expected_length)
expected_length = (2 * constants.DOUBLE_SIZE_IN_BYTES) + (5 * constants.UL_SHORT_SIZE_IN_BYTES) + \
(7 * constants.UL_INT_SIZE_IN_BYTES) + constants.IP_ADDR_SIZE_IN_BYTES + \
constants.CONTROL_FLAGS_LEN
node_stats = {}
helpers.add_stats_to_node_stats(node_stats, "127.0.0.1", 8001, 200,
300, 400, 500, 600, 700, 800, 100, 50)
self.get_message_preview_successfully(
BdnPerformanceStatsMessage(datetime.utcnow(), datetime.utcnow(),
100, node_stats),
BdnPerformanceStatsMessage.MESSAGE_TYPE, expected_length)
# multi node bdn stats message
expected_length = (
constants.CONTROL_FLAGS_LEN +
(2 * constants.DOUBLE_SIZE_IN_BYTES) + # start/end time
constants.UL_SHORT_SIZE_IN_BYTES + # memory
constants.UL_SHORT_SIZE_IN_BYTES + # num blockchain peers
(
3 * # num blockchain peers
(
constants.IP_ADDR_SIZE_IN_BYTES + # ip
constants.UL_SHORT_SIZE_IN_BYTES + # port
(2 * constants.UL_SHORT_SIZE_IN_BYTES)
+ # original block stats
(7 * constants.UL_INT_SIZE_IN_BYTES)))) # rest of stats
node_stats = {}
helpers.add_stats_to_node_stats(node_stats, "127.0.0.1", 8001, 200,
300, 400, 500, 600, 700, 800, 100, 50)
helpers.add_stats_to_node_stats(node_stats, "127.0.0.2", 8002, 200,
300, 400, 500, 600, 700, 800, 100, 50)
helpers.add_stats_to_node_stats(node_stats, "127.0.0.3", 8003, 200,
300, 400, 500, 600, 700, 800, 100, 50)
self.get_message_preview_successfully(
BdnPerformanceStatsMessage(datetime.utcnow(), datetime.utcnow(),
100, node_stats),
BdnPerformanceStatsMessage.MESSAGE_TYPE, expected_length)
tx_info = TransactionInfo(crypto.double_sha256(b"123"), bytearray(4),
1)
expected_length = constants.NETWORK_NUM_LEN + constants.SID_LEN + SHA256_HASH_LEN + \
constants.UL_INT_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN + len(tx_info.contents)
self.get_message_preview_successfully(TxContentsMessage(5, tx_info),
TxContentsMessage.MESSAGE_TYPE,
expected_length)
expected_length = constants.NETWORK_NUM_LEN + constants.SID_LEN + constants.CONTROL_FLAGS_LEN
self.get_message_preview_successfully(
GetTxContentsMessage(1, 2), GetTxContentsMessage.MESSAGE_TYPE,
expected_length)
def test_create_message_success_all_types(self):
test_network_num = 10
test_protocol_version = bloxroute_version_manager.CURRENT_PROTOCOL_VERSION
hello_message = self.create_message_successfully(HelloMessage(protocol_version=test_protocol_version,
network_num=test_network_num,
node_id=self.NODE_ID
),
HelloMessage)
self.assertEqual(test_protocol_version, hello_message.protocol_version())
self.assertEqual(test_network_num, hello_message.network_num())
self.assertEqual(self.NODE_ID, hello_message.node_id())
self.create_message_successfully(AckMessage(), AckMessage)
self.create_message_successfully(PingMessage(), PingMessage)
self.create_message_successfully(PongMessage(), PongMessage)
blob = bytearray(4)
broadcast_message = self.create_message_successfully(BroadcastMessage(self.HASH,
network_num=test_network_num,
is_encrypted=True,
source_id=self.NODE_ID,
blob=blob),
BroadcastMessage)
self.assertEqual(self.HASH, broadcast_message.block_hash())
self.assertEqual(test_network_num, broadcast_message.network_num())
self.assertEqual(self.NODE_ID, broadcast_message.source_id())
self.assertTrue(broadcast_message.is_encrypted())
self.assertEqual(blob, broadcast_message.blob().tobytes())
sid = 12
tx_val = bytes(1 for _ in range(5))
tx_message = self.create_message_successfully(TxMessage(self.HASH,
network_num=test_network_num,
source_id=self.NODE_ID,
short_id=sid,
tx_val=tx_val),
TxMessage)
self.assertEqual(self.HASH, tx_message.tx_hash())
self.assertEqual(self.NODE_ID, tx_message.source_id())
self.assertEqual(sid, tx_message.short_id())
self.assertEqual(test_network_num, tx_message.network_num())
self.assertEqual(tx_val, tx_message.tx_val())
key = bytearray(1 for _ in range(KEY_SIZE))
key_message = self.create_message_successfully(
KeyMessage(self.HASH, test_network_num, self.NODE_ID, bytearray(1 for _ in range(KEY_SIZE))),
KeyMessage
)
self.assertEqual(key, key_message.key())
self.assertEqual(self.NODE_ID, key_message.source_id())
self.assertEqual(test_network_num, key_message.network_num())
self.assertEqual(self.HASH, key_message.block_hash())
block_holding_message = self.create_message_successfully(
BlockHoldingMessage(self.HASH, test_network_num, self.NODE_ID),
BlockHoldingMessage
)
self.assertEqual(self.NODE_ID, block_holding_message.source_id())
self.assertEqual(test_network_num, block_holding_message.network_num())
self.assertEqual(self.HASH, block_holding_message.block_hash())
get_txs = [1, 2, 3]
get_txs_message = self.create_message_successfully(GetTxsMessage(get_txs), GetTxsMessage)
self.assertEqual(get_txs, get_txs_message.get_short_ids())
txs = [TransactionInfo(Sha256Hash(crypto.double_sha256(b"123")), bytearray(4), 1),
TransactionInfo(Sha256Hash(crypto.double_sha256(b"234")), bytearray(8), 2)]
txs_message = self.create_message_successfully(TxsMessage(txs), TxsMessage)
result_txs = txs_message.get_txs()
for i, result_tx in enumerate(result_txs):
self.assertEqual(txs[i].hash, result_tx.hash)
self.assertEqual(txs[i].contents, result_tx.contents)
self.assertEqual(txs[i].short_id, result_tx.short_id)