fix(forge): selectively enable Etherscan trace resolving when a test in ran in a forked environment and return block number in trace on a failed test

crates/evm/core/src/backend/mod.rs

@@ -1540,7 +1540,7 @@ pub struct BackendInner {
     /// issued _local_ numeric identifier, that remains constant, even if the underlying fork
     /// backend changes.
     pub issued_local_fork_ids: HashMap<LocalForkId, ForkId>,
-    /// tracks all the created forks
+    /// Tracks all the created forks
     /// Contains the index of the corresponding `ForkDB` in the `forks` vec
     pub created_forks: HashMap<ForkId, ForkLookupIndex>,
     /// Holds all created fork databases

crates/evm/core/src/fork/context.rs

@@ -0,0 +1,9 @@
+use alloy_primitives::U256;
+use serde::{Deserialize, Serialize};
+
+/// An execution context
+#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct Context {
+    /// The block number of the context.
+    pub block_number: U256,
+}

crates/evm/core/src/fork/mod.rs

@@ -10,6 +10,9 @@ pub use init::environment;
 mod cache;
 pub use cache::{BlockchainDb, BlockchainDbMeta, JsonBlockCacheDB, MemDb};
 
+mod context;
+pub use context::Context;
+
 pub mod database;
 
 mod multi;

crates/evm/evm/Cargo.toml

@@ -22,7 +22,12 @@ foundry-evm-traces.workspace = true
 
 alloy-dyn-abi = { workspace = true, features = ["arbitrary", "eip712"] }
 alloy-json-abi.workspace = true
