adapt Base dispatch to upstream ExecutorBuilder refactor

Author: lukasrosario

crates/cast/src/cmd/call.rs

@@ -291,6 +291,7 @@ impl CallArgs {
                     config,
                     evm_opts,
                     auth_preflight,
+                    ExecutorBuilder::<foundry_evm::core::evm::BaseEvmNetwork>::new(),
                 )
                 .await;
         }

crates/cast/src/cmd/run.rs

@@ -221,7 +221,11 @@ impl RunArgs {
         #[cfg(feature = "base")]
         if evm_opts.networks.is_base() {
             return self
-                .run_with_evm::<foundry_evm::core::evm::BaseEvmNetwork>(config, evm_opts)
+                .run_with_evm(
+                    config,
+                    evm_opts,
+                    ExecutorBuilder::<foundry_evm::core::evm::BaseEvmNetwork>::new(),
+                )
                 .await;
         }
 

crates/chisel/src/args.rs

@@ -80,6 +80,7 @@ pub async fn run_command(args: Chisel) -> Result<()> {
             args,
             config,
             evm_opts,
+            ExecutorBuilder::<foundry_evm::core::evm::BaseEvmNetwork>::new(),
             local_networks,
             local_chain_id,
         ))

crates/evm/evm/src/executors/builder.rs

@@ -1,5 +1,7 @@
 use crate::{executors::Executor, inspectors::InspectorStackBuilder};
 use alloy_primitives::Address;
+#[cfg(feature = "base")]
+use foundry_evm_core::evm::BaseEvmNetwork;
 #[cfg(feature = "optimism")]
 use foundry_evm_core::evm::OpEvmNetwork;
 use foundry_evm_core::{
@@ -128,6 +130,15 @@ impl ExecutorBuilder<EthEvmNetwork> {
     }
 }
 
+#[cfg(feature = "base")]
+impl ExecutorBuilder<BaseEvmNetwork> {
+    /// Creates the default Base executor builder.
+    #[inline]
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
 #[cfg(feature = "optimism")]
 impl ExecutorBuilder<OpEvmNetwork> {
     /// Creates the default OP executor builder.

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

@@ -2731,14 +2731,17 @@ impl TestArgs {
             }
             #[cfg(feature = "base")]
             NetworkDispatchKind::Base => {
-                self.build_and_run_tests::<foundry_evm::core::evm::BaseEvmNetwork>(
+                // Boxed to keep this arm's future out of `dispatch_network`'s frame, which the
+                // extra network would otherwise push past `clippy::large_stack_frames`.
+                Box::pin(self.build_and_run_tests::<foundry_evm::core::evm::BaseEvmNetwork>(
                     config,
                     evm_opts,
                     output,
                     filter,
                     execution,
                     resolved_fork,
-                )
+                    ExecutorBuilder::<foundry_evm::core::evm::BaseEvmNetwork>::new(),
+                ))
                 .await
             }
             #[cfg(feature = "monad")]
@@ -2805,7 +2808,11 @@ impl TestArgs {
             #[cfg(feature = "base")]
             NetworkDispatchKind::Base => self
                 .build_fuzz_minimize_runner::<foundry_evm::core::evm::BaseEvmNetwork>(
-                    config, evm_opts, output, options,
+                    config,
+                    evm_opts,
+                    output,
+                    options,
+                    ExecutorBuilder::<foundry_evm::core::evm::BaseEvmNetwork>::new(),
                 )
                 .await
                 .map(|runner| fuzz_minimize_replay(runner, filter)),

crates/forge/src/mutation/runner.rs

@@ -647,6 +647,7 @@ fn compile_and_test(
                 rerun_failures,
                 selected_sources_relative,
                 isolate,
+                ExecutorBuilder::<foundry_evm::core::evm::BaseEvmNetwork>::new(),
             );
         }
         #[cfg(feature = "monad")]

crates/script/src/lib.rs

@@ -427,9 +427,11 @@ impl ScriptArgs {
 
         #[cfg(feature = "base")]
         if evm_opts.networks.is_base() {
-            return Box::pin(
-                self.run_generic_script::<foundry_evm::core::evm::BaseEvmNetwork>(config, evm_opts),
-            )
+            return Box::pin(self.run_generic_script::<foundry_evm::core::evm::BaseEvmNetwork>(
+                config,
+                evm_opts,
+                ExecutorBuilder::<foundry_evm::core::evm::BaseEvmNetwork>::new(),
+            ))
             .await;
         }
 

crates/verify/src/bytecode.rs

@@ -253,55 +253,56 @@ impl VerifyBytecodeArgs {
 
         match network {
             NetworkVariant::Ethereum => {
-                self.run_with_network_and_config::<EthEvmNetwork>(
+                Box::pin(self.run_with_network_and_config::<EthEvmNetwork>(
                     config,
                     endpoint_identity,
                     network_was_inferred,
                     replay_block_transactions::<EthEvmNetwork>,
                     ExecutorBuilder::<EthEvmNetwork>::new(),
-                )
+                ))
                 .await
             }
             #[cfg(feature = "base")]
             NetworkVariant::Base => {
-                self.run_with_network_and_config::<BaseEvmNetwork>(
+                Box::pin(self.run_with_network_and_config::<BaseEvmNetwork>(
                     config,
                     endpoint_identity,
                     network_was_inferred,
                     replay_block_transactions::<BaseEvmNetwork>,
-                )
+                    ExecutorBuilder::<BaseEvmNetwork>::new(),
+                ))
                 .await
             }
             #[cfg(feature = "optimism")]
             NetworkVariant::Optimism => {
-                self.run_with_network_and_config::<OpEvmNetwork>(
+                Box::pin(self.run_with_network_and_config::<OpEvmNetwork>(
                     config,
                     endpoint_identity,
                     network_was_inferred,
                     replay_block_transactions::<OpEvmNetwork>,
                     ExecutorBuilder::<OpEvmNetwork>::new(),
-                )
+                ))
                 .await
             }
             NetworkVariant::Tempo => {
-                self.run_with_network_and_config::<TempoEvmNetwork>(
+                Box::pin(self.run_with_network_and_config::<TempoEvmNetwork>(
                     config,
                     endpoint_identity,
                     network_was_inferred,
                     replay_block_transactions::<TempoEvmNetwork>,
                     ExecutorBuilder::<TempoEvmNetwork>::new(),
-                )
+                ))
                 .await
             }
             #[cfg(feature = "monad")]
             NetworkVariant::Monad => {
-                self.run_with_network_and_config::<MonadEvmNetwork>(
+                Box::pin(self.run_with_network_and_config::<MonadEvmNetwork>(
                     config,
                     endpoint_identity,
                     network_was_inferred,
                     replay_monad_block_transactions,
                     ExecutorBuilder::<MonadEvmNetwork>::new(),
-                )
+                ))
                 .await
             }
         }