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)