async def test_eth_transaction_receipts_feed_default_subscribe(self):
self.gateway_node.opts.eth_ws_uri = f"ws://{constants.LOCALHOST}:8005"
self.gateway_node.feed_manager.register_feed(
EthTransactionReceiptsFeed(self.gateway_node, 0))
self.gateway_node.eth_ws_proxy_publisher = MockEthWsProxyPublisher(
"", None, None, self.gateway_node)
receipt_result = {
"blockHash":
"0xe6f67c6948158c45dct10b169ad6bf3a96c6402489733a03051feaf7d09e7b54",
"blockNumber": "0xaf25e5",
"cumulativeGasUsed": "0xbdb9ae",
"from": "0x82170dd1cec50107963bf1ba1e80955ea302c5ce",
"gasUsed": "0x5208",
"logs": [],
"logsBloom":
"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"status": "0x1",
"to": "0xa09f63d9a0b0fbe89e41e51282ad660e7c876165",
"transactionHash":
"0xbcdc5b22bf463f9b8766dd61cc133caf13472b6ae8474061134d9dc2983625f6",
"transactionIndex": "0x90"
}
self.gateway_node.eth_ws_proxy_publisher.call_rpc = AsyncMock(
return_value=JsonRpcResponse(request_id=1, result=receipt_result))
block = mock_eth_messages.get_dummy_block(5)
internal_block_info = InternalEthBlockInfo.from_new_block_msg(
NewBlockEthProtocolMessage(None, block, 1))
eth_raw_block_1 = EthRawBlock(1, internal_block_info.block_hash(),
FeedSource.BLOCKCHAIN_RPC,
get_block_message_lazy(None))
eth_raw_block_2 = EthRawBlock(
1, internal_block_info.block_hash(), FeedSource.BLOCKCHAIN_SOCKET,
get_block_message_lazy(internal_block_info))
async with WsProvider(self.ws_uri) as ws:
subscription_id = await ws.subscribe(
rpc_constants.ETH_TRANSACTION_RECEIPTS_FEED_NAME)
self.gateway_node.feed_manager.publish_to_feed(
FeedKey(rpc_constants.ETH_TRANSACTION_RECEIPTS_FEED_NAME),
eth_raw_block_1)
self.gateway_node.feed_manager.publish_to_feed(
FeedKey(rpc_constants.ETH_TRANSACTION_RECEIPTS_FEED_NAME),
eth_raw_block_2)
for i in range(len(block.transactions)):
subscription_message = await ws.get_next_subscription_notification_by_id(
subscription_id)
self.assertEqual(subscription_id,
subscription_message.subscription_id)
self.assertEqual(subscription_message.notification,
{"receipt": receipt_result})
def generate_raw_block_msg(self,
block_number=10,
source=FeedSource.BLOCKCHAIN_SOCKET):
block_msg = self.generate_new_eth_block(block_number)
return EthRawBlock(block_msg.block_number(), block_msg.block_hash(),
source,
self.node._get_block_message_lazy(block_msg, None))
async def test_publish_block_no_subscribers(self):
self.sut.serialize = MagicMock(wraps=self.sut.serialize)
block_message = self.generate_new_eth_block()
internal_block_message = InternalEthBlockInfo.from_new_block_msg(
block_message)
self.sut.publish(
EthRawBlock(block_message.number(), block_message.block_hash(),
FeedSource.BLOCKCHAIN_SOCKET,
iter([internal_block_message])))
self.sut.serialize.assert_not_called()
async def test_publish_from_internal_block(self):
subscriber = self.sut.subscribe({})
block_message = self.generate_new_eth_block()
internal_block_message = InternalEthBlockInfo.from_new_block_msg(
block_message)
block_hash_str = f"0x{str(internal_block_message.block_hash())}"
self.sut.publish(
EthRawBlock(block_message.number(), block_message.block_hash(),
FeedSource.BLOCKCHAIN_SOCKET,
iter([internal_block_message])))
received_block = await subscriber.receive()
self._verify_block(block_hash_str, received_block)
def publish_blocks_from_queue(self, start_block_height,
end_block_height) -> Set[int]:
missing_blocks = set()
for block_number in range(start_block_height, end_block_height):
block_hash = self.node.block_queuing_service.accepted_block_hash_at_height.contents.get(
block_number)
if block_hash:
self.publish(
EthRawBlock(
block_number, block_hash, FeedSource.BDN_INTERNAL,
self.node._get_block_message_lazy(None, block_hash)))
else:
missing_blocks.add(block_number)
return missing_blocks
def publish_block(self, block_number: Optional[int],
block_hash: Sha256Hash,
block_message: Optional[InternalEthBlockInfo],
source: FeedSource) -> None:
if block_number is None and block_message is not None:
block_number = block_message.block_number()
logger.debug(
"Handle block notification for feed. Number: {}, Hash: {} Msg: {} From: {}",
block_number, block_hash, block_message, source)
if block_number and self.opts.ws:
raw_block = EthRawBlock(
block_number, block_hash, source,
self._get_block_message_lazy(block_message, block_hash))
self._publish_block_to_on_block_feed(raw_block)
self._publish_block_to_new_block_feed(raw_block)