feat(script): support custom create2 deployer

crates/cast/bin/cmd/call.rs

@@ -170,15 +170,23 @@ impl CallArgs {
                 config.fork_block_number = Some(block_number);
             }
 
+            let create2_deployer = evm_opts.create2_deployer;
             let (mut env, fork, chain, alphanet) =
                 TracingExecutor::get_fork_material(&config, evm_opts).await?;
 
             // modify settings that usually set in eth_call
             env.cfg.disable_block_gas_limit = true;
             env.block.gas_limit = U256::MAX;
 
-            let mut executor =
-                TracingExecutor::new(env, fork, evm_version, debug, decode_internal, alphanet);
+            let mut executor = TracingExecutor::new(
+                env,
+                fork,
+                evm_version,
+                debug,
+                decode_internal,
+                alphanet,
+                create2_deployer,
+            );
 
             let value = tx.value.unwrap_or_default();
             let input = tx.inner.input.into_input().unwrap_or_default();

crates/cast/bin/cmd/run.rs

@@ -134,6 +134,7 @@ impl RunArgs {
         // 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, alphanet) =
             TracingExecutor::get_fork_material(&config, evm_opts).await?;
 
@@ -166,6 +167,7 @@ impl RunArgs {
             self.debug,
             self.decode_internal,
             alphanet,
+            create2_deployer,
         );
         let mut env =
             EnvWithHandlerCfg::new_with_spec_id(Box::new(env.clone()), executor.spec_id());

crates/cheatcodes/src/inspector.rs

@@ -1587,6 +1587,10 @@ impl InspectorExt for Cheatcodes {
             false
         }
     }