-alloy-primitives = { workspace = true, features = ["serde", "getrandom", "arbitrary", "rlp"] }
+alloy-primitives = { workspace = true, features = [
+    "serde",
+    "getrandom",
+    "arbitrary",
+    "rlp",
+] }
 alloy-sol-types.workspace = true
 revm = { workspace = true, default-features = false, features = [
     "std",

crates/evm/evm/src/executors/fuzz/mod.rs

@@ -150,6 +150,7 @@ impl FuzzedExecutor {
             logs: call.logs,
             labeled_addresses: call.labels,
             traces: last_run_traces,
+            contexts: call.contexts,
             gas_report_traces: traces,
             coverage: coverage.into_inner(),
         };

crates/evm/evm/src/executors/invariant/replay.rs

@@ -4,7 +4,7 @@ use alloy_dyn_abi::JsonAbiExt;
 use alloy_primitives::Log;
 use eyre::Result;
 use foundry_common::{ContractsByAddress, ContractsByArtifact};
-use foundry_evm_core::constants::CALLER;
+use foundry_evm_core::{constants::CALLER, fork::Context};
 use foundry_evm_coverage::HitMaps;
 use foundry_evm_fuzz::{
     invariant::{BasicTxDetails, InvariantContract},
@@ -26,6 +26,7 @@ pub fn replay_run(
     mut ided_contracts: ContractsByAddress,
     logs: &mut Vec<Log>,
     traces: &mut Traces,
+    contexts: &mut Vec<Context>,
     coverage: &mut Option<HitMaps>,
     inputs: Vec<BasicTxDetails>,
 ) -> Result<Option<CounterExample>> {
@@ -40,6 +41,7 @@ pub fn replay_run(
             executor.call_raw_committing(*sender, *addr, bytes.clone(), U256::ZERO)?;
         logs.extend(call_result.logs);
         traces.push((TraceKind::Execution, call_result.traces.clone().unwrap()));
+        contexts.extend(call_result.contexts);
 
         if let Some(new_coverage) = call_result.coverage {
             if let Some(old_coverage) = coverage {
@@ -77,6 +79,7 @@ pub fn replay_run(
         )?;
         traces.push((TraceKind::Execution, error_call_result.traces.clone().unwrap()));
         logs.extend(error_call_result.logs);
+        contexts.extend(error_call_result.contexts);
     }
 
     Ok((!counterexample_sequence.is_empty())
@@ -93,6 +96,7 @@ pub fn replay_error(
     ided_contracts: ContractsByAddress,
     logs: &mut Vec<Log>,
     traces: &mut Traces,
+    contexts: &mut Vec<Context>,
     coverage: &mut Option<HitMaps>,
 ) -> Result<Option<CounterExample>> {
     match failed_case.test_error {
@@ -116,6 +120,7 @@ pub fn replay_error(
                 ided_contracts,
                 logs,
                 traces,
+                contexts,
                 coverage,
                 calls,
             )

crates/evm/evm/src/executors/mod.rs

@@ -20,6 +20,7 @@ use foundry_evm_core::{
     },
     debug::DebugArena,
     decode::RevertDecoder,
+    fork::Context,
     utils::StateChangeset,
 };
 use foundry_evm_coverage::HitMaps;
@@ -662,6 +663,8 @@ pub struct RawCallResult {
     pub labels: HashMap<Address, String>,
     /// The traces of the call
     pub traces: Option<CallTraceArena>,
+    /// The contexts created during the call
+    pub contexts: Vec<Context>,
     /// The coverage info collected during the call
     pub coverage: Option<HitMaps>,
     /// The debug nodes of the call
@@ -696,6 +699,7 @@ impl Default for RawCallResult {
             logs: Vec::new(),
             labels: HashMap::new(),
             traces: None,
+            contexts: Vec::new(),
             coverage: None,
             debug: None,
             transactions: None,
@@ -810,7 +814,7 @@ fn convert_executed_result(
         _ => Bytes::new(),
     };
 
-    let InspectorData { logs, labels, traces, coverage, debug, cheatcodes, chisel_state } =
+    let InspectorData { logs, labels, traces, coverage, contexts, debug, cheatcodes, chisel_state } =
         inspector.collect();
 
     let transactions = match cheatcodes.as_ref() {
@@ -831,6 +835,7 @@ fn convert_executed_result(
         logs,
         labels,
         traces,
+        contexts,
         coverage,
         debug,
         transactions,

crates/evm/evm/src/inspectors/context.rs

@@ -0,0 +1,38 @@
+use alloy_primitives::U256;
+use foundry_evm_core::fork::Context;
+use revm::{
+    interpreter::{CallInputs, CallOutcome},
+    Database, EvmContext, Inspector,
+};
+
+/// An inspector that collects EVM context during execution.
+#[derive(Clone, Debug, Default)]
+pub struct ContextCollector {
+    /// The collected execution contexts.
+    pub contexts: Vec<Context>,
+}
+
+impl<DB: Database> Inspector<DB> for ContextCollector {
+    fn call(&mut self, ecx: &mut EvmContext<DB>, _call: &mut CallInputs) -> Option<CallOutcome> {
+        // Note: in case there are any cheatcodes executed that modify the environment, this will
+        // update the `env` of the `EvmContext` and the block number will be reflect that change.
+        let block_number = ecx.inner.env.block.number;
+
+        // Skip if the block number is at genesis
+        if block_number == U256::from(1) {
+            return None;
+        }
+
+        // Skip if the previous context is the same
+        if let Some(Context { block_number: prev_block_number }) = self.contexts.last() {
+            if *prev_block_number == block_number {
+                return None;
+            }
+        }
+
+        // Push the new context
+        self.contexts.push(Context { block_number });
+
+        None
+    }
+}

crates/evm/evm/src/inspectors/mod.rs

@@ -10,6 +10,9 @@ pub use revm_inspectors::access_list::AccessListInspector;
 mod chisel_state;
 pub use chisel_state::ChiselState;
 
+mod context;
+pub use context::ContextCollector;
+
 mod debugger;
 pub use debugger::Debugger;
 

crates/evm/evm/src/inspectors/stack.rs

@@ -1,11 +1,12 @@
 use super::{
-    Cheatcodes, CheatsConfig, ChiselState, CoverageCollector, Debugger, Fuzzer, LogCollector,
-    StackSnapshotType, TracingInspector, TracingInspectorConfig,
+    Cheatcodes, CheatsConfig, ChiselState, ContextCollector, CoverageCollector, Debugger, Fuzzer,
+    LogCollector, StackSnapshotType, TracingInspector, TracingInspectorConfig,
 };
 use alloy_primitives::{Address, Bytes, Log, U256};
 use foundry_evm_core::{
     backend::{update_state, DatabaseExt},
     debug::DebugArena,
+    fork::Context,
     InspectorExt,
 };
 use foundry_evm_coverage::HitMaps;
@@ -36,12 +37,14 @@ pub struct InspectorStackBuilder {
     pub gas_price: Option<U256>,
     /// The cheatcodes config.
     pub cheatcodes: Option<Arc<CheatsConfig>>,
+    /// Whether contexts should be collected.
+    pub contexts: Option<bool>,
+    /// Whether to enable the debugger.
+    pub debug: Option<bool>,
     /// The fuzzer inspector and its state, if it exists.
     pub fuzzer: Option<Fuzzer>,
     /// Whether to enable tracing.
     pub trace: Option<bool>,
-    /// Whether to enable the debugger.
-    pub debug: Option<bool>,
     /// Whether logs should be collected.
     pub logs: Option<bool>,
     /// Whether coverage info should be collected.
@@ -152,6 +155,7 @@ impl InspectorStackBuilder {
             fuzzer,
             trace,
             debug,
+            contexts,
             logs,
             coverage,
             print,
@@ -172,6 +176,7 @@ impl InspectorStackBuilder {
         }
         stack.collect_coverage(coverage.unwrap_or(false));
         stack.collect_logs(logs.unwrap_or(true));
+        stack.collect_contexts(contexts.unwrap_or(true));
         stack.enable_debugger(debug.unwrap_or(false));
         stack.print(print.unwrap_or(false));
         stack.tracing(trace.unwrap_or(false));
@@ -249,6 +254,7 @@ pub struct InspectorData {
     pub logs: Vec<Log>,
     pub labels: HashMap<Address, String>,
     pub traces: Option<CallTraceArena>,
+    pub contexts: Vec<Context>,
     pub debug: Option<DebugArena>,
     pub coverage: Option<HitMaps>,
     pub cheatcodes: Option<Cheatcodes>,
@@ -285,6 +291,7 @@ pub struct InspectorStack {
     pub debugger: Option<Debugger>,
     pub fuzzer: Option<Fuzzer>,
     pub log_collector: Option<LogCollector>,
+    pub context_collector: Option<ContextCollector>,
     pub printer: Option<CustomPrintTracer>,
     pub tracer: Option<TracingInspector>,
     pub enable_isolation: bool,
@@ -370,6 +377,12 @@ impl InspectorStack {
         self.log_collector = yes.then(Default::default);
     }
 
+    /// Set whether to enable the context collector.
+    #[inline]
+    pub fn collect_contexts(&mut self, yes: bool) {
+        self.context_collector = yes.then(Default::default);
+    }
+
     /// Set whether to enable the trace printer.
     #[inline]
     pub fn print(&mut self, yes: bool) {
@@ -404,6 +417,7 @@ impl InspectorStack {
                 })
                 .unwrap_or_default(),
             traces: self.tracer.map(|tracer| tracer.get_traces().clone()),
+            contexts: self.context_collector.map(|context| context.contexts).unwrap_or_default(),
             debug: self.debugger.map(|debugger| debugger.arena),
             coverage: self.coverage.map(|coverage| coverage.maps),
             cheatcodes: self.cheatcodes,
@@ -654,6 +668,7 @@ impl<DB: DatabaseExt + DatabaseCommit> Inspector<&mut DB> for InspectorStack {
                 &mut self.debugger,
                 &mut self.tracer,
                 &mut self.log_collector,
+                &mut self.context_collector,
                 &mut self.cheatcodes,
             ],
             |inspector| {

crates/evm/fuzz/src/lib.rs

@@ -10,6 +10,7 @@ extern crate tracing;
 use alloy_dyn_abi::{DynSolValue, JsonAbiExt};
 use alloy_primitives::{Address, Bytes, Log};
 use foundry_common::{calc, contracts::ContractsByAddress};
+use foundry_evm_core::fork::Context;
 use foundry_evm_coverage::HitMaps;
 use foundry_evm_traces::CallTraceArena;
 use itertools::Itertools;
@@ -150,6 +151,9 @@ pub struct FuzzTestResult {
     /// `num(fuzz_cases)` traces, one for each run, which is neither helpful nor performant.
     pub traces: Option<CallTraceArena>,
 
+    /// Execution contexts
+    pub contexts: Vec<Context>,
+
     /// Additional traces used for gas report construction.
     /// Those traces should not be displayed.
     pub gas_report_traces: Vec<CallTraceArena>,

crates/evm/traces/src/identifier/etherscan.rs

@@ -35,6 +35,10 @@ pub struct EtherscanIdentifier {
     invalid_api_key: Arc<AtomicBool>,
     pub contracts: BTreeMap<Address, Metadata>,
     pub sources: BTreeMap<u32, String>,
+    // Tracks whether the Etherscan identifier is enabled
+    // Enabled for forking tests
+    // Disabled for local tests
+    pub enabled: bool,
 }
 
 impl EtherscanIdentifier {
@@ -53,9 +57,17 @@ impl EtherscanIdentifier {
             invalid_api_key: Arc::new(AtomicBool::new(false)),
             contracts: BTreeMap::new(),
             sources: BTreeMap::new(),
+            // By default, the Etherscan identifier is enabled to cover edge cases.
+            // It is disabled for local tests and enabled for forked tests on a per test basis.
+            enabled: true,
         }))
     }
 
+    /// Enables or disables the Etherscan identifier.
+    pub fn enable(&mut self, yes: bool) {
+        self.enabled = yes;
+    }
+
     /// Goes over the list of contracts we have pulled from the traces, clones their source from
     /// Etherscan and compiles them locally, for usage in the debugger.
     pub async fn get_compiled_contracts(&self) -> eyre::Result<ContractSources> {

crates/evm/traces/src/identifier/mod.rs

@@ -62,7 +62,9 @@ impl TraceIdentifier for TraceIdentifiers<'_> {
             identities.extend(local.identify_addresses(addresses.clone()));
         }
         if let Some(etherscan) = &mut self.etherscan {
-            identities.extend(etherscan.identify_addresses(addresses));
+            if etherscan.enabled {
+                identities.extend(etherscan.identify_addresses(addresses));
+            }
         }
         identities
     }
@@ -86,6 +88,13 @@ impl<'a> TraceIdentifiers<'a> {
         Ok(self)
     }
 
+    /// Enables or disables the Etherscan identifier.
+    pub fn enable_etherscan(&mut self, yes: bool) {
+        if let Some(etherscan) = &mut self.etherscan {
+            etherscan.enable(yes);
+        }
+    }
+
     /// Returns `true` if there are no set identifiers.
     pub fn is_empty(&self) -> bool {
         self.local.is_none() && self.etherscan.is_none()

crates/forge/bin/cmd/test/mod.rs

@@ -447,6 +447,13 @@ impl TestArgs {
                     .labels
                     .extend(result.labeled_addresses.iter().map(|(k, v)| (*k, v.clone())));
 
+                // Enable Etherscan decoding for forking tests.
+                // Disable Etherscan decoding for local tests to avoid unnecessary API calls
+                // that can slow down execution significantly if rate-limited.
+                if identify_addresses {
+                    identifier.enable_etherscan(result.is_fork());
+                }
+
                 // Identify addresses and decode traces.
                 let mut decoded_traces = Vec::with_capacity(result.traces.len());
                 for (kind, arena) in &result.traces {