def test_set_transaction_flag(self):
tx_message = TxMessage(helpers.generate_object_hash(),
1,
"",
tx_val=helpers.generate_bytearray(250),
transaction_flag=TransactionFlag.PAID_TX)
tx_message.set_transaction_flag(TransactionFlag.PAID_TX
| TransactionFlag.CEN_ENABLED
| TransactionFlag.LOCAL_REGION
| TransactionFlag.TBD_2)
reserialized_message = self._serialize_deserialize_message(tx_message)
self.assertTrue(TransactionFlag.CEN_ENABLED in
reserialized_message.transaction_flag())
self.assertTrue(TransactionFlag.LOCAL_REGION in
reserialized_message.transaction_flag())
self.assertTrue(
TransactionFlag.TBD_2 in reserialized_message.transaction_flag())
def tx_to_bx_txs(self, ont_tx_msg: TxOntMessage, network_num: int, quota_type: Optional[QuotaType] = None) -> \
List[Tuple[TxMessage, Sha256Hash, Union[bytearray, memoryview]]]:
tx_msg = TxMessage(ont_tx_msg.tx_hash(),
network_num,
tx_val=ont_tx_msg.tx(),
quota_type=quota_type)
return [(tx_msg, ont_tx_msg.tx_hash(), ont_tx_msg.tx())]
def test_tx_message(self):
tx_hash = Sha256Hash(helpers.generate_bytes(crypto.SHA256_HASH_LEN))
tx_contents = helpers.generate_bytes(250)
network_num = 1234
self._test_to_old_version_broadcast_message(TxMessage(message_hash=tx_hash, network_num=network_num,
source_id=NEW_VERSION_SOURCE_ID, tx_val=tx_contents))
self._test_to_new_version_broadcast_message(TxMessageV4(tx_hash=tx_hash, network_num=network_num,
tx_val=tx_contents))
def test_tx_bx_message_setting_attributes(self):
contents = helpers.generate_bytes(250)
timestamp = time.time()
tx_message = TxMessage(self.HASH,
network_num=1,
source_id=self.NODE_ID,
short_id=2,
tx_val=contents,
transaction_flag=TransactionFlag.PAID_TX,
timestamp=timestamp)
tx_message.clear_protected_fields()
rebuilt_tx_message = self.create_message_successfully(
tx_message, TxMessage)
self.assertEqual(constants.NULL_TX_SID, rebuilt_tx_message.short_id())
self.assertEqual(constants.NULL_TX_TIMESTAMP,
rebuilt_tx_message.timestamp())
def test_empty_bytes_no_bytes_sent(self):
message = TxMessage(
helpers.generate_object_hash(),
5,
tx_val=helpers.generate_bytearray(250),
)
message_length = len(message.rawbytes())
self.output_buffer.enqueue_msgbytes(message.rawbytes())
self.output_buffer.flush()
self.tracker.append_message(message_length, message)
self.output_buffer.safe_empty()
self.tracker.empty_bytes(self.output_buffer.length)
self.assertEqual(0, self.output_buffer.length)
self.assertEqual(0, self.tracker.bytes_remaining)
self.assertEqual(0, len(self.tracker.messages))
def process_transactions_message_from_node(
self, msg, min_tx_network_fee: int, enable_transaction_validation: bool
) -> List[ProcessTransactionMessageFromNodeResult]:
opts = self.node.opts
msg_bytes = msg.rawbytes()
if (isinstance(self.node, OntGatewayNode) or isinstance(self.node, EthGatewayNode)) and \
opts.process_node_txs_in_extension:
ext_processing_results = memoryview(
self.proxy.process_gateway_transaction_from_node(
tpe.InputBytes(msg_bytes), min_tx_network_fee,
enable_transaction_validation))
else:
return GatewayTransactionService.process_transactions_message_from_node(
self, msg, min_tx_network_fee, enable_transaction_validation)
result = []
offset = 0
txs_count, = struct.unpack_from("<I", ext_processing_results, offset)
offset += constants.UL_INT_SIZE_IN_BYTES
while offset < len(ext_processing_results):
seen, = struct.unpack_from("<?", ext_processing_results, offset)
offset += 1
tx_hash = Sha256Hash(
ext_processing_results[offset:offset + crypto.SHA256_HASH_LEN])
offset += crypto.SHA256_HASH_LEN
tx_offset, = struct.unpack_from("<I", ext_processing_results,
offset)
offset += constants.UL_INT_SIZE_IN_BYTES
tx_len, = struct.unpack_from("<I", ext_processing_results, offset)
offset += constants.UL_INT_SIZE_IN_BYTES
tx_validation_status, = struct.unpack_from("<I",
ext_processing_results,
offset)
offset += constants.UL_INT_SIZE_IN_BYTES
tx_contents = msg_bytes[tx_offset:tx_offset + tx_len]
result.append(
ProcessTransactionMessageFromNodeResult(
seen, tx_hash, tx_contents,
TxMessage(message_hash=tx_hash,
network_num=self.network_num,
tx_val=tx_contents),
TxValidationStatus(tx_validation_status)))
if not seen:
transaction_key = self.get_transaction_key(tx_hash)
self.set_transaction_contents_base_by_key(
transaction_key, False, 0, False, tx_contents, tx_len)
assert txs_count == len(result)
return result
def compare_tx_old_to_current(
self,
converted_current_message: TxMessage,
original_current_message: TxMessage,
):
self.assertEqual(int(original_current_message.timestamp()),
converted_current_message.timestamp())
self.assert_attributes_equal(
converted_current_message,
original_current_message,
[
"message_hash",
"tx_val",
"source_id",
"network_num",
"transaction_flag",
],
)
def tx_to_bx_txs(
self,
tx_msg,
network_num: int,
quota_type: Optional[QuotaType] = None,
min_tx_network_fee: int = 0
) -> List[Tuple[TxMessage, Sha256Hash, Union[bytearray, memoryview]]]:
bx_tx_msg = TxMessage(tx_msg.tx_hash(), network_num, tx_val=tx_msg.tx(), quota_type=quota_type)
return [(bx_tx_msg, tx_msg.tx_hash(), tx_msg.tx())]
def bdn_tx_to_bx_tx(
self,
raw_tx: Union[bytes, bytearray, memoryview],
network_num: int,
transaction_flag: Optional[TransactionFlag] = None) -> TxMessage:
return TxMessage(Sha256Hash(crypto.double_sha256(raw_tx)),
network_num,
tx_val=raw_tx,
transaction_flag=transaction_flag)
def old_tx_message(self, original_message: TxMessage) -> TxMessageV21:
return TxMessageV21(original_message.message_hash(),
original_message.network_num(),
original_message.source_id(),
original_message.short_id(),
original_message.tx_val(),
original_message.transaction_flag(),
original_message.timestamp())
def tx_message(self) -> TxMessage:
return TxMessage(
helpers.generate_object_hash(),
self.NETWORK_NUMBER,
self.NODE_ID,
50,
helpers.generate_bytearray(250),
TransactionFlag.PAID_TX,
time.time(),
)
def test_msg_tx__compact_then_full(self):
tx_service = self.connection.node.get_tx_service()
short_id = 1
tx_hash = helpers.generate_object_hash()
tx_content = helpers.generate_bytearray(250)
compact_tx_msg = TxMessage(message_hash=tx_hash,
network_num=1,
short_id=short_id)
no_short_id_tx_msg = TxMessage(message_hash=tx_hash,
network_num=1,
tx_val=tx_content)
self.connection.msg_tx(compact_tx_msg)
self.connection.msg_tx(no_short_id_tx_msg)
self.assertEqual(short_id, tx_service.get_short_id(tx_hash))
self.assertEqual(tx_content,
tx_service.get_transaction_by_hash(tx_hash))
def tx_to_bx_txs(
self,
tx_msg,
network_num: int,
transaction_flag: Optional[TransactionFlag] = None,
min_tx_network_fee: int = 0
) -> List[Tuple[TxMessage, Sha256Hash, Union[bytearray, memoryview]]]:
bx_tx_msg = TxMessage(tx_msg.tx_hash(),
network_num,
tx_val=tx_msg.tx(),
transaction_flag=transaction_flag)
return [(bx_tx_msg, tx_msg.tx_hash(), tx_msg.tx())]
def compare_tx_old_to_current(
self,
converted_current_message: TxMessage,
original_current_message: TxMessage,
):
self.assertEqual(TransactionFlag.NO_FLAGS,
converted_current_message.transaction_flag())
self.assert_attributes_equal(
original_current_message,
converted_current_message,
["message_hash", "tx_val", "source_id", "network_num"],
)
def test_empty_bytes_more_bytes(self):
total_bytes = 0
for _ in range(100):
message = TxMessage(
helpers.generate_object_hash(),
5,
tx_val=helpers.generate_bytearray(2500),
)
message_length = len(message.rawbytes())
total_bytes += message_length
self.output_buffer.enqueue_msgbytes(message.rawbytes())
self.tracker.append_message(message_length, message)
self.output_buffer.advance_buffer(3500)
self.tracker.advance_bytes(3500)
self.output_buffer.safe_empty()
self.tracker.empty_bytes(self.output_buffer.length)
self.assertEqual(self.output_buffer.length,
self.tracker.bytes_remaining)
def bdn_tx_to_bx_tx(
self,
raw_tx: Union[bytes, bytearray, memoryview],
network_num: int,
transaction_flag: Optional[TransactionFlag] = None,
account_id: str = common_constants.DECODED_EMPTY_ACCOUNT_ID
) -> TxMessage:
return TxMessage(Sha256Hash(crypto.double_sha256(raw_tx)),
network_num,
tx_val=raw_tx,
transaction_flag=transaction_flag,
account_id=account_id)
def test_tx_msg_to_btc_tx_msg__success(self):
tx_hash = Sha256Hash(helpers.generate_bytearray(SHA256_HASH_LEN))
tx = mock_btc_messages.generate_btc_tx().payload()
tx_msg = TxMessage(message_hash=tx_hash, network_num=12345, tx_val=tx)
btc_tx_msg = self.btc_message_converter.bx_tx_to_tx(tx_msg)
self.assertTrue(btc_tx_msg)
self.assertEqual(btc_tx_msg.magic(), self.MAGIC)
self.assertEqual(btc_tx_msg.command(), b"tx")
self.assertEqual(btc_tx_msg.payload(), tx)
def tx_message(
network_num: int = 1,
source_id: str = "",
short_id: int = constants.NULL_TX_SID
) -> TxMessage:
return TxMessage(
helpers.generate_object_hash(),
network_num,
source_id,
short_id,
helpers.generate_bytearray(250),
account_id=helpers.generate_object_hash().to_string()
)
def test_msg_tx__full_message(self):
tx_service = self.connection.node.get_tx_service()
short_id = 1
tx_hash = helpers.generate_object_hash()
tx_content = helpers.generate_bytearray(250)
full_message = TxMessage(message_hash=tx_hash, network_num=1, short_id=short_id, tx_val=tx_content)
transaction_key = tx_service.get_transaction_key(tx_hash)
self.connection.msg_tx(full_message)
self.assertEqual(short_id, tx_service.get_short_id_by_key(transaction_key))
self.assertEqual(tx_content, tx_service.get_transaction_by_key(transaction_key))
def tx_to_bx_txs(
self,
tx_msg,
network_num: int,
transaction_flag: Optional[TransactionFlag] = None,
min_tx_network_fee: int = 0
) -> List[Tuple[TxMessage, Sha256Hash, Union[bytearray, memoryview]]]:
if not isinstance(tx_msg, TxBtcMessage):
raise TypeError("tx_msg is expected to be of type TxBTCMessage")
bx_tx_msg = TxMessage(tx_msg.tx_hash(), network_num, tx_val=tx_msg.tx(), transaction_flag=transaction_flag)
return [(bx_tx_msg, tx_msg.tx_hash(), tx_msg.tx())]
def test_empty_bytes(self):
message1 = TxMessage(
helpers.generate_object_hash(),
5,
tx_val=helpers.generate_bytearray(250),
)
message2 = TxMessage(
helpers.generate_object_hash(),
5,
tx_val=helpers.generate_bytearray(250),
)
message3 = TxMessage(
helpers.generate_object_hash(),
5,
tx_val=helpers.generate_bytearray(250),
)
message_length = len(message1.rawbytes())
self.output_buffer.enqueue_msgbytes(message1.rawbytes())
self.output_buffer.flush()
self.output_buffer.enqueue_msgbytes(message2.rawbytes())
self.output_buffer.enqueue_msgbytes(message3.rawbytes())
self.tracker.append_message(message_length, message1)
self.tracker.append_message(message_length, message2)
self.tracker.append_message(message_length, message3)
self.output_buffer.advance_buffer(120)
self.tracker.advance_bytes(120)
self.output_buffer.safe_empty()
self.assertEqual(message_length - 120, self.output_buffer.length)
self.tracker.empty_bytes(self.output_buffer.length)
self.assertEqual(1, len(self.tracker.messages))
self.assertEqual(message_length - 120, self.tracker.bytes_remaining)
self.assertEqual(120, self.tracker.messages[0].sent_bytes)
def tx_to_bx_txs(
self,
tx_msg,
network_num: int,
transaction_flag: Optional[TransactionFlag] = None,
min_tx_network_fee: int = 0,
account_id: str = common_constants.DECODED_EMPTY_ACCOUNT_ID
) -> List[Tuple[TxMessage, Sha256Hash, Union[bytearray, memoryview]]]:
bx_tx_msg = TxMessage(tx_msg.tx_hash(),
network_num,
tx_val=tx_msg.tx(),
transaction_flag=transaction_flag,
account_id=account_id)
return [(bx_tx_msg, tx_msg.tx_hash(), tx_msg.tx())]
def ont_bdn_tx_to_bx_tx(
raw_tx: Union[bytes, bytearray, memoryview],
network_num: int,
transaction_flag: Optional[TransactionFlag] = None) -> TxMessage:
if isinstance(raw_tx, bytes):
raw_tx = bytearray(raw_tx)
try:
tx_hash, _ = ont_common_utils.get_txid(raw_tx)
except IndexError:
raise ValueError("Invalid raw transaction provided.")
return TxMessage(message_hash=tx_hash,
network_num=network_num,
tx_val=raw_tx,
transaction_flag=transaction_flag)
def old_tx_message(self, original_message: TxMessage) -> TxMessageV7:
return TxMessageV7(
original_message.message_hash(),
original_message.network_num(),
original_message.source_id(),
original_message.short_id(),
original_message.tx_val(),
original_message.transaction_flag().get_quota_type(),
)
def test_transaction_propagation(self):
initial_message = TxOntMessage(12345, 123,
helpers.generate_bytearray(250))
self.gateway_1.account_id = "12345"
transaction_hash = initial_message.tx_hash()
transaction_key = self.gateway_1._tx_service.get_transaction_key(
transaction_hash)
self.gateway_1_receive_message_from_blockchain(initial_message)
time.time = MagicMock(return_value=time.time() + 1)
self.gateway_1.alarm_queue.fire_alarms()
self.assertTrue(
self.gateway_1._tx_service.has_transaction_contents_by_key(
transaction_key))
self.assertFalse(
self.gateway_1._tx_service.has_transaction_short_id_by_key(
transaction_key))
messages_for_relay = self.gateway_1_get_queued_messages_for_relay()
self.assertEqual(1, len(messages_for_relay))
tx_message = messages_for_relay[0]
self.assertIsInstance(tx_message, TxMessage)
self.assertEqual(tx_message.tx_hash(), transaction_hash)
tx_message_with_short_id = TxMessage(tx_message.message_hash(),
tx_message.network_num(),
short_id=10,
tx_val=tx_message.tx_val())
self.gateway_2_receive_message_from_relay(tx_message_with_short_id)
self.assertTrue(
self.gateway_2._tx_service.has_transaction_contents_by_key(
transaction_key))
self.assertTrue(
self.gateway_2._tx_service.has_transaction_short_id_by_key(
transaction_key))
self.assertEqual(
10,
self.gateway_2._tx_service.get_short_id_by_key(transaction_key))
messages_for_blockchain = self.gateway_2_get_queued_messages_for_blockchain(
)
self.assertEqual(1, len(messages_for_blockchain))
tx_ont_message = messages_for_blockchain[0]
self.assertIsInstance(tx_ont_message, TxOntMessage)
self.assertEqual(tx_ont_message.tx_hash(), transaction_hash)
self.assertEqual(tx_ont_message.tx(), initial_message.tx())
def test_tx_stats_redundant_tx_contents_from_relay(self):
tx_hash = helpers.generate_object_hash()
tx_content = helpers.generate_bytearray(250)
short_id = 1
full_message = TxMessage(message_hash=tx_hash,
network_num=1,
short_id=short_id,
tx_val=tx_content)
self.relay_connection.msg_tx(full_message)
short_id = 2
full_message = TxMessage(message_hash=tx_hash,
network_num=1,
short_id=short_id,
tx_val=tx_content)
self.relay_connection.msg_tx(full_message)
self.assertEqual(
2, gateway_transaction_stats_service.interval_data.
new_full_transactions_received_from_relays)
self.assertEqual(
0, gateway_transaction_stats_service.interval_data.
duplicate_full_transactions_received_from_relays)
self.assertEqual(
0, gateway_transaction_stats_service.interval_data.
new_compact_transactions_received_from_relays)
self.assertEqual(
0, gateway_transaction_stats_service.interval_data.
duplicate_compact_transactions_received_from_relays)
self.assertEqual(
2, gateway_transaction_stats_service.interval_data.
short_id_assignments_processed)
self.assertEqual(
1, gateway_transaction_stats_service.interval_data.
redundant_transaction_content_messages)
def btc_bdn_tx_to_bx_tx(
raw_tx: Union[bytes, bytearray, memoryview],
network_num: int,
transaction_flag: Optional[TransactionFlag] = None,
account_id: str = constants.DECODED_EMPTY_ACCOUNT_ID) -> TxMessage:
if isinstance(raw_tx, bytes):
raw_tx = bytearray(raw_tx)
try:
tx_hash = btc_common_utils.get_txid(raw_tx)
except IndexError:
raise ValueError("Invalid raw transaction provided.")
return TxMessage(message_hash=tx_hash,
network_num=network_num,
tx_val=raw_tx,
transaction_flag=transaction_flag,
account_id=account_id)
def compare_tx_old_to_current(
self,
converted_current_message: TxMessage,
original_current_message: TxMessage,
):
self.assertEqual(constants.NULL_TX_TIMESTAMP,
converted_current_message.timestamp())
self.assert_attributes_equal(
converted_current_message,
original_current_message,
[
"message_hash",
"tx_val",
"source_id",
"network_num",
"quota_type",
],
)
def raw_tx_to_bx_tx(
tx_bytes: Union[bytearray, memoryview],
tx_start_index: int,
network_num: int,
transaction_flag: Optional[TransactionFlag] = None
) -> Tuple[TxMessage, int, int]:
if isinstance(tx_bytes, bytearray):
tx_bytes = memoryview(tx_bytes)
_, tx_item_length, tx_item_start = rlp_utils.consume_length_prefix(
tx_bytes, tx_start_index)
tx_bytes = tx_bytes[tx_start_index:tx_item_start + tx_item_length]
tx_hash_bytes = keccak_hash(tx_bytes)
msg_hash = Sha256Hash(tx_hash_bytes)
bx_tx = TxMessage(message_hash=msg_hash,
network_num=network_num,
tx_val=tx_bytes,
transaction_flag=transaction_flag)
return bx_tx, tx_item_length, tx_item_start
def test_bx_tx_to_tx__success(self):
tx = mock_eth_messages.get_dummy_transaction(1)
tx_bytes = rlp.encode(tx, Transaction)
tx_hash_bytes = hashlib.sha256(tx_bytes).digest()
tx_hash = Sha256Hash(tx_hash_bytes)
bx_tx_message = TxMessage(message_hash=tx_hash, network_num=self.test_network_num, tx_val=tx_bytes)
tx_message = self.eth_message_converter.bx_tx_to_tx(bx_tx_message)
self.assertIsNotNone(tx_message)
self.assertIsInstance(tx_message, TransactionsEthProtocolMessage)
self.assertTrue(tx_message.get_transactions())
self.assertEqual(1, len(tx_message.get_transactions()))
tx_obj = tx_message.get_transactions()[0]
self.assertEqual(tx, tx_obj)