revive: Skip redundant eth_block_hash RPC call in block subscription

insert_block_receipts already receives the ethereum block hash from the
caller (via eth_block().hash), but extract_from_block was fetching it
again via a separate state_call RPC. This redundant call occasionally
stalls for 10-20s on public RPC nodes, causing the block cache to fall
behind and the health check to report out-of-sync.

Add extract_from_block_with_eth_hash that accepts a pre-fetched hash,
and use it from insert_block_receipts. The original extract_from_block
still fetches the hash for callers that don't have it.

Author: pgherveou

substrate/frame/revive/rpc/src/client.rs

@@ -361,14 +361,30 @@ impl Client {
 	) -> Result<(), ClientError> {
 		log::info!(target: LOG_TARGET, "🔌 Subscribing to new blocks ({subscription_type:?})");
 		self.subscribe_new_blocks(subscription_type, |block| async {
+			macro_rules! time {
+				($label:expr, $expr:expr) => {{
+					let t = std::time::Instant::now();
+					let r = $expr;
+					log::trace!(
+						target: LOG_TARGET,
+						"⏱️ [{subscription_type:?}] #{} {}: {:?}",
+						block.number(),
+						$label,
+						t.elapsed(),
+					);
+					r
+				}};
+			}
+
 			let hash = block.hash();
-			let evm_block = self.runtime_api(hash).eth_block().await?;
-			let (_, receipts): (Vec<_>, Vec<_>) = self
-				.receipt_provider
-				.insert_block_receipts(&block, &evm_block.hash)
-				.await?
-				.into_iter()
-				.unzip();
+			let evm_block = time!("eth_block", self.runtime_api(hash).eth_block().await?);
+
+			let (_, receipts): (Vec<_>, Vec<_>) = time!(
+				"insert_block_receipts",
+				self.receipt_provider.insert_block_receipts(&block, &evm_block.hash).await?
+			)
+			.into_iter()
+			.unzip();
 
 			self.block_provider.update_latest(Arc::new(block), subscription_type).await;
 			self.fee_history_provider.update_fee_history(&evm_block, &receipts).await;

substrate/frame/revive/rpc/src/receipt_extractor.rs

@@ -232,20 +232,26 @@ impl ReceiptExtractor {
 	pub async fn extract_from_block(
 		&self,
 		block: &SubstrateBlock,
+	) -> Result<Vec<(TransactionSigned, ReceiptInfo)>, ClientError> {
+		let eth_block_hash = self
+			.get_ethereum_block_hash(&block.hash(), block.number() as u64)
+			.await
+			.unwrap_or(block.hash());
+		self.extract_from_block_with_eth_hash(block, eth_block_hash).await
+	}
+
+	/// Extract receipts from block, using a pre-fetched ethereum block hash.
+	pub async fn extract_from_block_with_eth_hash(
+		&self,
+		block: &SubstrateBlock,
+		eth_block_hash: H256,
 	) -> Result<Vec<(TransactionSigned, ReceiptInfo)>, ClientError> {
 		if self.is_before_earliest_block(block.number()) {
 			return Ok(vec![]);
 		}
 
 		let ext_iter = self.get_block_extrinsics(block).await?;
 
-		let substrate_block_number = block.number() as u64;
-		let substrate_block_hash = block.hash();
-		let eth_block_hash =
-			(self.fetch_eth_block_hash)(substrate_block_hash, substrate_block_number)
-				.await
-				.unwrap_or(substrate_block_hash);
-
 		// Process extrinsics in order while maintaining parallelism within buffer window
 		stream::iter(ext_iter)
 			.map(|(ext, call, receipt, ext_idx)| async move {

substrate/frame/revive/rpc/src/receipt_provider.rs

@@ -245,7 +245,10 @@ impl<B: BlockInfoProvider> ReceiptProvider<B> {
 		block: &SubstrateBlock,
 		ethereum_hash: &H256,
 	) -> Result<Vec<(TransactionSigned, ReceiptInfo)>, ClientError> {
-		let receipts = self.receipts_from_block(block).await?;
+		let receipts = self
+			.receipt_extractor
+			.extract_from_block_with_eth_hash(block, *ethereum_hash)
+			.await?;
 		self.insert(block, &receipts, ethereum_hash).await?;
 		Ok(receipts)
 	}