def generate_eth_raw_transaction_with_to_address( source: FeedSource = FeedSource.BDN_SOCKET, to_address: str = helpers.generate_bytes(eth_common_constants.ADDRESS_LEN) ) -> EthRawTransaction: transaction = get_dummy_transaction(1, to_address_str=to_address) transactions_eth_message = TransactionsEthProtocolMessage( None, [transaction]) tx_message = EthNormalMessageConverter().tx_to_bx_txs( transactions_eth_message, 5)[0][0] return EthRawTransaction(tx_message.tx_hash(), tx_message.tx_val(), source)
def generate_new_eth_transaction() -> TxMessage: transaction = mock_eth_messages.get_dummy_transaction(1) transactions_eth_message = TransactionsEthProtocolMessage( None, [transaction]) tx_message = EthNormalMessageConverter().tx_to_bx_txs( transactions_eth_message, 5)[0][0] return tx_message
def setUp(self) -> None: opts = gateway_helpers.get_gateway_opts(8000, include_default_eth_args=True) self.node = MockGatewayNode(opts) self.connection = MagicMock(spec=AbstractGatewayBlockchainConnection) self.connection.node = self.node self.connection.is_active = MagicMock(return_value=True) self.connection.network_num = 5 self.connection.format_connection_desc = "127.0.0.1:12345 - B" self.node.set_known_total_difficulty = MagicMock() self.node.node_conn = self.connection self.node.message_converter = EthNormalMessageConverter() self.cleanup_service = EthNormalBlockCleanupService( self.node, NETWORK_NUM ) self.node.block_cleanup_service = self.cleanup_service self.node.block_processing_service = EthBlockProcessingService( self.node ) self.node.block_processing_service.queue_block_for_processing = MagicMock() self.node.block_queuing_service = EthBlockQueuingService(self.node) dummy_private_key = crypto_utils.make_private_key( helpers.generate_bytearray(111) ) dummy_public_key = crypto_utils.private_to_public_key(dummy_private_key) self.sut = EthNodeConnectionProtocol( self.connection, True, dummy_private_key, dummy_public_key ) self.sut._waiting_checkpoint_headers_request = False
def setUp(self) -> None: opts = gateway_helpers.get_gateway_opts(8000) self.node = MockGatewayNode(opts) self.node.message_converter = EthNormalMessageConverter() self.connection = helpers.create_connection(EthRelayConnection, self.node)
def create_eth_message_converter(opts): if opts.use_extensions or opts.import_extensions: from bxgateway.messages.eth.eth_extension_message_converter import EthExtensionMessageConverter # TODO temp - need to remove opts.enable_eth_extensions if opts.use_extensions and opts.enable_eth_extensions: return EthExtensionMessageConverter() else: return EthNormalMessageConverter()
def setUp(self) -> None: crypto_utils.recover_public_key = MagicMock( return_value=bytes(32)) pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" opts = gateway_helpers.get_gateway_opts(8000, include_default_eth_args=True, pub_key=pub_key) if opts.use_extensions: helpers.set_extensions_parallelism() node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) self.node = EthGatewayNode(opts, node_ssl_service) self.sut = EthNewBlockFeed(self.node) self.message_converter = EthNormalMessageConverter() crypto_utils.recover_public_key = MagicMock( return_value=bytes(32))
async def test_blxr_tx_ethereum_berlin(self): self.gateway_node.message_converter = EthNormalMessageConverter() self.gateway_node.network_num = 5 # legacy result = await self.request( BxJsonRpcRequest( "1", RpcRequestType.BLXR_TX, { rpc_constants.TRANSACTION_PARAMS_KEY: convert.bytes_to_hex(eth_fixtures.LEGACY_TRANSACTION), rpc_constants.STATUS_TRACK_PARAMS_KEY: "True" })) self.assertEqual("1", result.id) self.assertIsNone(result.error) self.assertEqual(eth_fixtures.LEGACY_TRANSACTION_HASH, result.result["tx_hash"]) self.assertEqual(1, len(self.gateway_node.broadcast_messages)) self.assertEqual( Sha256Hash( convert.hex_to_bytes(eth_fixtures.LEGACY_TRANSACTION_HASH)), self.gateway_node.broadcast_messages[0][0].tx_hash()) # access list result = await self.request( BxJsonRpcRequest( "1", RpcRequestType.BLXR_TX, { rpc_constants.TRANSACTION_PARAMS_KEY: convert.bytes_to_hex(eth_fixtures.ACL_TRANSACTION), rpc_constants.STATUS_TRACK_PARAMS_KEY: "True" })) self.assertEqual("1", result.id) self.assertIsNone(result.error) self.assertEqual(eth_fixtures.ACL_TRANSACTION_HASH, result.result["tx_hash"]) self.assertEqual(2, len(self.gateway_node.broadcast_messages)) self.assertEqual( Sha256Hash(convert.hex_to_bytes( eth_fixtures.ACL_TRANSACTION_HASH)), self.gateway_node.broadcast_messages[1][0].tx_hash())
def generate_new_eth_transaction() -> TxMessage: transaction = mock_eth_messages.get_dummy_transaction(1, to_address_str="ef26fd0f0f95d28408fc663b1e4de25855ff7f73") transactions_eth_message = TransactionsEthProtocolMessage(None, [transaction]) tx_message = EthNormalMessageConverter().tx_to_bx_txs(transactions_eth_message, 5)[0][0] return tx_message
def setUp(self) -> None: self.alarm_queue = AlarmQueue() self.sut = EthPendingTransactionFeed(self.alarm_queue) self.message_converter = EthNormalMessageConverter()
class EthPendingTransactionFeedTest(AbstractTestCase): def setUp(self) -> None: self.alarm_queue = AlarmQueue() self.sut = EthPendingTransactionFeed(self.alarm_queue) self.message_converter = EthNormalMessageConverter() def generate_new_eth_transaction(self) -> TxMessage: transaction = mock_eth_messages.get_dummy_transaction(1) transactions_eth_message = TransactionsEthProtocolMessage(None, [transaction]) tx_message = self.message_converter.tx_to_bx_txs( transactions_eth_message, 5 )[0][0] return tx_message def generate_eth_raw_transaction(self) -> EthRawTransaction: tx_message = self.generate_new_eth_transaction() return EthRawTransaction(tx_message.tx_hash(), tx_message.tx_val()) @async_test async def test_publish_transaction_bytes(self): subscriber = self.sut.subscribe({}) tx_message = self.generate_new_eth_transaction() tx_hash_str = f"0x{str(tx_message.tx_hash())}" self.sut.publish( EthRawTransaction(tx_message.tx_hash(), tx_message.tx_val()) ) received_tx = await subscriber.receive() self.assertEqual(tx_hash_str, received_tx.tx_hash) self.assertEqual(tx_hash_str, received_tx.tx_contents["hash"]) self.assertIn("from", received_tx.tx_contents) self.assertIn("gas", received_tx.tx_contents) self.assertIn("gas_price", received_tx.tx_contents) self.assertIn("input", received_tx.tx_contents) self.assertIn("value", received_tx.tx_contents) self.assertIn("to", received_tx.tx_contents) self.assertIn("nonce", received_tx.tx_contents) self.assertIn("v", received_tx.tx_contents) self.assertIn("r", received_tx.tx_contents) self.assertIn("s", received_tx.tx_contents) @async_test async def test_publish_transaction_dictionary(self): subscriber = self.sut.subscribe({}) transaction_hash_str = SAMPLE_TRANSACTION_FROM_WS["hash"] transaction_hash = Sha256Hash( convert.hex_to_bytes(transaction_hash_str[2:]) ) self.sut.publish( EthRawTransaction(transaction_hash, SAMPLE_TRANSACTION_FROM_WS) ) received_tx = await subscriber.receive() self.assertEqual(transaction_hash_str, received_tx.tx_hash) self.assertEqual(transaction_hash_str, received_tx.tx_contents["hash"]) self.assertIn("from", received_tx.tx_contents) self.assertIn("gas", received_tx.tx_contents) self.assertIn("gas_price", received_tx.tx_contents) self.assertIn("input", received_tx.tx_contents) self.assertIn("value", received_tx.tx_contents) self.assertIn("to", received_tx.tx_contents) self.assertIn("nonce", received_tx.tx_contents) self.assertIn("v", received_tx.tx_contents) self.assertIn("r", received_tx.tx_contents) self.assertIn("s", received_tx.tx_contents) @async_test async def test_publish_transaction_no_subscribers(self): self.sut.serialize = MagicMock(wraps=self.sut.serialize) self.sut.publish(self.generate_eth_raw_transaction()) self.sut.serialize.assert_not_called() @async_test async def test_publish_transaction_duplicate_transaction(self): self.sut.subscribe({}) self.sut.serialize = MagicMock(wraps=self.sut.serialize) raw_transaction = self.generate_eth_raw_transaction() self.sut.publish(raw_transaction) self.sut.publish(raw_transaction) self.sut.serialize.assert_called_once() @async_test async def test_publish_duplicate_transaction_subscriber_wants_duplicates(self): subscriber = self.sut.subscribe({"duplicates": True}) self.sut.serialize = MagicMock(wraps=self.sut.serialize) subscriber.queue = MagicMock(wraps=subscriber.queue) raw_transaction = self.generate_eth_raw_transaction() self.sut.publish(raw_transaction) self.sut.serialize.assert_called_once() self.sut.serialize.reset_mock() subscriber.queue.assert_called_once() subscriber.queue.reset_mock() self.sut.publish(raw_transaction) self.sut.serialize.assert_called_once() subscriber.queue.assert_called_once() @async_test async def test_publish_invalid_transaction(self): subscriber = self.sut.subscribe({}) transaction_hash = helpers.generate_object_hash() transaction_contents = helpers.generate_bytearray(250) self.sut.publish( EthRawTransaction(transaction_hash, transaction_contents) ) self.assertEqual(0, subscriber.messages.qsize())