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

@@ -522,6 +522,11 @@ impl Backend {
  }
  }
 
+ /// Returns whether the backend has any active 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
@@ -1539,7 +1544,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
@@ -1598,6 +1603,15 @@ impl BackendInner {
  self.ensure_fork_index(self.ensure_fork_id(id)?)
  }
 
+ /// Returns whether there are any active forks
+ pub fn has_forks(&self) -> bool {
+ 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/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,20 @@ impl EtherscanIdentifier {
  invalid_api_key: Arc::new(AtomicBool::new(false)),
  contracts: BTreeMap::new(),
  sources: BTreeMap::new(),
+ enabled: true,
  }))
  }
 
+ /// Enables the Etherscan identifier.
+ pub fn enable(&mut self) {
+ self.enabled = true;
+ }
+
+ /// Disables the Etherscan identifier.
+ pub fn disable(&mut self) {
+ self.enabled = false;
+ }
+
  /// 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,20 @@ impl<'a> TraceIdentifiers<'a> {
  Ok(self)
  }
 
+ /// Enables the Etherscan identifier.
+ pub fn enable_etherscan(&mut self) {
+ if let Some(etherscan) = &mut self.etherscan {
+ etherscan.enable();
+ }
+ }
+
+ /// Disables the Etherscan identifier.
+ pub fn disable_etherscan(&mut self) {
+ if let Some(etherscan) = &mut self.etherscan {
+ etherscan.disable();
+ }
+ }
+
  /// 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

