Implementanvil_nodeInfo and anvil_metadata (paritytech#364)

* draft implementation of `anvil_nodeInfo` and `anvil_metadata`

* clippy

* import nit

* Implement thread-safe snapshot getter

* fix + add tests

* CR changes

Author: re-gius

Cargo.lock

@@ -144,6 +144,7 @@ subxt-signer = "0.43.0"
 tokio-stream = "0.1.17"
 jsonrpsee = "0.24.9"
 sqlx = "0.8.6"
+revm.workspace = true
 
 [dev-dependencies]
 alloy-provider = { workspace = true, features = ["txpool-api"] }

crates/anvil-polkadot/Cargo.toml

@@ -27,7 +27,11 @@ use crate::{
 use alloy_dyn_abi::TypedData;
 use alloy_eips::{BlockId, BlockNumberOrTag};
 use alloy_primitives::{Address, B256, U64, U256};
-use alloy_rpc_types::{Filter, TransactionRequest, anvil::MineOptions, txpool::TxpoolStatus};
+use alloy_rpc_types::{
+    Filter, TransactionRequest,
+    anvil::{Metadata as AnvilMetadata, MineOptions, NodeEnvironment, NodeInfo},
+    txpool::TxpoolStatus,
+};
 use alloy_serde::WithOtherFields;
 use alloy_trie::{EMPTY_ROOT_HASH, KECCAK_EMPTY, TrieAccount};
 use anvil_core::eth::{EthRequest, Params as MineParams};
@@ -52,12 +56,13 @@ use polkadot_sdk::{
     polkadot_sdk_frame::runtime::types_common::OpaqueBlock,
     sc_client_api::HeaderBackend,
     sc_service::{InPoolTransaction, SpawnTaskHandle, TransactionPool},
-    sp_api::{Metadata, ProvideRuntimeApi},
+    sp_api::{Metadata as _, ProvideRuntimeApi},
     sp_arithmetic::Permill,
     sp_blockchain::Info,
     sp_core::{self, Hasher, keccak_256},
     sp_runtime::traits::BlakeTwo256,
 };
+use revm::primitives::hardfork::SpecId;
 use sqlx::sqlite::SqlitePoolOptions;
 use std::{collections::HashSet, sync::Arc, time::Duration};
 use substrate_runtime::{Balance, RuntimeCall, UncheckedExtrinsic};
@@ -84,6 +89,7 @@ pub struct ApiServer {
     snapshot_manager: SnapshotManager,
     impersonation_manager: ImpersonationManager,
     tx_pool: Arc<TransactionPoolHandle>,
+    instance_id: B256,
 }
 
 impl ApiServer {
@@ -122,6 +128,7 @@ impl ApiServer {
             impersonation_manager,
             tx_pool: substrate_service.tx_pool.clone(),
             wallet: DevSigner::new(signers)?,
+            instance_id: B256::random(),
         })
     }
 
@@ -344,6 +351,9 @@ impl ApiServer {
                 node_info!("anvil_dropTransaction");
                 self.anvil_drop_transaction(eth_hash).await.to_rpc_result()
             }
+            // --- Metadata ---
+            EthRequest::NodeInfo(_) => self.anvil_node_info().await.to_rpc_result(),
+            EthRequest::AnvilMetadata(_) => self.anvil_metadata().await.to_rpc_result(),
             _ => Err::<(), _>(Error::RpcUnimplemented).to_rpc_result(),
         };
 
@@ -749,6 +759,69 @@ impl ApiServer {
         Ok(())
     }
 
