feat(anvil): add block context overrides for eth_call and eth_estimateGas

This commit implements block context overrides for eth_call and eth_estimateGas RPC methods,
allowing users to specify block parameters like timestamp, number, difficulty, etc. for call
execution context.

Key changes:
- BlockOverrides added to EthRequest enum variants for eth_call and eth_estimateGas
- Block overrides handling implemented in `anvil::eth::backend::mem::state` as `apply_block_overrides()` function (ported from reth)
- Add new error type EvmOverrideError to group state and block override related errors (due to fork mode)
- State override handling refactored:
  - Rename `apply_cached_db_state_override()` to `apply_state_overrides()`
  - Modify to take mutable `CacheDB` reference instead of creating new instance
  - Consistent pattern for `apply_state_overrides()` and `apply_block_overrides()`

Author: mablr

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

@@ -10,7 +10,7 @@ use alloy_rpc_types::{
         filter::TraceFilter,
         geth::{GethDebugTracingCallOptions, GethDebugTracingOptions},
     },
-    BlockId, BlockNumberOrTag as BlockNumber, Filter, Index,
+    BlockId, BlockNumberOrTag as BlockNumber, BlockOverrides, Filter, Index,
 };
 use alloy_serde::WithOtherFields;
 use foundry_common::serde_helpers::{
@@ -151,6 +151,7 @@ pub enum EthRequest {
         WithOtherFields<TransactionRequest>,
         #[serde(default)] Option<BlockId>,
         #[serde(default)] Option<StateOverride>,
+        #[serde(default)] Option<Box<BlockOverrides>>,
     ),
 
     #[serde(rename = "eth_simulateV1")]
@@ -164,6 +165,7 @@ pub enum EthRequest {
         WithOtherFields<TransactionRequest>,
         #[serde(default)] Option<BlockId>,
         #[serde(default)] Option<StateOverride>,
+        #[serde(default)] Option<Box<BlockOverrides>>,
     ),
 
     #[serde(rename = "eth_getTransactionByHash", with = "sequence")]

crates/anvil/src/eth/api.rs

@@ -1,5 +1,8 @@
 use super::{
-    backend::mem::{state, BlockRequest, State},
+    backend::{
+        db::MaybeFullDatabase,
+        mem::{state, BlockRequest, State},
+    },
     sign::build_typed_transaction,
 };
 use crate::{
@@ -54,7 +57,7 @@ use alloy_rpc_types::{
     },
     request::TransactionRequest,
     simulate::{SimulatePayload, SimulatedBlock},
-    state::StateOverride,
+    state::EvmOverrides,
     trace::{
         filter::TraceFilter,
         geth::{GethDebugTracingCallOptions, GethDebugTracingOptions, GethTrace},
@@ -84,7 +87,7 @@ use foundry_evm::{
     backend::DatabaseError,
     decode::RevertDecoder,
     revm::{
-        db::DatabaseRef,
+        db::{CacheDB, DatabaseRef},
         interpreter::{return_ok, return_revert, InstructionResult},
         primitives::BlockEnv,
     },
@@ -247,18 +250,20 @@ impl EthApi {
             EthRequest::EthSendRawTransaction(tx) => {
                 self.send_raw_transaction(tx).await.to_rpc_result()
             }
-            EthRequest::EthCall(call, block, overrides) => {
-                self.call(call, block, overrides).await.to_rpc_result()
-            }
+            EthRequest::EthCall(call, block, state_override, block_overrides) => self
+                .call(call, block, EvmOverrides::new(state_override, block_overrides))
+                .await
+                .to_rpc_result(),
             EthRequest::EthSimulateV1(simulation, block) => {
                 self.simulate_v1(simulation, block).await.to_rpc_result()
             }
             EthRequest::EthCreateAccessList(call, block) => {
                 self.create_access_list(call, block).await.to_rpc_result()
             }
-            EthRequest::EthEstimateGas(call, block, overrides) => {
-                self.estimate_gas(call, block, overrides).await.to_rpc_result()
-            }
+            EthRequest::EthEstimateGas(call, block, state_override, block_overrides) => self
+                .estimate_gas(call, block, EvmOverrides::new(state_override, block_overrides))
+                .await
+                .to_rpc_result(),
             EthRequest::EthGetRawTransactionByHash(hash) => {
                 self.raw_transaction(hash).await.to_rpc_result()
             }
@@ -969,7 +974,8 @@ impl EthApi {
 
         if request.gas.is_none() {
             // estimate if not provided
-            if let Ok(gas) = self.estimate_gas(request.clone(), None, None).await {
+            if let Ok(gas) = self.estimate_gas(request.clone(), None, EvmOverrides::default()).await
+            {
                 request.gas = Some(gas.to());
             }
         }
@@ -996,7 +1002,8 @@ impl EthApi {
 
         if request.gas.is_none() {
             // estimate if not provided
-            if let Ok(gas) = self.estimate_gas(request.clone(), None, None).await {
+            if let Ok(gas) = self.estimate_gas(request.clone(), None, EvmOverrides::default()).await
+            {
                 request.gas = Some(gas.to());
             }
         }
@@ -1070,16 +1077,16 @@ impl EthApi {
         &self,
         request: WithOtherFields<TransactionRequest>,
         block_number: Option<BlockId>,
-        overrides: Option<StateOverride>,
+        overrides: EvmOverrides,
     ) -> Result<Bytes> {
         node_info!("eth_call");
         let block_request = self.block_request(block_number).await?;
         // check if the number predates the fork, if in fork mode
         if let BlockRequest::Number(number) = block_request {
             if let Some(fork) = self.get_fork() {
                 if fork.predates_fork(number) {
-                    if overrides.is_some() {
-                        return Err(BlockchainError::StateOverrideError(
+                    if overrides.has_state() || overrides.has_block() {
+                        return Err(BlockchainError::EvmOverrideError(
                             "not available on past forked blocks".to_string(),
                         ));
                     }
@@ -1201,7 +1208,7 @@ impl EthApi {
         &self,
         request: WithOtherFields<TransactionRequest>,
         block_number: Option<BlockId>,
-        overrides: Option<StateOverride>,
+        overrides: EvmOverrides,
     ) -> Result<U256> {
         node_info!("eth_estimateGas");
         self.do_estimate_gas(
@@ -2082,7 +2089,9 @@ impl EthApi {
 
                 // Estimate gas
                 if tx_req.gas.is_none() {
-                    if let Ok(gas) = self.estimate_gas(tx_req.clone(), None, None).await {
+                    if let Ok(gas) =
+                        self.estimate_gas(tx_req.clone(), None, EvmOverrides::default()).await
+                    {
                         tx_req.gas = Some(gas.to());
                     }
                 }
@@ -2550,7 +2559,8 @@ impl EthApi {
 
         request.from = Some(from);
 
-        let gas_limit_fut = self.estimate_gas(request.clone(), Some(BlockId::latest()), None);
+        let gas_limit_fut =
+            self.estimate_gas(request.clone(), Some(BlockId::latest()), EvmOverrides::default());
 
         let fees_fut = self.fee_history(
             U256::from(EIP1559_FEE_ESTIMATION_PAST_BLOCKS),
@@ -2651,15 +2661,15 @@ impl EthApi {
         &self,
         request: WithOtherFields<TransactionRequest>,
         block_number: Option<BlockId>,
-        overrides: Option<StateOverride>,
+        overrides: EvmOverrides,
     ) -> Result<u128> {
         let block_request = self.block_request(block_number).await?;
         // check if the number predates the fork, if in fork mode
         if let BlockRequest::Number(number) = block_request {
             if let Some(fork) = self.get_fork() {
                 if fork.predates_fork(number) {
-                    if overrides.is_some() {
-                        return Err(BlockchainError::StateOverrideError(
+                    if overrides.has_state() || overrides.has_block() {
+                        return Err(BlockchainError::EvmOverrideError(
                             "not available on past forked blocks".to_string(),
                         ));
                     }
@@ -2672,14 +2682,18 @@ impl EthApi {
         // <https://github.com/foundry-rs/foundry/issues/6036>
         self.on_blocking_task(|this| async move {
             this.backend
-                .with_database_at(Some(block_request), |mut state, block| {
-                    if let Some(overrides) = overrides {
-                        state = Box::new(state::apply_state_override(
-                            overrides.into_iter().collect(),
-                            state,
-                        )?);
+                .with_database_at(Some(block_request), |state, mut block| {
+                    let mut cache_db = CacheDB::new(state);
+                    if let Some(state_overrides) = overrides.state {
+                        state::apply_state_overrides(
+                            state_overrides.into_iter().collect(),
+                            &mut cache_db,
+                        )?;
+                    }
+                    if let Some(block_overrides) = overrides.block {
+                        state::apply_block_overrides(*block_overrides, &mut cache_db, &mut block);
                     }
-                    this.do_estimate_gas_with_state(request, &state, block)
+                    this.do_estimate_gas_with_state(request, cache_db.as_dyn(), block)
                 })
                 .await?
         })

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

@@ -52,7 +52,7 @@ use alloy_rpc_types::{
     request::TransactionRequest,
     serde_helpers::JsonStorageKey,
     simulate::{SimBlock, SimCallResult, SimulatePayload, SimulatedBlock},
-    state::StateOverride,
+    state::EvmOverrides,
     trace::{
         filter::TraceFilter,
         geth::{
@@ -1359,16 +1359,19 @@ impl Backend {
         request: WithOtherFields<TransactionRequest>,
         fee_details: FeeDetails,
         block_request: Option<BlockRequest>,
-        overrides: Option<StateOverride>,
+        overrides: EvmOverrides,
     ) -> Result<(InstructionResult, Option<Output>, u128, State), BlockchainError> {
-        self.with_database_at(block_request, |state, block| {
+        self.with_database_at(block_request, |state, mut block| {
             let block_number = block.number.to::<u64>();
-            let (exit, out, gas, state) = match overrides {
-                None => self.call_with_state(state.as_dyn(), request, fee_details, block),
-                Some(overrides) => {
-                    let state = state::apply_state_override(overrides.into_iter().collect(), state)?;
-                    self.call_with_state(state.as_dyn(), request, fee_details, block)
-                },
+            let (exit, out, gas, state) = {
+                let mut cache_db = CacheDB::new(state);
+                if let Some(state_overrides) = overrides.state {
+                    state::apply_state_overrides(state_overrides.into_iter().collect(), &mut cache_db)?;
+                }
+                if let Some(block_overrides) = overrides.block {
+                    state::apply_block_overrides(*block_overrides, &mut cache_db, &mut block);
+                }
+                self.call_with_state(cache_db.as_dyn(), request, fee_details, block)
             }?;
             trace!(target: "backend", "call return {:?} out: {:?} gas {} on block {}", exit, out, gas, block_number);
             Ok((exit, out, gas, state))
@@ -1512,34 +1515,12 @@ impl Backend {
                 let mut log_index = 0;
                 let mut gas_used = 0;
                 let mut transactions = Vec::with_capacity(calls.len());
-                // apply state overrides before executing the transactions
+                // apply state and block overrides before executing the transactions
                 if let Some(state_overrides) = state_overrides {
-                    state::apply_cached_db_state_override(state_overrides, &mut cache_db)?;
+                    state::apply_state_overrides(state_overrides, &mut cache_db)?;
                 }
-
-                // apply block overrides
-                if let Some(overrides) = block_overrides {
-                    if let Some(number) = overrides.number {
-                        block_env.number = number.saturating_to();
-                    }
-                    if let Some(difficulty) = overrides.difficulty {
-                        block_env.difficulty = difficulty;
-                    }
-                    if let Some(time) = overrides.time {
-                        block_env.timestamp = U256::from(time);
-                    }
-                    if let Some(gas_limit) = overrides.gas_limit {
-                        block_env.gas_limit = U256::from(gas_limit);
-                    }
-                    if let Some(coinbase) = overrides.coinbase {
-                        block_env.coinbase = coinbase;
-                    }
-                    if let Some(random) = overrides.random {
-                        block_env.prevrandao = Some(random);
-                    }
-                    if let Some(base_fee) = overrides.base_fee {
-                        block_env.basefee = base_fee.saturating_to();
-                    }
+                if let Some(block_overrides) = block_overrides {
+                    state::apply_block_overrides(block_overrides, &mut cache_db, &mut block_env);
                 }
 
                 // execute all calls in that block
@@ -1740,19 +1721,20 @@ impl Backend {
         block_request: Option<BlockRequest>,
         opts: GethDebugTracingCallOptions,
     ) -> Result<GethTrace, BlockchainError> {
-        let GethDebugTracingCallOptions { tracing_options, block_overrides: _, state_overrides } =
+        let GethDebugTracingCallOptions { tracing_options, block_overrides, state_overrides } =
             opts;
         let GethDebugTracingOptions { config, tracer, tracer_config, .. } = tracing_options;
 
-        self.with_database_at(block_request, |state, block| {
+        self.with_database_at(block_request, |state, mut block| {
             let block_number = block.number;
 
-            let state = if let Some(overrides) = state_overrides {
-                Box::new(state::apply_state_override(overrides, state)?)
-                    as Box<dyn MaybeFullDatabase>
-            } else {
-                state
-            };
+            let mut cache_db = CacheDB::new(state);
+            if let Some(state_overrides) = state_overrides {
+                state::apply_state_overrides(state_overrides, &mut cache_db)?;
+            }
+            if let Some(block_overrides) = block_overrides {
+                state::apply_block_overrides(block_overrides, &mut cache_db, &mut block);
+            }
 
             if let Some(tracer) = tracer {
                 return match tracer {
@@ -1768,7 +1750,7 @@ impl Backend {
 
                             let env = self.build_call_env(request, fee_details, block);
                             let mut evm = self.new_evm_with_inspector_ref(
-                                state.as_dyn(),
+                                cache_db.as_dyn(),
                                 env,
                                 &mut inspector,
                             );
@@ -1803,7 +1785,7 @@ impl Backend {
                 .with_tracing_config(TracingInspectorConfig::from_geth_config(&config));
 
             let env = self.build_call_env(request, fee_details, block);
-            let mut evm = self.new_evm_with_inspector_ref(state.as_dyn(), env, &mut inspector);
+            let mut evm = self.new_evm_with_inspector_ref(cache_db.as_dyn(), env, &mut inspector);
             let ResultAndState { result, state: _ } = evm.transact()?;
 
             let (exit_reason, gas_used, out) = match result {