perf: remove some more unnecessary RPC calls (#12338)

Author: DaniPopes

crates/cast/src/cmd/call.rs

@@ -357,7 +357,7 @@ impl CallArgs {
                 ),
             };
 
-            let contracts_bytecode = fetch_contracts_bytecode_from_trace(&provider, &trace).await?;
+            let contracts_bytecode = fetch_contracts_bytecode_from_trace(&executor, &trace)?;
             handle_traces(
                 trace,
                 &config,

crates/cast/src/cmd/run.rs

@@ -1,11 +1,11 @@
-use crate::debug::handle_traces;
+use crate::{debug::handle_traces, utils::apply_chain_and_block_specific_env_changes};
 use alloy_consensus::Transaction;
 use alloy_network::{AnyNetwork, TransactionResponse};
 use alloy_primitives::{
     Address, Bytes, U256,
-    map::{HashMap, HashSet},
+    map::{AddressSet, HashMap},
 };
-use alloy_provider::{Provider, RootProvider};
+use alloy_provider::Provider;
 use alloy_rpc_types::BlockTransactions;
 use clap::Parser;
 use eyre::{Result, WrapErr};
@@ -25,13 +25,13 @@ use foundry_config::{
 use foundry_evm::{
     Env,
     core::env::AsEnvMut,
-    executors::{EvmError, TracingExecutor},
+    executors::{EvmError, Executor, TracingExecutor},
     opts::EvmOpts,
     traces::{InternalTraceMode, TraceMode, Traces},
     utils::configure_tx_env,
 };
-
-use crate::utils::apply_chain_and_block_specific_env_changes;
+use futures::TryFutureExt;
+use revm::DatabaseRef;
 
 /// CLI arguments for `cast run`.
 #[derive(Clone, Debug, Parser)]
@@ -151,15 +151,16 @@ impl RunArgs {
         let tx_block_number =
             tx.block_number.ok_or_else(|| eyre::eyre!("tx may still be pending: {:?}", tx_hash))?;
 
-        // fetch the block the transaction was mined in
-        let block = provider.get_block(tx_block_number.into()).full().await?;
-
         // we need to fork off the parent block
         config.fork_block_number = Some(tx_block_number - 1);
 
         let create2_deployer = evm_opts.create2_deployer;
-        let (mut env, fork, chain, networks) =
-            TracingExecutor::get_fork_material(&mut config, evm_opts).await?;
+        let (block, (mut env, fork, chain, networks)) = tokio::try_join!(
+            // fetch the block the transaction was mined in
+            provider.get_block(tx_block_number.into()).full().into_future().map_err(Into::into),
+            TracingExecutor::get_fork_material(&mut config, evm_opts)
+        )?;
+
         let mut evm_version = self.evm_version;
 
         env.evm_env.cfg_env.disable_block_gas_limit = self.disable_block_gas_limit;
@@ -303,7 +304,7 @@ impl RunArgs {
             }
         };
 
-        let contracts_bytecode = fetch_contracts_bytecode_from_trace(&provider, &result).await?;
+        let contracts_bytecode = fetch_contracts_bytecode_from_trace(&executor, &result)?;
         handle_traces(
             result,
             &config,
@@ -321,34 +322,32 @@ impl RunArgs {
     }
 }
 
-pub async fn fetch_contracts_bytecode_from_trace(
-    provider: &RootProvider<AnyNetwork>,
+pub fn fetch_contracts_bytecode_from_trace(
+    executor: &Executor,
     result: &TraceResult,
 ) -> Result<HashMap<Address, Bytes>> {
     let mut contracts_bytecode = HashMap::default();
     if let Some(ref traces) = result.traces {
-        let addresses = gather_trace_addresses(traces);
-        let results = futures::future::join_all(addresses.into_iter().map(async |a| {
-            (
-                a,
-                provider.get_code_at(a).await.unwrap_or_else(|e| {
-                    sh_warn!("Failed to fetch code for {a:?}: {e:?}").ok();
-                    Bytes::new()
-                }),
-            )
-        }))
-        .await;
-        for (address, code) in results {
-            if !code.is_empty() {
-                contracts_bytecode.insert(address, code);
+        contracts_bytecode.extend(gather_trace_addresses(traces).filter_map(|addr| {
+            // All relevant bytecodes should already be cached in the executor.
+            let code = executor
+                .backend()
+                .basic_ref(addr)
+                .inspect_err(|e| _ = sh_warn!("Failed to fetch code for {addr}: {e}"))
+                .ok()??
+                .code?
+                .bytes();
+            if code.is_empty() {
+                return None;
             }
-        }
+            Some((addr, code))
+        }));
     }
     Ok(contracts_bytecode)
 }
 
-fn gather_trace_addresses(traces: &Traces) -> HashSet<Address> {
-    let mut addresses = HashSet::default();
+fn gather_trace_addresses(traces: &Traces) -> impl Iterator<Item = Address> {
+    let mut addresses = AddressSet::default();
     for (_, trace) in traces {
         for node in trace.arena.nodes() {
             if !node.trace.address.is_zero() {
@@ -359,7 +358,7 @@ fn gather_trace_addresses(traces: &Traces) -> HashSet<Address> {
             }
         }
     }
-    addresses
+    addresses.into_iter()
 }
 
 impl figment::Provider for RunArgs {

crates/cast/src/debug.rs

@@ -17,7 +17,7 @@ use foundry_evm::traces::{
 pub(crate) async fn handle_traces(
     mut result: TraceResult,
     config: &Config,
-    chain: Option<Chain>,
+    chain: Chain,
     contracts_bytecode: &HashMap<Address, Bytes>,
     labels: Vec<String>,
     with_local_artifacts: bool,
@@ -56,7 +56,7 @@ pub(crate) async fn handle_traces(
         .with_labels(labels.chain(config_labels))
         .with_signature_identifier(SignaturesIdentifier::from_config(config)?)
         .with_label_disabled(disable_label);
-    let mut identifier = TraceIdentifiers::new().with_external(config, chain)?;
+    let mut identifier = TraceIdentifiers::new().with_external(config, Some(chain))?;
     if let Some(contracts) = &known_contracts {
         builder = builder.with_known_contracts(contracts);
         identifier = identifier.with_local_and_bytecodes(contracts, contracts_bytecode);

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

@@ -21,6 +21,17 @@ pub async fn environment<N: Network, P: Provider<N>>(
     enable_tx_gas_limit: bool,
     configs: NetworkConfigs,
 ) -> eyre::Result<(Env, N::BlockResponse)> {
+    trace!(
+        %memory_limit,
+        ?override_gas_price,
+        ?override_chain_id,
+        ?pin_block,
+        %origin,
+        %disable_block_gas_limit,
+        %enable_tx_gas_limit,
+        ?configs,
+        "creating fork environment"
+    );
     let bn = match pin_block {
         Some(bn) => BlockNumberOrTag::Number(bn),
         None => BlockNumberOrTag::Latest,

crates/evm/evm/src/executors/trace.rs

@@ -21,14 +21,14 @@ pub struct TracingExecutor {
 impl TracingExecutor {
     pub fn new(
         env: Env,
-        fork: Option<CreateFork>,
+        fork: CreateFork,
         version: Option<EvmVersion>,
         trace_mode: TraceMode,
         networks: NetworkConfigs,
         create2_deployer: Address,
         state_overrides: Option<StateOverride>,
     ) -> eyre::Result<Self> {
-        let db = Backend::spawn(fork)?;
+        let db = Backend::spawn(Some(fork))?;
         // configures a bare version of the evm executor: no cheatcode inspector is enabled,
         // tracing will be enabled only for the targeted transaction
         let mut executor = ExecutorBuilder::new()
@@ -79,17 +79,18 @@ impl TracingExecutor {
     pub async fn get_fork_material(
         config: &mut Config,
         mut evm_opts: EvmOpts,
-    ) -> eyre::Result<(Env, Option<CreateFork>, Option<Chain>, NetworkConfigs)> {
+    ) -> eyre::Result<(Env, CreateFork, Chain, NetworkConfigs)> {
         evm_opts.fork_url = Some(config.get_rpc_url_or_localhost_http()?.into_owned());
         evm_opts.fork_block_number = config.fork_block_number;
 
         let env = evm_opts.evm_env().await?;
 
-        let fork = evm_opts.get_fork(config, env.clone());
+        let fork = evm_opts.get_fork(config, env.clone()).unwrap();
         let networks = evm_opts.networks.with_chain_id(env.evm_env.cfg_env.chain_id);
         config.labels.extend(networks.precompiles_label());
 
-        Ok((env, fork, evm_opts.get_remote_chain_id().await, networks))
+        let chain = env.tx.chain_id.unwrap().into();
+        Ok((env, fork, chain, networks))
     }
 }
 

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

@@ -509,7 +509,8 @@ impl TestArgs {
             return Ok(TestOutcome::new(Some(runner), results, self.allow_failure));
         }
 
-        let remote_chain_id = runner.evm_opts.get_remote_chain_id().await;
+        let remote_chain =
+            if runner.fork.is_some() { runner.env.tx.chain_id.map(Into::into) } else { None };
         let known_contracts = runner.known_contracts.clone();
 
         let libraries = runner.libraries.clone();
@@ -529,7 +530,7 @@ impl TestArgs {
         // Avoid using external identifiers for gas report as we decode more traces and this will be
         // expensive.
         if !self.gas_report {
-            identifier = identifier.with_external(&config, remote_chain_id)?;
+            identifier = identifier.with_external(&config, remote_chain)?;
         }
 
         // Build the trace decoder.