+
+    fn create2_deployer(&self) -> Address {
+        self.config.evm_opts.create2_deployer
+    }
 }
 
 impl Cheatcodes {

crates/config/src/lib.rs

@@ -440,6 +440,9 @@ pub struct Config {
     /// CREATE2 salt to use for the library deployment in scripts.
     pub create2_library_salt: B256,
 
+    /// The CREATE2 deployer address to use.
+    pub create2_deployer: Address,
+
     /// Configuration for Vyper compiler
     pub vyper: VyperConfig,
 
@@ -553,6 +556,10 @@ impl Config {
     /// Default salt for create2 library deployments
     pub const DEFAULT_CREATE2_LIBRARY_SALT: FixedBytes<32> = FixedBytes::<32>::ZERO;
 
+    /// Default create2 deployer
+    pub const DEFAULT_CREATE2_DEPLOYER: Address =
+        address!("4e59b44847b379578588920ca78fbf26c0b4956c");
+
     /// Docker image with eof-enabled solc binary
     pub const EOF_SOLC_IMAGE: &'static str = "ghcr.io/paradigmxyz/forge-eof@sha256:46f868ce5264e1190881a3a335d41d7f42d6f26ed20b0c823609c715e38d603f";
 
@@ -2301,6 +2308,7 @@ impl Default for Config {
             labels: Default::default(),
             unchecked_cheatcode_artifacts: false,
             create2_library_salt: Self::DEFAULT_CREATE2_LIBRARY_SALT,
+            create2_deployer: Self::DEFAULT_CREATE2_DEPLOYER,
             skip: vec![],
             dependencies: Default::default(),
             soldeer: Default::default(),

crates/evm/core/src/lib.rs

@@ -5,6 +5,8 @@
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
+use crate::constants::DEFAULT_CREATE2_DEPLOYER;
+use alloy_primitives::Address;
 use auto_impl::auto_impl;
 use backend::DatabaseExt;
 use revm::{inspectors::NoOpInspector, interpreter::CreateInputs, EvmContext, Inspector};
@@ -54,6 +56,11 @@ pub trait InspectorExt: for<'a> Inspector<&'a mut dyn DatabaseExt> {
     fn is_alphanet(&self) -> bool {
         false
     }
+
+    /// Returns the CREATE2 deployer address.
+    fn create2_deployer(&self) -> Address {
+        DEFAULT_CREATE2_DEPLOYER
+    }
 }
 
 impl InspectorExt for NoOpInspector {}

crates/evm/core/src/opts.rs

@@ -1,5 +1,5 @@
 use super::fork::environment;
-use crate::fork::CreateFork;
+use crate::{constants::DEFAULT_CREATE2_DEPLOYER, fork::CreateFork};
 use alloy_primitives::{Address, B256, U256};
 use alloy_provider::{network::AnyRpcBlock, Provider};
 use eyre::WrapErr;
@@ -9,7 +9,7 @@ use revm::primitives::{BlockEnv, CfgEnv, TxEnv};
 use serde::{Deserialize, Deserializer, Serialize};
 use url::Url;
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct EvmOpts {
     /// The EVM environment configuration.
     #[serde(flatten)]
@@ -66,6 +66,34 @@ pub struct EvmOpts {
 
     /// whether to enable Alphanet features.
     pub alphanet: bool,
+
+    /// The CREATE2 deployer's address.
+    pub create2_deployer: Address,
+}
+
+impl Default for EvmOpts {
+    fn default() -> Self {
+        Self {
+            env: Env::default(),
+            fork_url: None,
+            fork_block_number: None,
+            fork_retries: None,
+            fork_retry_backoff: None,
+            compute_units_per_second: None,
+            no_rpc_rate_limit: false,
+            no_storage_caching: false,
+            initial_balance: U256::default(),
+            sender: Address::default(),
+            ffi: false,
+            always_use_create_2_factory: false,
+            verbosity: 0,
+            memory_limit: 0,
+            isolate: false,
+            disable_block_gas_limit: false,
+            alphanet: false,
+            create2_deployer: DEFAULT_CREATE2_DEPLOYER,
+        }
+    }
 }
 
 impl EvmOpts {

crates/evm/core/src/utils.rs

@@ -1,8 +1,5 @@
 pub use crate::ic::*;
-use crate::{
-    backend::DatabaseExt, constants::DEFAULT_CREATE2_DEPLOYER, precompiles::ALPHANET_P256,
-    InspectorExt,
-};
+use crate::{backend::DatabaseExt, precompiles::ALPHANET_P256, InspectorExt};
 use alloy_consensus::BlockHeader;
 use alloy_json_abi::{Function, JsonAbi};
 use alloy_network::AnyTxEnvelope;
@@ -149,12 +146,16 @@ pub fn gas_used(spec: SpecId, spent: u64, refunded: u64) -> u64 {
     spent - (refunded).min(spent / refund_quotient)
 }
 
-fn get_create2_factory_call_inputs(salt: U256, inputs: CreateInputs) -> CallInputs {
+fn get_create2_factory_call_inputs(
+    salt: U256,
+    inputs: CreateInputs,
+    deployer: Address,
+) -> CallInputs {
     let calldata = [&salt.to_be_bytes::<32>()[..], &inputs.init_code[..]].concat();
     CallInputs {
         caller: inputs.caller,
-        bytecode_address: DEFAULT_CREATE2_DEPLOYER,
-        target_address: DEFAULT_CREATE2_DEPLOYER,
+        bytecode_address: deployer,
+        target_address: deployer,
         scheme: CallScheme::Call,
         value: CallValue::Transfer(inputs.value),
         input: calldata.into(),
@@ -165,7 +166,7 @@ fn get_create2_factory_call_inputs(salt: U256, inputs: CreateInputs) -> CallInpu
     }
 }
 
-/// Used for routing certain CREATE2 invocations through [DEFAULT_CREATE2_DEPLOYER].
+/// Used for routing certain CREATE2 invocations through CREATE2_DEPLOYER.
 ///
 /// Overrides create hook with CALL frame if [InspectorExt::should_use_create2_factory] returns
 /// true. Keeps track of overridden frames and handles outcome in the overridden insert_call_outcome
@@ -190,8 +191,10 @@ pub fn create2_handler_register<I: InspectorExt>(
 
             let gas_limit = inputs.gas_limit;
 
+            // Get CREATE2 deployer.
+            let create2_deployer = ctx.external.create2_deployer();
             // Generate call inputs for CREATE2 factory.
-            let mut call_inputs = get_create2_factory_call_inputs(salt, *inputs);
+            let mut call_inputs = get_create2_factory_call_inputs(salt, *inputs, create2_deployer);
 
             // Call inspector to change input or return outcome.
             let outcome = ctx.external.call(&mut ctx.evm, &mut call_inputs);
@@ -202,12 +205,12 @@ pub fn create2_handler_register<I: InspectorExt>(
                 .push((ctx.evm.journaled_state.depth(), call_inputs.clone()));
 
             // Sanity check that CREATE2 deployer exists.
-            let code_hash = ctx.evm.load_account(DEFAULT_CREATE2_DEPLOYER)?.info.code_hash;
+            let code_hash = ctx.evm.load_account(create2_deployer)?.info.code_hash;
             if code_hash == KECCAK_EMPTY {
                 return Ok(FrameOrResult::Result(FrameResult::Call(CallOutcome {
                     result: InterpreterResult {
                         result: InstructionResult::Revert,
-                        output: "missing CREATE2 deployer".into(),
+                        output: format!("missing CREATE2 deployer: {create2_deployer}").into(),
                         gas: Gas::new(gas_limit),
                     },
                     memory_offset: 0..0,

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

@@ -24,6 +24,7 @@ use foundry_evm_core::{
     },
     decode::{RevertDecoder, SkipReason},
     utils::StateChangeset,
+    InspectorExt,
 };
 use foundry_evm_coverage::HitMaps;
 use foundry_evm_traces::{SparsedTraceArena, TraceMode};
@@ -237,6 +238,17 @@ impl Executor {
         self
     }
 
+    #[inline]
+    pub fn set_create2_deployer(&mut self, create2_deployer: Address) -> &mut Self {
+        self.inspector_mut().set_create2_deployer(create2_deployer);
+        self
+    }
+
+    #[inline]
+    pub fn create2_deployer(&self) -> Address {
+        self.inspector().create2_deployer()
+    }
+
     /// Deploys a contract and commits the new state to the underlying database.
     ///
     /// Executes a CREATE transaction with the contract `code` and persistent database state

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

@@ -1,4 +1,5 @@
 use crate::executors::{Executor, ExecutorBuilder};
+use alloy_primitives::Address;
 use foundry_compilers::artifacts::EvmVersion;
 use foundry_config::{utils::evm_spec_id, Chain, Config};
 use foundry_evm_core::{backend::Backend, fork::CreateFork, opts::EvmOpts};
@@ -19,6 +20,7 @@ impl TracingExecutor {
         debug: bool,
         decode_internal: bool,
         alphanet: bool,
+        create2_deployer: Address,
     ) -> Self {
         let db = Backend::spawn(fork);
         let trace_mode =
@@ -31,7 +33,12 @@ impl TracingExecutor {
             // configures a bare version of the evm executor: no cheatcode inspector is enabled,
             // tracing will be enabled only for the targeted transaction
             executor: ExecutorBuilder::new()
-                .inspectors(|stack| stack.trace_mode(trace_mode).alphanet(alphanet))
+                .inspectors(|stack| {
+                    stack
+                        .trace_mode(trace_mode)
+                        .alphanet(alphanet)
+                        .create2_deployer(create2_deployer)
+                })
                 .spec(evm_spec_id(&version.unwrap_or_default(), alphanet))
                 .build(env, db),
         }

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

@@ -59,6 +59,8 @@ pub struct InspectorStackBuilder {
     pub alphanet: bool,
     /// The wallets to set in the cheatcodes context.
     pub wallets: Option<Wallets>,
+    /// The CREATE2 deployer address.
+    pub create2_deployer: Address,
 }
 
 impl InspectorStackBuilder {
@@ -156,6 +158,12 @@ impl InspectorStackBuilder {
         self
     }
 
+    #[inline]
+    pub fn create2_deployer(mut self, create2_deployer: Address) -> Self {
+        self.create2_deployer = create2_deployer;
+        self
+    }
+
     /// Builds the stack of inspectors to use when transacting/committing on the EVM.
     pub fn build(self) -> InspectorStack {
         let Self {
@@ -171,6 +179,7 @@ impl InspectorStackBuilder {
             enable_isolation,
             alphanet,
             wallets,
+            create2_deployer,
         } = self;
         let mut stack = InspectorStack::new();
 
@@ -197,6 +206,7 @@ impl InspectorStackBuilder {
 
         stack.enable_isolation(enable_isolation);
         stack.alphanet(alphanet);
+        stack.set_create2_deployer(create2_deployer);
 
         // environment, must come after all of the inspectors
         if let Some(block) = block {
@@ -282,6 +292,7 @@ pub struct InspectorStackInner {
     pub tracer: Option<TracingInspector>,
     pub enable_isolation: bool,
     pub alphanet: bool,
+    pub create2_deployer: Address,
 
     /// Flag marking if we are in the inner EVM context.
     pub in_inner_context: bool,
@@ -398,6 +409,12 @@ impl InspectorStack {
         self.alphanet = yes;
     }
 
+    /// Set the CREATE2 deployer address.
+    #[inline]
+    pub fn set_create2_deployer(&mut self, deployer: Address) {
+        self.create2_deployer = deployer;
+    }
+
     /// Set whether to enable the log collector.
     #[inline]
     pub fn collect_logs(&mut self, yes: bool) {
@@ -1022,6 +1039,10 @@ impl InspectorExt for InspectorStackRefMut<'_> {
     fn is_alphanet(&self) -> bool {
         self.inner.alphanet
     }
+
+    fn create2_deployer(&self) -> Address {
+        self.inner.create2_deployer
+    }
 }
 
 impl Inspector<&mut dyn DatabaseExt> for InspectorStack {
@@ -1124,6 +1145,10 @@ impl InspectorExt for InspectorStack {
     fn is_alphanet(&self) -> bool {
         self.alphanet
     }
+
+    fn create2_deployer(&self) -> Address {
+        self.create2_deployer
+    }
 }
 
 impl<'a> Deref for InspectorStackRefMut<'a> {

crates/forge/src/multi_runner.rs

@@ -259,6 +259,7 @@ impl MultiContractRunner {
                     .coverage(self.coverage)
                     .enable_isolation(self.isolation)
                     .alphanet(self.alphanet)
+                    .create2_deployer(self.evm_opts.create2_deployer)
             })
             .spec(self.evm_spec)
             .gas_limit(self.evm_opts.gas_limit())

crates/forge/tests/cli/config.rs

@@ -143,6 +143,7 @@ forgetest!(can_extract_config_values, |prj, cmd| {
         isolate: true,
         unchecked_cheatcode_artifacts: false,
         create2_library_salt: Config::DEFAULT_CREATE2_LIBRARY_SALT,
+        create2_deployer: Config::DEFAULT_CREATE2_DEPLOYER,
         vyper: Default::default(),
         skip: vec![],
         dependencies: Default::default(),