Merge branch 'master' into dani/inline-config-generic

Author: DaniPopes

Cargo.toml

@@ -32,7 +32,7 @@ resolver = "2"
 version = "1.3.5"
 edition = "2024"
 # Remember to update clippy.toml as well
-rust-version = "1.88"
+rust-version = "1.89"
 authors = ["Foundry Contributors"]
 license = "MIT OR Apache-2.0"
 homepage = "https://getfoundry.sh"

clippy.toml

@@ -1,4 +1,4 @@
-msrv = "1.88"
+msrv = "1.89"
 
 # `bytes::Bytes` is included by default and `alloy_primitives::Bytes` is a wrapper around it,
 # so it is safe to ignore it as well.

crates/anvil/core/src/eth/mod.rs

@@ -264,6 +264,9 @@ pub enum EthRequest {
     #[serde(rename = "eth_syncing", with = "empty_params")]
     EthSyncing(()),
 
+    #[serde(rename = "eth_config", with = "empty_params")]
+    EthConfig(()),
+
     /// geth's `debug_getRawTransaction`  endpoint
     #[serde(rename = "debug_getRawTransaction", with = "sequence")]
     DebugGetRawTransaction(TxHash),

crates/anvil/src/eth/api.rs

@@ -34,7 +34,10 @@ use alloy_consensus::{
     transaction::{Recovered, eip4844::TxEip4844Variant},
 };
 use alloy_dyn_abi::TypedData;
-use alloy_eips::eip2718::Encodable2718;
+use alloy_eips::{
+    eip2718::Encodable2718,
+    eip7910::{EthConfig, EthForkConfig},
+};
 use alloy_evm::overrides::{OverrideBlockHashes, apply_state_overrides};
 use alloy_network::{
     AnyRpcBlock, AnyRpcTransaction, BlockResponse, Ethereum, NetworkWallet, TransactionBuilder,
@@ -313,6 +316,7 @@ impl EthApi {
             EthRequest::EthGetLogs(filter) => self.logs(filter).await.to_rpc_result(),
             EthRequest::EthGetWork(_) => self.work().to_rpc_result(),
             EthRequest::EthSyncing(_) => self.syncing().to_rpc_result(),
+            EthRequest::EthConfig(_) => self.config().to_rpc_result(),
             EthRequest::EthSubmitWork(nonce, pow, digest) => {
                 self.submit_work(nonce, pow, digest).to_rpc_result()
             }
@@ -762,12 +766,31 @@ impl EthApi {
     }
 
     /// Returns the account information including balance, nonce, code and storage
+    ///
+    /// Note: This isn't support by all providers
     pub async fn get_account_info(
         &self,
         address: Address,
         block_number: Option<BlockId>,
     ) -> Result<alloy_rpc_types::eth::AccountInfo> {
         node_info!("eth_getAccountInfo");
+
+        if let Some(fork) = self.get_fork() {
+            // check if the number predates the fork, if in fork mode
+            if let BlockRequest::Number(number) = self.block_request(block_number).await?
+                && fork.predates_fork(number)
+            {
+                // if this predates the fork we need to fetch balance, nonce, code individually
+                // because the provider might not support this endpoint
+                let balance = self.balance(address, Some(number.into()));
+                let code = self.get_code(address, Some(number.into()));
+                let nonce = self.get_transaction_count(address, Some(number.into()));
+                let (balance, code, nonce) = try_join!(balance, code, nonce)?;
+
+                return Ok(alloy_rpc_types::eth::AccountInfo { balance, nonce, code });
+            }
+        }
+
         let account = self.get_account(address, block_number);
         let code = self.get_code(address, block_number);
         let (account, code) = try_join!(account, code)?;
@@ -1472,6 +1495,32 @@ impl EthApi {
         Ok(false)
     }
 
+    /// Returns the current configuration of the chain.
+    /// This is useful for finding out what precompiles and system contracts are available.
+    ///
+    /// Note: the activation timestamp is always 0 as the configuration is set at genesis.
+    /// Note: the `fork_id` is always `0x00000000` as this node does not participate in any forking
+    /// on the network.
+    /// Note: the `next` and `last` fields are always `null` as this node does not participate in
+    /// any forking on the network.
+    ///
+    /// Handler for ETH RPC call: `eth_config`
+    pub fn config(&self) -> Result<EthConfig> {
+        node_info!("eth_config");
+        Ok(EthConfig {
+            current: EthForkConfig {
+                activation_time: 0,
+                blob_schedule: self.backend.blob_params(),
+                chain_id: self.backend.env().read().evm_env.cfg_env.chain_id,
+                fork_id: Bytes::from_static(&[0; 4]),
+                precompiles: self.backend.precompiles(),
+                system_contracts: self.backend.system_contracts(),
+            },
+            next: None,
+            last: None,
+        })
+    }
+
     /// Used for submitting a proof-of-work solution.
     ///
     /// Handler for ETH RPC call: `eth_submitWork`

crates/anvil/src/eth/backend/mem/mod.rs

@@ -27,7 +27,7 @@ use crate::{
         pool::transactions::PoolTransaction,
         sign::build_typed_transaction,
     },
-    evm::celo_precompile,
+    evm::celo_precompile::{self, CELO_TRANSFER_ADDRESS},
     inject_precompiles,
     mem::{
         inspector::AnvilInspector,
@@ -41,7 +41,10 @@ use alloy_consensus::{
     proofs::{calculate_receipt_root, calculate_transaction_root},
     transaction::Recovered,
 };
-use alloy_eips::{eip1559::BaseFeeParams, eip4844::kzg_to_versioned_hash, eip7840::BlobParams};
+use alloy_eips::{
+    eip1559::BaseFeeParams, eip4844::kzg_to_versioned_hash, eip7840::BlobParams,
+    eip7910::SystemContract,
+};
 use alloy_evm::{
     Database, Evm,
     eth::EthEvmContext,
@@ -115,7 +118,11 @@ use revm::{
     },
     database::{CacheDB, WrapDatabaseRef},
     interpreter::InstructionResult,
-    precompile::secp256r1::{P256VERIFY, P256VERIFY_BASE_GAS_FEE},
+    precompile::{
+        PrecompileId, PrecompileSpecId, Precompiles,
+        secp256r1::{P256VERIFY, P256VERIFY_ADDRESS, P256VERIFY_BASE_GAS_FEE},
+        u64_to_address,
+    },
     primitives::{KECCAK_EMPTY, hardfork::SpecId},
     state::AccountInfo,
 };
@@ -843,6 +850,56 @@ impl Backend {
         self.env.read().is_celo
     }
 
+    /// Returns the precompiles for the current spec.
+    pub fn precompiles(&self) -> BTreeMap<String, Address> {
+        let spec_id = self.env.read().evm_env.cfg_env.spec;
+        let precompiles = Precompiles::new(PrecompileSpecId::from_spec_id(spec_id));
+
+        let mut precompiles_map = BTreeMap::<String, Address>::default();
+        for (address, precompile) in precompiles.inner() {
+            precompiles_map.insert(precompile.id().name().to_string(), *address);
+        }
+
+        if self.odyssey {
+            precompiles_map.insert(
+                PrecompileId::P256Verify.name().to_string(),
+                u64_to_address(P256VERIFY_ADDRESS),
+            );
+        }
+
+        if self.is_celo() {
+            precompiles_map.insert(
+                celo_precompile::PRECOMPILE_ID_CELO_TRANSFER.clone().name().to_string(),
+                CELO_TRANSFER_ADDRESS,
+            );
+        }
+
+        if let Some(factory) = &self.precompile_factory {
+            for (precompile, _) in &factory.precompiles() {
+                precompiles_map.insert(precompile.id().name().to_string(), *precompile.address());
+            }
+        }
+
+        precompiles_map
+    }
+
+    /// Returns the system contracts for the current spec.
+    pub fn system_contracts(&self) -> BTreeMap<SystemContract, Address> {
+        let mut system_contracts = BTreeMap::<SystemContract, Address>::default();
+
+        let spec_id = self.env.read().evm_env.cfg_env.spec;
+
+        if spec_id >= SpecId::CANCUN {
+            system_contracts.extend(SystemContract::cancun());
+        }
+
+        if spec_id >= SpecId::PRAGUE {
+            system_contracts.extend(SystemContract::prague(None));
+        }
+
+        system_contracts
+    }
+
     /// Returns [`BlobParams`] corresponding to the current spec.
     pub fn blob_params(&self) -> BlobParams {
         let spec_id = self.env.read().evm_env.cfg_env.spec;

crates/anvil/src/evm/celo_precompile.rs

@@ -11,18 +11,25 @@
 //! - to address (32 bytes, left-padded)
 //! - value (32 bytes, big-endian U256)
 
+use std::borrow::Cow;
+
 use alloy_evm::precompiles::{DynPrecompile, PrecompileInput};
 use alloy_primitives::{Address, U256, address};
 use revm::precompile::{PrecompileError, PrecompileId, PrecompileOutput, PrecompileResult};
 
+/// Address of the Celo transfer precompile.
 pub const CELO_TRANSFER_ADDRESS: Address = address!("0x00000000000000000000000000000000000000fd");
 
-/// Gas cost for Celo transfer precompile
+/// ID for the [Celo transfer precompile](CELO_TRANSFER_ADDRESS).
+pub static PRECOMPILE_ID_CELO_TRANSFER: PrecompileId =
+    PrecompileId::Custom(Cow::Borrowed("celo transfer"));
+
+/// Gas cost for Celo transfer precompile.
 const CELO_TRANSFER_GAS_COST: u64 = 9000;
 
-/// Returns the celo native transfer
+/// Returns the Celo native transfer.
 pub fn precompile() -> DynPrecompile {
-    DynPrecompile::new_stateful(PrecompileId::custom("celo transfer"), celo_transfer_precompile)
+    DynPrecompile::new_stateful(PRECOMPILE_ID_CELO_TRANSFER.clone(), celo_transfer_precompile)
 }
 
 /// Celo transfer precompile implementation.