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

@@ -523,6 +523,11 @@ impl Backend {
         }
     }
 
+    /// Returns whether the backend has any forks
+    pub fn has_forks(&self) -> bool {
+        self.inner.has_forks()
+    }
+
     /// Returns all snapshots created in this backend
     pub fn snapshots(&self) -> &Snapshots<BackendSnapshot<BackendDatabaseSnapshot>> {
         &self.inner.snapshots
@@ -1540,7 +1545,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
@@ -1599,6 +1604,19 @@ impl BackendInner {
         self.ensure_fork_index(self.ensure_fork_id(id)?)
     }
 
+    /// Returns whether there are any forks
+    pub fn has_forks(&self) -> bool {
+        if self.launched_with_fork.is_some() {
+            return true;
+        }
+
+        if !self.created_forks.is_empty() {
+            return true;
+        }
+
+        self.forks.iter().any(|fork| fork.is_some())
+    }
+
     /// Returns the underlying fork mapped to the index
     #[track_caller]
     fn get_fork(&self, idx: ForkLookupIndex) -> &Fork {

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/error.rs

@@ -4,7 +4,7 @@ use alloy_json_abi::Function;
 use alloy_primitives::{Address, Bytes, Log};
 use eyre::Result;
 use foundry_common::contracts::{ContractsByAddress, ContractsByArtifact};
-use foundry_evm_core::{constants::CALLER, decode::RevertDecoder};
+use foundry_evm_core::{constants::CALLER, decode::RevertDecoder, fork::Context};
 use foundry_evm_fuzz::{
     invariant::FuzzRunIdentifiedContracts, BaseCounterExample, CounterExample, FuzzedCases, Reason,
 };
@@ -153,6 +153,7 @@ impl FailedInvariantCaseData {
         mut ided_contracts: ContractsByAddress,
         logs: &mut Vec<Log>,
         traces: &mut Traces,
+        contexts: &mut Vec<Context>,
     ) -> Result<Option<CounterExample>> {
         let mut counterexample_sequence = vec![];
         let mut calls = match self.test_error {
@@ -179,6 +180,7 @@ impl FailedInvariantCaseData {
 
             logs.extend(call_result.logs);
             traces.push((TraceKind::Execution, call_result.traces.clone().unwrap()));
+            contexts.extend(call_result.contexts);
 
             // Identify newly generated contracts, if they exist.
             ided_contracts.extend(load_contracts(
@@ -199,9 +201,10 @@ impl FailedInvariantCaseData {
                 let error_call_result =
                     executor.call_raw(CALLER, self.addr, func.clone(), U256::ZERO)?;
 
+                logs.extend(error_call_result.logs);
                 traces.push((TraceKind::Execution, error_call_result.traces.clone().unwrap()));
+                contexts.extend(error_call_result.contexts);
 
-                logs.extend(error_call_result.logs);
                 if error_call_result.reverted {
                     break
                 }

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

@@ -4,7 +4,7 @@ use alloy_dyn_abi::JsonAbiExt;
 use alloy_json_abi::Function;
 use alloy_primitives::Log;
 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, FuzzRunIdentifiedContracts, InvariantContract};
 use foundry_evm_traces::{load_contracts, TraceKind, Traces};
@@ -75,6 +75,7 @@ pub fn replay_run(
     mut ided_contracts: ContractsByAddress,
     logs: &mut Vec<Log>,
     traces: &mut Traces,
+    contexts: &mut Vec<Context>,
     coverage: &mut Option<HitMaps>,
     func: Function,
     inputs: Vec<BasicTxDetails>,
@@ -91,6 +92,7 @@ pub fn replay_run(
 
         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 {
@@ -114,9 +116,9 @@ pub fn replay_run(
             U256::ZERO,
         )?;
 
-        traces.push((TraceKind::Execution, error_call_result.traces.clone().unwrap()));
-
         logs.extend(error_call_result.logs);
+        traces.push((TraceKind::Execution, error_call_result.traces.clone().unwrap()));
+        contexts.extend(error_call_result.contexts);
     }
     Ok(())
 }

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, contexts, coverage, 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,36 @@
+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> {
+        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;
@@ -40,6 +41,8 @@ pub struct InspectorStackBuilder {
     pub fuzzer: Option<Fuzzer>,
     /// Whether to enable tracing.
     pub trace: Option<bool>,
+    /// Whether to enable context capture.
+    pub context: Option<bool>,
     /// Whether to enable the debugger.
     pub debug: Option<bool>,
     /// Whether logs should be collected.
@@ -151,6 +154,7 @@ impl InspectorStackBuilder {
             cheatcodes,
             fuzzer,
             trace,
+            context,
             debug,
             logs,
             coverage,
@@ -172,6 +176,7 @@ impl InspectorStackBuilder {
         }
         stack.collect_coverage(coverage.unwrap_or(false));
         stack.collect_logs(logs.unwrap_or(true));
+        stack.collect_context(context.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_context(&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/Cargo.toml

@@ -20,7 +20,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",
+] }
 revm = { workspace = true, default-features = false, features = [
     "std",
     "serde",

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> {