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())
