[Anvil] Fix use of Ethereum hashes in RPC endpoints (#468)

* Use eth hash in eth_GetBlockByHash

* Prevent docker from trying to use SSH

* remove hash resolving in test utility method

* Fix use of block hash across endpoints

* fix

* fix send_transaction

* fix tests for metadata endpoints

* fix test_anvil_node

* Fix + index genesis block eth hash

* Best-effort indexing for latest block

* make tests less flaky

* Subscribe and cache genesis block manually

* nit - revert unnecessary changes

Author: re-gius

crates/anvil-polkadot/docker/Dockerfile

@@ -26,7 +26,8 @@ COPY . .
 # Optionally switch to a specific git ref (tag/branch/commit) before building.
 # If RELEASE_REF is not set, the current workspace state is used.
 RUN if [ -n "$RELEASE_REF" ]; then \
-      git fetch --tags origin && \
+      git remote set-url origin https://github.com/paritytech/foundry-polkadot.git && \
+      git fetch --tags --force origin && \
       git checkout "$RELEASE_REF"; \
     fi
 

crates/anvil-polkadot/src/api_server/server.rs

@@ -689,14 +689,17 @@ impl ApiServer {
         Ok(code.into())
     }
 
+    /// Returns the EVM block with the given ethereum hash.
     async fn get_block_by_hash(
         &self,
         block_hash: B256,
         hydrated_transactions: bool,
     ) -> Result<Option<Block>> {
         node_info!("eth_getBlockByHash");
-        let Some(block) =
-            self.eth_rpc_client.block_by_hash(&H256::from_slice(block_hash.as_slice())).await?
+        let Some(block) = self
+            .eth_rpc_client
+            .block_by_ethereum_hash(&H256::from_slice(block_hash.as_slice()))
+            .await?
         else {
             return Ok(None);
         };
@@ -795,8 +798,12 @@ impl ApiServer {
             return Err(Error::ReviveRpc(EthRpcError::InvalidTransaction));
         };
 
-        let latest_block = self.latest_block();
-        let latest_block_id = Some(BlockId::hash(B256::from_slice(latest_block.as_ref())));
+        let best_hash = self.latest_block();
+        let best_eth_hash =
+            self.eth_rpc_client.resolve_ethereum_hash(&best_hash).await.ok_or_else(|| {
+                Error::InternalError("Ethereum block hash of latest block not found".to_string())
+            })?;
+        let latest_block_id = Some(BlockId::hash(B256::from_slice(best_eth_hash.as_ref())));
         let account = if self.impersonation_manager.is_impersonated(from) || unsigned_tx {
             None
         } else {
@@ -824,7 +831,7 @@ impl ApiServer {
 
         if transaction.chain_id.is_none() {
             transaction.chain_id =
-                Some(sp_core::U256::from_big_endian(&self.chain_id(latest_block).to_be_bytes()));
+                Some(sp_core::U256::from_big_endian(&self.chain_id(best_hash).to_be_bytes()));
         }
 
         let tx = transaction
@@ -935,27 +942,27 @@ impl ApiServer {
         node_info!("anvil_nodeInfo");
 
         let best_hash = self.latest_block();
-        let Some(current_block) =
-            self.get_block_by_hash(B256::from_slice(best_hash.as_ref()), false).await?
-        else {
+        let Some(latest_evm_block) = self.get_block_by_substrate_hash(best_hash).await? else {
             return Err(Error::InternalError("Latest block not found".to_string()));
         };
         let current_block_number: u64 =
-            current_block.number.try_into().map_err(|_| EthRpcError::ConversionError)?;
+            latest_evm_block.number.try_into().map_err(|_| EthRpcError::ConversionError)?;
         let current_block_timestamp: u64 =
-            current_block.timestamp.try_into().map_err(|_| EthRpcError::ConversionError)?;
+            latest_evm_block.timestamp.try_into().map_err(|_| EthRpcError::ConversionError)?;
         // This is both gas price and base fee, since pallet-revive does not support tips
         // https://github.com/paritytech/polkadot-sdk/blob/227c73b5c8810c0f34e87447f00e96743234fa52/substrate/frame/revive/rpc/src/lib.rs#L269
-        let base_fee: u128 =
-            current_block.base_fee_per_gas.try_into().map_err(|_| EthRpcError::ConversionError)?;
-        let gas_limit: u64 = current_block.gas_limit.try_into().unwrap_or(u64::MAX);
+        let base_fee: u128 = latest_evm_block
+            .base_fee_per_gas
+            .try_into()
+            .map_err(|_| EthRpcError::ConversionError)?;
+        let gas_limit: u64 = latest_evm_block.gas_limit.try_into().unwrap_or(u64::MAX);
         // pallet-revive should currently support all opcodes in PRAGUE.
         let hard_fork: &str = SpecId::PRAGUE.into();
 
         Ok(NodeInfo {
             current_block_number,
             current_block_timestamp,
-            current_block_hash: B256::from_slice(best_hash.as_ref()),
+            current_block_hash: B256::from_slice(latest_evm_block.hash.as_ref()),
             hard_fork: hard_fork.to_string(),
             // pallet-revive does not support tips
             transaction_order: "fifo".to_string(),
@@ -974,18 +981,16 @@ impl ApiServer {
         node_info!("anvil_metadata");
 
         let best_hash = self.latest_block();
-        let Some(latest_block) =
-            self.get_block_by_hash(B256::from_slice(best_hash.as_ref()), false).await?
-        else {
+        let Some(latest_evm_block) = self.get_block_by_substrate_hash(best_hash).await? else {
             return Err(Error::InternalError("Latest block not found".to_string()));
         };
         let latest_block_number: u64 =
-            latest_block.number.try_into().map_err(|_| EthRpcError::ConversionError)?;
+            latest_evm_block.number.try_into().map_err(|_| EthRpcError::ConversionError)?;
 
         Ok(AnvilMetadata {
             client_version: CLIENT_VERSION.to_string(),
             chain_id: self.chain_id(best_hash),
-            latest_block_hash: B256::from_slice(best_hash.as_ref()),
+            latest_block_hash: B256::from_slice(latest_evm_block.hash.as_ref()),
             latest_block_number,
             instance_id: self.instance_id,
             // Forking is not supported yet in anvil-polkadot
@@ -1472,12 +1477,18 @@ impl ApiServer {
         Ok(())
     }
 
+    // This function translates a block ethereum hash to a substrate hash if needed.
     async fn maybe_get_block_hash_for_tag(
         &self,
         block_id: Option<BlockId>,
     ) -> Result<Option<H256>> {
         match ReviveBlockId::from(block_id).inner() {
-            BlockNumberOrTagOrHash::BlockHash(hash) => Ok(Some(hash)),
+            BlockNumberOrTagOrHash::BlockHash(hash) => {
+                // Translate the ethereum hash to a substrate hash.
+                Ok(Some(self.eth_rpc_client.resolve_substrate_hash(&hash).await.ok_or(
+                    Error::ReviveRpc(EthRpcError::ClientError(ClientError::EthereumBlockNotFound)),
+                )?))
+            }
             BlockNumberOrTagOrHash::BlockNumber(block_number) => {
                 let n = block_number.try_into().map_err(|_| {
                     Error::InvalidParams("Block number conversion failed".to_string())
@@ -1495,6 +1506,7 @@ impl ApiServer {
         }
     }
 
+    /// Returns the substrate block hash for a given block id.
     async fn get_block_hash_for_tag(&self, block_id: Option<BlockId>) -> Result<H256> {
         self.maybe_get_block_hash_for_tag(block_id)
             .await?
@@ -1516,6 +1528,19 @@ impl ApiServer {
         self.backend.blockchain().info().best_hash
     }
 
+    /// Returns the EVM block for a given substrate block hash.
+    async fn get_block_by_substrate_hash(&self, block_hash: H256) -> Result<Option<Block>> {
+        let Some(substrate_block) = self.eth_rpc_client.block_by_hash(&block_hash).await? else {
+            return Ok(None);
+        };
+        let Some(evm_block) = self.eth_rpc_client.evm_block(substrate_block, false).await else {
+            return Err(Error::InternalError(
+                "EVM block not found for substrate block".to_string(),
+            ));
+        };
+        Ok(Some(evm_block))
+    }
+
     fn set_frame_system_balance(
         &self,
         latest_block: H256,
@@ -1958,6 +1983,9 @@ async fn create_revive_rpc_client(
         EthRpcClient::new(api, rpc_client, rpc, block_provider, receipt_provider)
             .await
             .map_err(Error::from)?;
+    // Genesis block is not imported via block import notifications, so we need to subscribe and
+    // cache it manually.
+    let _ = eth_rpc_client.subscribe_and_cache_blocks(1).await;
 
     // Capacity is chosen using random.org
     eth_rpc_client.set_block_notifier(Some(tokio::sync::broadcast::channel::<H256>(50).0));

crates/anvil-polkadot/src/api_server/trace_helpers.rs

@@ -11,8 +11,8 @@ use polkadot_sdk::pallet_revive::evm::{
 };
 
 /// Builds a Parity block trace from a vector of TransactionTrace objects returned by the
-/// debug_traceBlockByNumber endpoint of pallet revive and a Block object recovered from pallet
-/// revive. The block must be "hydrated" with all the transactions details.
+/// debug_traceBlockByNumber endpoint of pallet revive and a Substrate Block object recovered from
+/// pallet revive. The block must be "hydrated" with all the transactions details.
 /// This is used to build the output for Parity client's RPC method `trace_block`.
 pub fn parity_block_trace_builder(
     traces: Vec<ReviveTransactionTrace>,

crates/anvil-polkadot/tests/it/mining.rs

@@ -151,7 +151,7 @@ async fn test_interval_mining() {
     assert_with_tolerance(
         after_mining.duration_since(before_mining).unwrap().as_millis(),
         3000,
-        500,
+        600,
         "Interval between the blocks is outside of the desired range.",
     );
     let hash3 = node.block_hash_by_number(3).await.unwrap();

crates/anvil-polkadot/tests/it/revert.rs

@@ -557,7 +557,7 @@ async fn test_timestmap_in_contract_after_revert() {
     let timestamp = multicall_get_timestamp(&mut node, alith_addr, contract_address).await;
     assert_eq!(timestamp, U256::from(first_timestamp.saturating_div(1000)));
 
-    let second_timestamp = first_timestamp.saturating_add(3000);
+    let second_timestamp = first_timestamp.saturating_add(3500);
     assert_with_tolerance(
         unwrap_response::<u64>(
             node.eth_rpc(EthRequest::EvmSetTime(U256::from(second_timestamp.saturating_div(1000))))

crates/anvil-polkadot/tests/it/standard_rpc.rs

@@ -81,10 +81,15 @@ async fn test_get_block_by_hash() {
     let tx_hash2 = node.send_transaction(transaction.nonce(2)).await.unwrap();
     unwrap_response::<()>(node.eth_rpc(EthRequest::Mine(None, None)).await.unwrap()).unwrap();
 
-    let hash1 = node.block_hash_by_number(1).await.unwrap();
-    let hash2 = node.block_hash_by_number(2).await.unwrap();
+    let hash0 = node.eth_block_hash_by_number(0).await.unwrap();
+    let hash1 = node.eth_block_hash_by_number(1).await.unwrap();
+    let hash2 = node.eth_block_hash_by_number(2).await.unwrap();
+    let block0 = node.get_block_by_hash(hash0).await;
     let block1 = node.get_block_by_hash(hash1).await;
     let block2 = node.get_block_by_hash(hash2).await;
+    assert_eq!(block0.hash, hash0);
+    assert_eq!(block1.hash, hash1);
+    assert_eq!(block2.hash, hash2);
     assert!(is_transaction_in_block(&block1.transactions, tx_hash0));
     assert!(is_transaction_in_block(&block1.transactions, tx_hash1));
     assert!(is_transaction_in_block(&block2.transactions, tx_hash2));
@@ -902,7 +907,7 @@ async fn test_anvil_node_info() {
     assert_eq!(node_info.fork_config.fork_block_number, None);
     assert_eq!(node_info.fork_config.fork_retry_backoff, None);
 
-    let genesis_block_hash = node.block_hash_by_number(0).await.unwrap();
+    let genesis_block_hash = node.eth_block_hash_by_number(0).await.unwrap();
     assert_eq!(node_info.current_block_hash, B256::from_slice(genesis_block_hash.as_ref()));
     let block = node.get_block_by_hash(genesis_block_hash).await;
     assert_eq!(block.gas_limit, node_info.environment.gas_limit.into());
@@ -946,7 +951,7 @@ async fn test_anvil_metadata() {
     assert!(metadata.snapshots.is_empty());
 
     // Get current block hash for comparison
-    let block_hash = node.block_hash_by_number(0).await.unwrap();
+    let block_hash = node.eth_block_hash_by_number(0).await.unwrap();
     assert_eq!(metadata.latest_block_hash, B256::from_slice(block_hash.as_ref()));
 
     // Create a snapshot and verify it appears in metadata

crates/anvil-polkadot/tests/it/utils.rs

@@ -268,6 +268,11 @@ impl TestNode {
         .unwrap()
     }
 
+    /// Retrieves a block allowing both ethereum and substrate hashes.
+    ///
+    /// This relies on the `GetBlockByHash` anvil RPC call, which is based on pallet revive
+    /// `get_block_by_hash` function. As a consequence, the block is first retrieved using the
+    /// input hash as an ethereum hash, and then as a substrate hash if not found.
     pub async fn get_block_by_hash(&mut self, hash: H256) -> Block {
         unwrap_response::<Block>(
             self.eth_rpc(EthRequest::EthGetBlockByHash(hash.as_fixed_bytes().into(), false))