feat: support EVM interpreter for cast run (#1168)

* support evm interpreter

* support cast

* cleanup

* fmt

* remove print

* clippy

* update Cargo.lock

* use evm-interpreter aware transact_with_env instead fo deploy_with_env

* fmt

* fmt

* handle transact_to address for CALLs

* fix test

* add test

* add test for cast run with evm interpreter

* Add gas comparison and fix interpreter not being used

* Remove force EVM interpreter override in cast run

* fix conflict resolution

* remove raw logs and fix test list

---------

Co-authored-by: jrigada <[email protected]>
Co-authored-by: Juan Rigada <[email protected]>

Author: nbaztec

crates/cast/src/cmd/call.rs

@@ -297,6 +297,7 @@ impl CallArgs {
                             paymaster: Default::default(),
                             paymaster_input: data.to_vec(),
                         }),
+                    force_evm_interpreter: None,
                 };
 
                 other_fields.insert(

crates/cast/src/cmd/run.rs

@@ -113,6 +113,10 @@ pub struct RunArgs {
     #[arg(long = "zksync")]
     zk_force: bool,
 
+    /// Use ZKsync EVM interpreter.
+    #[arg(long = "zk-evm-interpreter")]
+    zk_evm_interpreter: bool,
+
     /// Disables storage caching entirely.
     /// NOTE(zk) This is needed so tests don't cache anvil-zksync responses, could also be useful
     /// upstream.
@@ -131,6 +135,7 @@ impl RunArgs {
         let evm_opts = figment.extract::<EvmOpts>()?;
         let mut config = Config::from_provider(figment)?.sanitized();
         config.zksync.compile = self.zk_force;
+        config.zksync.evm_interpreter = self.zk_evm_interpreter;
         config.no_storage_caching = self.no_storage_caching;
         let strategy = utils::get_executor_strategy(&config);
 
@@ -319,7 +324,17 @@ impl RunArgs {
                         })?;
                     } else {
                         trace!(tx=?tx.tx_hash(), "executing previous create transaction");
-                        if let Err(error) = executor.deploy_with_env(env.clone(), None) {
+                        if self.zk_force {
+                            if let Err(error) = executor.transact_with_env(env.clone()) {
+                                return Err(error).wrap_err_with(|| {
+                                    format!(
+                                        "Failed to deploy transaction: {:?} in block {}",
+                                        tx.tx_hash(),
+                                        env.evm_env.block_env.number
+                                    )
+                                });
+                            }
+                        } else if let Err(error) = executor.deploy_with_env(env.clone(), None) {
                             match error {
                                 // Reverted transactions should be skipped
                                 EvmError::Execution(_) => (),
@@ -380,7 +395,11 @@ impl RunArgs {
                 TraceResult::try_from(executor.transact_with_env(env))?
             } else {
                 trace!(tx=?tx.tx_hash(), "executing create transaction");
-                TraceResult::try_from(executor.deploy_with_env(env, None))?
+                if self.zk_force {
+                    TraceResult::try_from(executor.transact_with_env(env))?
+                } else {
+                    TraceResult::try_from(executor.deploy_with_env(env, None))?
+                }
             }
         };
 
@@ -478,9 +497,9 @@ pub fn configure_zksync_tx_env(
     // Set basic transaction fields
     env.tx.caller = outer_tx.initiator_account().to_address();
 
-    env.tx.kind = TxKind::Call(
-        outer_tx.recipient_account().expect("recipient_account not found in execute").to_address(),
-    );
+    let recipient_account = outer_tx.recipient_account();
+
+    env.tx.kind = TxKind::Call(recipient_account.unwrap_or_default().to_address());
     env.tx.gas_limit = match &outer_tx.common_data {
         ExecuteTransactionCommon::L2(l2) => l2.fee.gas_limit.as_u64(),
         _ => outer_tx.gas_limit().as_u64(),
@@ -497,10 +516,12 @@ pub fn configure_zksync_tx_env(
         ExecuteTransactionCommon::L2(common_data) => foundry_zksync_core::ZkTransactionMetadata {
             factory_deps: outer_tx.execute.factory_deps.clone(),
             paymaster_data: Some(common_data.paymaster_params.clone()),
+            force_evm_interpreter: None,
         },
         _ => foundry_zksync_core::ZkTransactionMetadata {
             factory_deps: outer_tx.execute.factory_deps.clone(),
             paymaster_data: None,
+            force_evm_interpreter: None,
         },
     }
 }

crates/cast/tests/cli/zk.rs

@@ -816,6 +816,89 @@ casttest!(test_zk_cast_run_with_call, async |prj, cmd| {
     );
 });
 
+casttest!(test_zk_cast_run_with_evm_interpreter, async |prj, cmd| {
+    let node = ZkSyncNode::start().await;
+    let url = node.url();
+
+    let (_, private_key) = ZkSyncNode::rich_wallets()
+        .next()
+        .map(|(addr, pk, _)| (addr, pk))
+        .expect("No rich wallets available");
+
+    prj.add_script(
+        "Counter",
+        r#"
+        contract Counter {
+            uint256 public number;
+
+            function increment() public {
+                number++;
+            }
+        }
+
+       "#,
+    );
+
+    // Deploy the contract
+    let output = cmd
+        .forge_fuse()
+        .args([
+            "create",
+            "Counter",
+            "--rpc-url",
+            &url,
+            "--private-key",
+            private_key,
+            "--zksync",
+            "--broadcast",
+        ])
+        .assert_success()
+        .get_output()
+        .stdout_lossy();
+
+    let output = output.trim().parse::<String>().unwrap();
+    assert!(output.contains("success"));
+
+    let re = Regex::new(r"Deployed to: (\w+)\nTransaction hash: (\w+)").expect("invalid regex");
+    let caps = re.captures(&output).expect("failed getting captures");
+    let deployed_addr = caps.get(1).expect("failed getting deployed address").as_str();
+
+    // Call a function to generate a transaction
+    let output = cmd
+        .cast_fuse()
+        .args([
+            "send",
+            deployed_addr,
+            "increment()",
+            "--rpc-url",
+            &url,
+            "--private-key",
+            private_key,
+            "--zksync",
+        ])
+        .assert_success()
+        .get_output()
+        .stdout_lossy();
+
+    let re = Regex::new(r"transactionHash\s+(\w+)").expect("invalid regex");
+    let caps = re.captures(&output).expect("failed getting capture");
+    let tx_hash = caps.get(1).expect("failed getting tx hash").as_str();
+
+    let output = cmd
+        .cast_fuse()
+        .args(["run", "--rpc-url", &url, "--zksync", tx_hash, "--no-storage-caching"])
+        .assert_success()
+        .get_output()
+        .stdout_lossy();
+
+    assert!(
+        output.contains(&format!("{deployed_addr}::increment()")) && output.contains("Return"),
+        "trace missing or incomplete, got:\n{output}"
+    );
+
+    assert!(output.contains("Traces:"), "trace missing, got:\n{output}");
+});
+
 casttest!(test_zk_cast_run_with_create_transaction_on_sepolia, async |_prj, cmd| {
     let node =
         ZkSyncNode::start_with_fork(Fork::new("https://sepolia.era.zksync.dev".to_string())).await;

crates/strategy/zksync/src/executor/runner/libraries.rs

@@ -222,6 +222,7 @@ impl ZksyncExecutorStrategyRunner {
 
         let ctx = get_context(executor.strategy.context.as_mut());
 
+        // TODO(zk): adapt this to conditionally use EVM interpreter?
         let (code, create_scheme, to) = match kind {
             DeployLibKind::Create(bytes) => {
                 (bytes, CreateScheme::Create, CONTRACT_DEPLOYER_ADDRESS)
@@ -254,7 +255,8 @@ impl ZksyncExecutorStrategyRunner {
         // persist existing paymaster data (TODO(zk): is this needed?)
         let paymaster_data =
             ctx.transaction_context.take().and_then(|metadata| metadata.paymaster_data);
-        let metadata = ZkTransactionMetadata { factory_deps, paymaster_data };
+        let metadata =
+            ZkTransactionMetadata { factory_deps, paymaster_data, force_evm_interpreter: None };
         ctx.transaction_context = Some(metadata.clone());
 
         let result = executor.transact_raw(from, to, create_params.clone(), value)?;

crates/zksync/core/src/lib.rs

@@ -111,12 +111,14 @@ pub struct ZkTransactionMetadata {
     pub factory_deps: Vec<Vec<u8>>,
     /// Paymaster data for ZK transactions.
     pub paymaster_data: Option<PaymasterParams>,
+    /// Use EVM interpreter overriding the strategy configuration.
+    pub force_evm_interpreter: Option<bool>,
 }
 
 impl ZkTransactionMetadata {
     /// Create a new [`ZkTransactionMetadata`] with the given factory deps
     pub fn new(factory_deps: Vec<Vec<u8>>, paymaster_data: Option<PaymasterParams>) -> Self {
-        Self { factory_deps, paymaster_data }
+        Self { factory_deps, paymaster_data, force_evm_interpreter: None } // TODO(zk): make it configurable
     }
 }
 /// Estimated gas from a ZK network.

zksync-tests

@@ -11,6 +11,7 @@ cast::cli:
     zk::test_zk_cast_run_with_call_transaction_on_sepolia
     zk::test_zk_cast_run_with_create
     zk::test_zk_cast_run_with_create_transaction_on_sepolia
+    zk::test_zk_cast_run_with_evm_interpreter
     zk::test_zk_cast_using_paymaster
     zk::test_zk_cast_without_paymaster
 forge: