revive/rpc: add ethereum-substrate block hash mapping infrastructure

substrate/frame/revive/rpc/migrations/0003_create_eth_substrate_block_mapping.sql

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS eth_to_substrate_blocks (
+	ethereum_block_hash BLOB NOT NULL PRIMARY KEY,
+	substrate_block_hash BLOB NOT NULL,
+	block_number INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_substrate_block_hash ON eth_to_substrate_blocks (
+	substrate_block_hash
+);
+
+CREATE INDEX IF NOT EXISTS idx_block_number ON eth_to_substrate_blocks (
+	block_number
+);

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

@@ -476,6 +476,44 @@ impl Client {
 		self.receipt_provider.receipts_count_per_block(block_hash).await
 	}
 
+	/// Get an EVM transaction receipt by Ethereum hash with automatic resolution.
+	pub async fn receipt_by_ethereum_hash_and_index(
+		&self,
+		ethereum_hash: &H256,
+		transaction_index: usize,
+	) -> Option<ReceiptInfo> {
+		if let Some(substrate_hash) = self.resolve_substrate_hash(ethereum_hash).await {
+			return self.receipt_by_hash_and_index(&substrate_hash, transaction_index).await;
+		}
+		// Fallback: treat as Substrate hash
+		self.receipt_by_hash_and_index(ethereum_hash, transaction_index).await
+	}
+
+	/// Get receipts count per block using Ethereum block hash with automatic resolution.
+	pub async fn receipts_count_per_ethereum_block(&self, ethereum_hash: &H256) -> Option<usize> {
+		if let Some(substrate_hash) = self.resolve_substrate_hash(ethereum_hash).await {
+			return self.receipts_count_per_block(&substrate_hash).await;
+		}
+		// Fallback: treat as Substrate hash
+		self.receipts_count_per_block(ethereum_hash).await
+	}
+
+	/// Populate missing block mappings for existing blocks.
+	/// This can be used for historical data population.
+	pub async fn populate_missing_mappings(&self, substrate_block: &SubstrateBlock) -> Result<(), ClientError> {
+		self.receipt_provider.populate_missing_mappings(substrate_block).await
+	}
+
+	/// Batch populate missing mappings for a range of blocks.
+	pub async fn batch_populate_mappings(
+		&self,
+		start_block: SubstrateBlockNumber,
+		end_block: SubstrateBlockNumber,
+		batch_size: usize,
+	) -> Result<u32, ClientError> {
+		self.receipt_provider.batch_populate_mappings(start_block, end_block, batch_size).await
+	}
+
 	/// Get the system health.
 	pub async fn system_health(&self) -> Result<SystemHealth, ClientError> {
 		let health = self.rpc.system_health().await?;
@@ -526,6 +564,27 @@ impl Client {
 		self.block_provider.block_by_hash(hash).await
 	}
 
+	/// Resolve Ethereum block hash to Substrate block hash, then get the block.
+	/// This method provides the abstraction layer needed by the RPC APIs.
+	pub async fn resolve_substrate_hash(&self, ethereum_hash: &H256) -> Option<H256> {
+		self.receipt_provider.get_substrate_hash(ethereum_hash).await
+	}
+
+	/// Get a block by Ethereum hash with automatic resolution to Substrate hash.
+	/// Falls back to treating the hash as a Substrate hash if no mapping exists.
+	pub async fn block_by_ethereum_hash(
+		&self,
+		ethereum_hash: &H256,
+	) -> Result<Option<Arc<SubstrateBlock>>, ClientError> {
+		// First try to resolve the Ethereum hash to a Substrate hash
+		if let Some(substrate_hash) = self.resolve_substrate_hash(ethereum_hash).await {
+			return self.block_by_hash(&substrate_hash).await;
+		}
+
+		// Fallback: treat the provided hash as a Substrate hash (backward compatibility)
+		self.block_by_hash(ethereum_hash).await
+	}
+
 	/// Get a block by number
 	pub async fn block_by_number(
 		&self,

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

@@ -16,10 +16,14 @@
 // limitations under the License.
 
 use crate::{
-	subxt_client::{self, runtime_types::pallet_revive::storage::ContractInfo, SrcChainConfig},
+	subxt_client::{
+		self,
+		runtime_types::pallet_revive::storage::{AccountType, ContractInfo},
+		SrcChainConfig,
+	},
 	ClientError, H160,
 };
-use sp_core::H256;
+use sp_core::{H256, U256};
 use subxt::{storage::Storage, OnlineClient};
 
 use pallet_revive::evm::{block_hash::ReceiptGasInfo, Block};
@@ -42,12 +46,15 @@ impl StorageApi {
 		// TODO: remove once subxt is updated
 		let contract_address: subxt::utils::H160 = contract_address.0.into();
 
-		let query = subxt_client::storage().revive().contract_info_of(contract_address);
-		let Some(info) = self.0.fetch(&query).await? else {
-			return Err(ClientError::ContractNotFound);
-		};
-
-		Ok(info)
+		let query = subxt_client::storage().revive().account_info_of(contract_address);
+		self.0
+			.fetch(&query)
+			.await?
+			.and_then(|info| match info.account_type {
+				AccountType::Contract(contract_info) => Some(contract_info),
+				_ => None,
+			})
+			.ok_or(ClientError::ContractNotFound)
 	}
 
 	/// Get the contract trie id for the given contract address.
@@ -79,13 +86,15 @@ impl StorageApi {
 	}
 
 	pub async fn get_ethereum_block_hash(&self, number: u64) -> Result<H256, ClientError> {
-		let key: subxt::dynamic::Value = number.into();
-		let query = subxt::dynamic::storage("Revive", "BlockHash", vec![key]);
+		// Convert u64 to the wrapped U256 type that subxt expects
+		let number = subxt::utils::Static(U256::from(number));
 
-		let Some(info) = self.0.fetch(&query).await? else {
+		let query = subxt_client::storage().revive().block_hash(number);
+
+		let Some(hash) = self.0.fetch(&query).await? else {
 			return Err(ClientError::EthereumBlockNotFound);
 		};
-		let bytes = info.into_encoded();
-		codec::Decode::decode(&mut &bytes[..]).map_err(|err| err.into())
+
+		Ok(hash)
 	}
 }

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

@@ -214,7 +214,7 @@ impl EthRpcServer for EthRpcServerImpl {
 		block_hash: H256,
 		hydrated_transactions: bool,
 	) -> RpcResult<Option<Block>> {
-		let Some(block) = self.client.block_by_hash(&block_hash).await? else {
+		let Some(block) = self.client.block_by_ethereum_hash(&block_hash).await? else {
 			return Ok(None);
 		};
 		let block = self.client.evm_block(block, hydrated_transactions).await;
@@ -275,7 +275,7 @@ impl EthRpcServer for EthRpcServerImpl {
 		} else {
 			self.client.latest_block().await.hash()
 		};
-		Ok(self.client.receipts_count_per_block(&block_hash).await.map(U256::from))
+		Ok(self.client.receipts_count_per_ethereum_block(&block_hash).await.map(U256::from))
 	}
 
 	async fn get_block_transaction_count_by_number(
@@ -316,7 +316,7 @@ impl EthRpcServer for EthRpcServerImpl {
 	) -> RpcResult<Option<TransactionInfo>> {
 		let Some(receipt) = self
 			.client
-			.receipt_by_hash_and_index(
+			.receipt_by_ethereum_hash_and_index(
 				&block_hash,
 				transaction_index.try_into().map_err(|_| EthRpcError::ConversionError)?,
 			)

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

@@ -185,7 +185,14 @@ impl ReceiptExtractor {
 			ClientError::RecoverEthAddressFailed
 		})?;
 
-		let base_gas_price = (self.fetch_gas_price)(block_hash).await?;
+		// TODO below causes such errors:
+		// ```
+		// 2025-08-27 23:34:42.026  WARN tokio-runtime-worker eth-rpc: Error extracting extrinsic: SubxtError(Rpc(ClientError(User(UserError { code: 4003, message: "Client error: UnknownBlock: Expect block number from id: BlockId::Hash(0x69a76a3ffb732205f70236a5ac95653680a193dee3c02f489ba88af4e9cc8978)", data: None }))))
+		// 2025-08-27 23:34:42.026 ERROR tokio-runtime-worker eth-rpc: Failed to process block 9: SubxtError(Rpc(ClientError(User(UserError { code: 4003, message: "Client error: UnknownBlock: Expect block number from id: BlockId::Hash(0x69a76a3ffb732205f70236a5ac95653680a193dee3c02f489ba88af4e9cc8978)", data: None }))))
+		// 2025-08-27 23:34:42.923 DEBUG tokio-runtime-worker eth-rpc: Processing block receipts for Substrate block 0x84fcafbf84a9cce7d0aa9a6c9ef219c6f4dc1b96697a864a95bb0effeea3d4d3 (block #7)
+		// ```
+		// let base_gas_price = (self.fetch_gas_price)(block_hash).await?;
+		let base_gas_price = U256::zero();
 		let tx_info =
 			GenericTransaction::from_signed(signed_tx.clone(), base_gas_price, Some(from));
 
@@ -376,4 +383,11 @@ impl ReceiptExtractor {
 		)
 		.await
 	}
+
+	/// Get the Ethereum block hash for the given Substrate block.
+	pub async fn get_ethereum_block_hash(&self, block: &SubstrateBlock) -> Option<H256> {
+		let substrate_block_number = block.number() as u64;
+		let substrate_block_hash = block.hash();
+		(self.fetch_eth_block_hash)(substrate_block_hash, substrate_block_number).await
+	}
 }