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 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,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/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

@@ -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)?;
         }
@@ -423,7 +425,7 @@ impl TestArgs {
 
             // Process individual test results, printing logs and traces when necessary.
             for (name, result) in tests {
-                shell::println(result.short_result(name))?;
+                shell::println(result.short_success_result(name))?;
 
                 // We only display logs at level 2 and above
                 if verbosity >= 2 {
@@ -456,6 +458,11 @@ impl TestArgs {
                 let mut decoded_traces = Vec::with_capacity(result.traces.len());
                 for (kind, arena) in &result.traces {
                     if identify_addresses {
+                        // 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.
+                        identifier.enable_etherscan(result.is_fork());
+
                         decoder.identify(arena, &mut identifier);
                     }
 

crates/forge/src/result.rs

@@ -169,7 +169,7 @@ impl TestOutcome {
             let term = if failed > 1 { "tests" } else { "test" };
             shell::println(format!("Encountered {failed} failing {term} in {suite_name}"))?;
             for (name, result) in suite.failures() {
-                shell::println(result.short_result(name))?;
+                shell::println(result.short_failure_result(name))?;
             }
             shell::println("")?;
         }
@@ -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,15 +432,65 @@ impl TestResult {
         Self { status: TestStatus::Failure, reason: Some(reason), ..Default::default() }
     }
 
+    /// Returns `true` if this is the result of a fork 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 { .. })
     }
 
-    /// Formats the test result into a string (for printing).
-    pub fn short_result(&self, name: &str) -> String {
+    /// Formats a successful test result into a string (for printing).
+    pub fn short_success_result(&self, name: &str) -> String {
         format!("{self} {name} {}", self.kind.report())
     }
+
+    /// Formats a failed test result into a string (for printing).
+    pub fn short_failure_result(&self, name: &str) -> String {
+        format!("{self} {name} {}{}", self.environment.report(), self.kind.report())
+    }
+}
+
+/// Various types of tests
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum TestKind {
+    /// A standard test that consists of calling the defined solidity function
+    ///
+    /// Holds the consumed gas
+    Standard(u64),
+    /// A solidity fuzz test, that stores all test cases
+    Fuzz {
+        /// we keep this for the debugger
+        first_case: FuzzCase,
+        runs: usize,
+        mean_gas: u64,
+        median_gas: u64,
+    },
+    /// A solidity invariant test, that stores all test cases
+    Invariant { runs: usize, calls: usize, reverts: usize },
+}
+
+impl Default for TestKind {
+    fn default() -> Self {
+        Self::Standard(0)
+    }
+}
+
+impl TestKind {
+    /// The gas consumed by this test
+    pub fn report(&self) -> TestKindReport {
+        match self {
+            TestKind::Standard(gas) => TestKindReport::Standard { gas: *gas },
+            TestKind::Fuzz { runs, mean_gas, median_gas, .. } => {
+                TestKindReport::Fuzz { runs: *runs, mean_gas: *mean_gas, median_gas: *median_gas }
+            }
+            TestKind::Invariant { runs, calls, reverts } => {
+                TestKindReport::Invariant { runs: *runs, calls: *calls, reverts: *reverts }
+            }
+        }
+    }
 }
 
 /// Data report by a test.
@@ -472,42 +530,50 @@ impl TestKindReport {
     }
 }
 
-/// Various types of tests
+/// Various types of test environments
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum TestKind {
-    /// A standard test that consists of calling the defined solidity function
-    ///
-    /// Holds the consumed gas
-    Standard(u64),
-    /// A solidity fuzz test, that stores all test cases
-    Fuzz {
-        /// we keep this for the debugger
-        first_case: FuzzCase,
-        runs: usize,
-        mean_gas: u64,
-        median_gas: u64,
+pub enum TestEnvironment {
+    /// A standard test environment
+    Standard,
+    /// A forked test environment
+    Fork {
+        /// The block number at which the test was executed
+        block_number: u64,
     },
-    /// A solidity invariant test, that stores all test cases
-    Invariant { runs: usize, calls: usize, reverts: usize },
 }
 
-impl Default for TestKind {
+impl Default for TestEnvironment {
     fn default() -> Self {
-        Self::Standard(0)
+        Self::Standard
     }
 }
 
-impl TestKind {
-    /// The gas consumed by this test
-    pub fn report(&self) -> TestKindReport {
+impl TestEnvironment {
+    // The environment in which the test was run
+    pub fn report(&self) -> TestEnvironmentReport {
         match self {
-            TestKind::Standard(gas) => TestKindReport::Standard { gas: *gas },
-            TestKind::Fuzz { runs, mean_gas, median_gas, .. } => {
-                TestKindReport::Fuzz { runs: *runs, mean_gas: *mean_gas, median_gas: *median_gas }
+            TestEnvironment::Standard => TestEnvironmentReport::Standard,
+            TestEnvironment::Fork { block_number } => {
+                TestEnvironmentReport::Fork { block_number: *block_number }
             }
-            TestKind::Invariant { runs, calls, reverts } => {
-                TestKindReport::Invariant { runs: *runs, calls: *calls, reverts: *reverts }
+        }
+    }
+}
+
+/// Environment report by a test.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum TestEnvironmentReport {
+    Standard,
+    Fork { block_number: u64 },
+}
+
+impl fmt::Display for TestEnvironmentReport {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            TestEnvironmentReport::Fork { block_number } => {
+                write!(f, "(block: {block_number}) ")
             }
+            _ => Ok(()),
         }
     }
 }