@@ -373,6 +373,8 @@ impl TestArgs {
  let mut identifier = TraceIdentifiers::new().with_local(&known_contracts);
 
  // Avoid using etherscan for gas report as we decode more traces and this will be expensive.
+ // Because users can enable forking through cheat codes, we cannot simply disable etherscan
+ // for non-forking tests here.
  if !self.gas_report {
  identifier = identifier.with_etherscan(&config, remote_chain_id)?;
  }
@@ -456,6 +458,15 @@ impl TestArgs {
  let mut decoded_traces = Vec::with_capacity(result.traces.len());
  for (kind, arena) in &result.traces {
  if identify_addresses {
+ if result.is_fork() {
+ // Enable Etherscan decoding for forking tests.
+ identifier.enable_etherscan();
+ } else {
+ // Disable Etherscan decoding for local tests to avoid unnecessary API
+ // calls that can slow down execution significantly if rate-limited.
+ identifier.disable_etherscan();
+ }
+
  decoder.identify(arena, &mut identifier);
  }
 

crates/forge/src/result.rs

@@ -248,6 +248,11 @@ impl SuiteResult {
  self.test_results.is_empty()
  }
 
+ /// Whether this test suite has any forked tests.
+ pub fn has_fork(&self) -> bool {
+ self.test_results.values().any(|result| result.is_fork())
+ }
+
  /// The number of tests in this test suite.
  pub fn len(&self) -> usize {
  self.test_results.len()
@@ -359,9 +364,12 @@ pub struct TestResult {
  /// The decoded DSTest logging events and Hardhat's `console.log` from [logs](Self::logs).
  pub decoded_logs: Vec<String>,
 
- /// What kind of test this was
+ /// What kind of test this was.
  pub kind: TestKind,
 
+ /// What kind of environment this test was run in.
+ pub environment: TestEnvironment,
+
  /// Traces
  #[serde(skip)]
  pub traces: Traces,
@@ -424,6 +432,11 @@ impl TestResult {
  Self { status: TestStatus::Failure, reason: Some(reason), ..Default::default() }
  }
 
+ /// Returns `true` if this is the result of a forked test
+ pub fn is_fork(&self) -> bool {
+ matches!(self.environment, TestEnvironment::Fork { .. })
+ }
+
  /// Returns `true` if this is the result of a fuzz test
  pub fn is_fuzz(&self) -> bool {
  matches!(self.kind, TestKind::Fuzz { .. })
@@ -472,6 +485,24 @@ impl TestKindReport {
  }
 }
 
+/// Various types of test environments
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum TestEnvironment {
+ /// A standard test environment
+ Standard,
+ /// A forked test environment
+ Fork {
+ /// The block number at which the test was executed
+ block: u64,
+ },
+}
+
+impl Default for TestEnvironment {
+ fn default() -> Self {
+ Self::Standard
+ }
+}
+
 /// Various types of tests
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum TestKind {

crates/forge/src/runner.rs

@@ -2,7 +2,7 @@
 
 use crate::{
  multi_runner::{is_matching_test, TestContract},
- result::{SuiteResult, TestKind, TestResult, TestSetup, TestStatus},
+ result::{SuiteResult, TestEnvironment, TestKind, TestResult, TestSetup, TestStatus},
  TestFilter, TestOptions,
 };
 use alloy_json_abi::Function;
@@ -235,6 +235,7 @@ impl<'a> ContractRunner<'a> {
  decoded_logs: decode_console_logs(&setup.logs),
  logs: setup.logs,
  kind: TestKind::Standard(0),
+ environment: self.get_environment(),
  traces: setup.traces,
  coverage: setup.coverage,
  labeled_addresses: setup.labeled_addresses,
@@ -393,6 +394,7 @@ impl<'a> ContractRunner<'a> {
  traces,
  labeled_addresses,
  kind: TestKind::Standard(0),
+ environment: self.get_environment(),
  duration: start.elapsed(),
  ..Default::default()
  }
@@ -405,6 +407,7 @@ impl<'a> ContractRunner<'a> {
  traces,
  labeled_addresses,
  kind: TestKind::Standard(0),
+ environment: self.get_environment(),
  duration: start.elapsed(),
  ..Default::default()
  }
@@ -432,6 +435,7 @@ impl<'a> ContractRunner<'a> {
  decoded_logs: decode_console_logs(&logs),
  logs,
  kind: TestKind::Standard(gas.overflowing_sub(stipend).0),
+ environment: self.get_environment(),
  traces,
  coverage,
  labeled_addresses,
@@ -474,6 +478,7 @@ impl<'a> ContractRunner<'a> {
  traces,
  labeled_addresses,
  kind: TestKind::Invariant { runs: 1, calls: 1, reverts: 1 },
+ environment: self.get_environment(),
  coverage,
  duration: start.elapsed(),
  ..Default::default()
@@ -504,6 +509,7 @@ impl<'a> ContractRunner<'a> {
  traces,
  labeled_addresses,
  kind: TestKind::Invariant { runs: 0, calls: 0, reverts: 0 },
+ environment: self.get_environment(),
  duration: start.elapsed(),
  ..Default::default()
  }
@@ -570,6 +576,7 @@ impl<'a> ContractRunner<'a> {
  calls: cases.iter().map(|sequence| sequence.cases().len()).sum(),
  reverts,
  },
+ environment: self.get_environment(),
  coverage,
  traces,
  labeled_addresses: labeled_addresses.clone(),
@@ -626,6 +633,7 @@ impl<'a> ContractRunner<'a> {
  traces,
  labeled_addresses,
  kind: TestKind::Standard(0),
+ environment: self.get_environment(),
  debug,
  breakpoints,
  coverage,
@@ -698,6 +706,7 @@ impl<'a> ContractRunner<'a> {
  decoded_logs: decode_console_logs(&logs),
  logs,
  kind,
+ environment: self.get_environment(),
  traces,
  coverage,
  labeled_addresses,
@@ -707,6 +716,15 @@ impl<'a> ContractRunner<'a> {
  gas_report_traces: result.gas_report_traces.into_iter().map(|t| vec![t]).collect(),
  }
  }
+
+ /// Returns the environment of the test runner
+ fn get_environment(&self) -> TestEnvironment {
+ self.executor
+ .backend
+ .has_forks()
+ .then(|| TestEnvironment::Fork { block: self.executor.env.block.number.to::<u64>() })
+ .unwrap_or(TestEnvironment::Standard)
+ }
 }
 
 /// Utility function to merge coverage options