+    async fn anvil_node_info(&self) -> Result<NodeInfo> {
+        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 {
+            return Err(Error::InternalError("Latest block not found".to_string()));
+        };
+        let current_block_number: u64 =
+            current_block.number.try_into().map_err(|_| EthRpcError::ConversionError)?;
+        let current_block_timestamp: u64 =
+            current_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);
+        // 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()),
+            hard_fork: hard_fork.to_string(),
+            // pallet-revive does not support tips
+            transaction_order: "fifo".to_string(),
+            environment: NodeEnvironment {
+                base_fee,
+                chain_id: self.chain_id(best_hash),
+                gas_limit,
+                gas_price: base_fee,
+            },
+            // Forking is not supported yet in anvil-polkadot
+            fork_config: Default::default(),
+        })
+    }
+
+    async fn anvil_metadata(&self) -> Result<AnvilMetadata> {
+        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 {
+            return Err(Error::InternalError("Latest block not found".to_string()));
+        };
+        let latest_block_number: u64 =
+            latest_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_number,
+            instance_id: self.instance_id,
+            // Forking is not supported yet in anvil-polkadot
+            forked_network: None,
+            snapshots: self.snapshot_manager.list_snapshots(),
+        })
+    }
+
     async fn get_block_transaction_count_by_hash(&self, block_hash: B256) -> Result<Option<U256>> {
         let block_hash = H256::from_slice(block_hash.as_slice());
         Ok(self.eth_rpc_client.receipts_count_per_block(&block_hash).await.map(U256::from))

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

@@ -1,13 +1,14 @@
 use crate::substrate_node::service::{Backend, Client};
-use alloy_primitives::U256;
+use alloy_primitives::{B256, U256};
 use polkadot_sdk::{
     polkadot_sdk_frame::runtime::types_common::OpaqueBlock,
     sc_client_api::Backend as BackendT,
     sp_blockchain::{HeaderBackend, Info, Result},
 };
 use std::{collections::BTreeMap, sync::Arc};
 
-type Snapshot = u64;
+// The snapshot contains the block number and the block hash
+type Snapshot = (u64, B256);
 
 pub struct RevertInfo {
     pub info: Info<OpaqueBlock>,
@@ -32,25 +33,26 @@ impl SnapshotManager {
     pub fn snapshot(&mut self) -> U256 {
         let current_snapshot_id = self.next_snapshot_id;
         self.next_snapshot_id += U256::ONE;
-        let snapshot = self.client.info().best_number.into();
-        self.snapshots.insert(current_snapshot_id, snapshot);
+        let block_number = self.client.info().best_number.into();
+        let block_hash = B256::from_slice(self.client.info().best_hash.as_ref());
+        self.snapshots.insert(current_snapshot_id, (block_number, block_hash));
         current_snapshot_id
     }
 
     /// Revert the chain to the block number represented by the snapshot `id`.
     pub fn revert(&mut self, snapshot_id: U256) -> Result<Option<RevertInfo>> {
         let maybe_snapshot = self.snapshots.remove(&snapshot_id);
-        let Some(snap) = maybe_snapshot else {
+        let Some((snapshot_block_number, _)) = maybe_snapshot else {
             return Ok(None);
         };
 
         let current_best_number: u64 = self.client.info().best_number.into();
-        let number_of_blocks_to_revert = current_best_number - snap;
+        let number_of_blocks_to_revert = current_best_number - snapshot_block_number;
 
         let (reverted, _) =
             self.backend.revert(number_of_blocks_to_revert.try_into().unwrap_or(u32::MAX), true)?;
 
-        self.snapshots.retain(|_, snap_to_remove| *snap_to_remove < snap);
+        self.snapshots.retain(|_, (snap_to_remove, _)| *snap_to_remove < snapshot_block_number);
 
         Ok(Some(RevertInfo { reverted: reverted.into(), info: self.client.info() }))
     }
@@ -61,4 +63,8 @@ impl SnapshotManager {
             self.backend.revert(depth.unwrap_or(1).try_into().unwrap_or(u32::MAX), true)?;
         Ok(RevertInfo { reverted: reverted.into(), info: self.client.info() })
     }
+
+    pub fn list_snapshots(&self) -> BTreeMap<U256, (u64, B256)> {
+        self.snapshots.clone()
+    }
 }

crates/anvil-polkadot/src/substrate_node/snapshot.rs

@@ -8,7 +8,10 @@ use crate::{
     },
 };
 use alloy_primitives::{Address, B256, Bytes, U256, map::HashSet};
-use alloy_rpc_types::{Index, TransactionInput, TransactionRequest};
+use alloy_rpc_types::{
+    Index, TransactionInput, TransactionRequest,
+    anvil::{Metadata as AnvilMetadata, NodeInfo},
+};
 use alloy_serde::WithOtherFields;
 use alloy_sol_types::{SolCall, SolEvent};
 use anvil_core::eth::EthRequest;
@@ -894,3 +897,105 @@ async fn test_coinbase() {
     let coinbase = multicall_get_coinbase(&mut node, alith_addr, contract_address).await;
     assert_eq!(coinbase, new_coinbase);
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_anvil_node_info() {
+    let anvil_node_config = AnvilNodeConfig::test_config();
+    let substrate_node_config = SubstrateNodeConfig::new(&anvil_node_config);
+    let mut node = TestNode::new(anvil_node_config.clone(), substrate_node_config).await.unwrap();
+
+    let node_info =
+        unwrap_response::<NodeInfo>(node.eth_rpc(EthRequest::NodeInfo(())).await.unwrap()).unwrap();
+
+    // Check initial state - should be at genesis block
+    assert_eq!(node_info.current_block_number, 0);
+    assert_eq!(node_info.hard_fork, "Prague".to_string());
+    assert_eq!(node_info.transaction_order, "fifo");
+    assert_eq!(node_info.environment.chain_id, 0x7a69);
+
+    // Verify fork config is empty (forking not supported)
+    assert_eq!(node_info.fork_config.fork_url, None);
+    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();
+    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());
+    assert_eq!(block.base_fee_per_gas, node_info.environment.base_fee.into());
+    assert_eq!(block.base_fee_per_gas, node_info.environment.gas_price.into());
+
+    // Mine some blocks and check that node_info updates
+    unwrap_response::<()>(node.eth_rpc(EthRequest::Mine(Some(U256::from(3)), None)).await.unwrap())
+        .unwrap();
+    tokio::time::sleep(Duration::from_millis(400)).await;
+
+    let node_info_after =
+        unwrap_response::<NodeInfo>(node.eth_rpc(EthRequest::NodeInfo(())).await.unwrap()).unwrap();
+
+    // Block number should have increased
+    assert_eq!(node_info_after.current_block_number, 3);
+
+    // Timestamp should be greater or equal (may have advanced)
+    assert!(node_info_after.current_block_timestamp >= node_info.current_block_timestamp);
+    assert_eq!(node_info_after.environment.chain_id, node_info.environment.chain_id);
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_anvil_metadata() {
+    let anvil_node_config = AnvilNodeConfig::test_config();
+    let substrate_node_config = SubstrateNodeConfig::new(&anvil_node_config);
+    let mut node = TestNode::new(anvil_node_config.clone(), substrate_node_config).await.unwrap();
+
+    let metadata = unwrap_response::<AnvilMetadata>(
+        node.eth_rpc(EthRequest::AnvilMetadata(())).await.unwrap(),
+    )
+    .unwrap();
+
+    assert!(metadata.client_version.contains("anvil-polkadot"));
+    assert_eq!(metadata.latest_block_number, 0);
+    assert_eq!(metadata.chain_id, 0x7a69);
+
+    // Verify forked_network is None (forking not supported)
+    assert_eq!(metadata.forked_network, None);
+
+    // Initial snapshots should be empty
+    assert!(metadata.snapshots.is_empty());
+
+    // Get current block hash for comparison
+    let block_hash = node.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
+    let snapshot_id = U256::from_str_radix(
+        unwrap_response::<String>(node.eth_rpc(EthRequest::EvmSnapshot(())).await.unwrap())
+            .unwrap()
+            .trim_start_matches("0x"),
+        16,
+    )
+    .unwrap();
+
+    let metadata_after_snapshot = unwrap_response::<AnvilMetadata>(
+        node.eth_rpc(EthRequest::AnvilMetadata(())).await.unwrap(),
+    )
+    .unwrap();
+
+    // Should have one snapshot
+    assert_eq!(metadata_after_snapshot.snapshots.len(), 1);
+    assert!(metadata_after_snapshot.snapshots.contains_key(&snapshot_id));
+
+    // Mine some blocks and check that metadata updates
+    unwrap_response::<()>(node.eth_rpc(EthRequest::Mine(Some(U256::from(5)), None)).await.unwrap())
+        .unwrap();
+    tokio::time::sleep(Duration::from_millis(400)).await;
+
+    let metadata_after_mining = unwrap_response::<AnvilMetadata>(
+        node.eth_rpc(EthRequest::AnvilMetadata(())).await.unwrap(),
+    )
+    .unwrap();
+
+    // Block number should have increased
+    assert_eq!(metadata_after_mining.latest_block_number, 5);
+    // Snapshot should still be present
+    assert!(metadata_after_mining.snapshots.contains_key(&snapshot_id));
+}