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/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",
@@ -43,5 +48,6 @@ parking_lot = "0.12"
 proptest = "1"
 rand.workspace = true
 rayon = "1"
+serde.workspace = true
 thiserror = "1"
 tracing = "0.1"

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

@@ -7,7 +7,7 @@
 // the concrete `Executor` type.
 
 use crate::inspectors::{
- cheatcodes::BroadcastableTransactions, Cheatcodes, InspectorData, InspectorStack,
+ cheatcodes::BroadcastableTransactions, Cheatcodes, Context, InspectorData, InspectorStack,
 };
 use alloy_dyn_abi::{DynSolValue, FunctionExt, JsonAbiExt};
 use alloy_json_abi::Function;
@@ -662,6 +662,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 +698,7 @@ impl Default for RawCallResult {
  logs: Vec::new(),
  labels: HashMap::new(),
  traces: None,
+ contexts: Vec::new(),
  coverage: None,
  debug: None,
  transactions: None,
@@ -810,7 +813,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 +834,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 revm::{
+ interpreter::{CallInputs, CallOutcome},
+ Database, EvmContext, Inspector,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
+/// A context
+pub struct Context {
+ /// The block number of the context.
+ pub block_number: U256,
+}
+
+/// An inspector that collects EVM context during execution.
+#[derive(Clone, Debug, Default)]
+pub struct ContextCollector {
+ /// The collected 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 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::{Context, ContextCollector};
+
 mod debugger;
 pub use debugger::Debugger;
 

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

@@ -1,6 +1,6 @@
 use super::{
- Cheatcodes, CheatsConfig, ChiselState, CoverageCollector, Debugger, Fuzzer, LogCollector,
- StackSnapshotType, TracingInspector, TracingInspectorConfig,
+ context::Context, Cheatcodes, CheatsConfig, ChiselState, ContextCollector, CoverageCollector,
+ Debugger, Fuzzer, LogCollector, StackSnapshotType, TracingInspector, TracingInspectorConfig,
 };
 use alloy_primitives::{Address, Bytes, Log, U256};
 use foundry_evm_core::{
@@ -40,6 +40,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 +153,7 @@ impl InspectorStackBuilder {
  cheatcodes,
  fuzzer,
  trace,
+ context,
  debug,
  logs,
  coverage,
@@ -172,6 +175,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 +253,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 +290,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 +376,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 +416,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 +667,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/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 {