fix: Respect priority fee and max fee per gas for broadcasting txs with scripts (#841)

Jrigada · elfedy · nbaztec · web-flow · commit 4a216e99dc5a · 2025-01-23T18:52:08.000+01:00
* Pass down priority and max fee per gas for broadcasting script txs * Use EIP1559 parameters only in zksync execution and fix multiplier * Add test for gas estimate multiplier * feat: Add zk gas per pubdata flag (#845) * Add zk gas per pubdata flag * Update crates/cli/src/opts/build/zksync.rs Co-authored-by: Federico Rodríguez <federico@moonsonglabs.com> * simplify approach * Cargo fmt * Put back new line * Update crates/script/src/lib.rs Co-authored-by: Federico Rodríguez <federico@moonsonglabs.com> --------- Co-authored-by: Federico Rodríguez <federico@moonsonglabs.com> * Fix variable name --------- Co-authored-by: Federico Rodríguez <federico@moonsonglabs.com> Co-authored-by: Nisheeth Barthwal <nbaztec@gmail.com>
diff --git a/crates/cast/bin/cmd/send.rs b/crates/cast/bin/cmd/send.rs
@@ -286,7 +286,7 @@ async fn cast_send_zk<P: Provider<T, AnyNetwork>, Z: ZksyncProvider<T>, T: Trans
         zk_tx.set_paymaster_params(paymaster_params);
     }
 
-    foundry_zksync_core::estimate_gas(&mut zk_tx, &zk_provider).await?;
+    foundry_zksync_core::estimate_fee(&mut zk_tx, &zk_provider, 130, None).await?;
 
     let cast = ZkCast::new(zk_provider, Cast::new(provider));
     let pending_tx = cast.send_zk(zk_tx).await?;
diff --git a/crates/forge/bin/cmd/create.rs b/crates/forge/bin/cmd/create.rs
@@ -692,7 +692,7 @@ impl CreateArgs {
         deployer.tx.set_gas_price(gas_price);
 
         // estimate fee
-        foundry_zksync_core::estimate_gas(&mut deployer.tx, &provider).await?;
+        foundry_zksync_core::estimate_fee(&mut deployer.tx, &provider, 130, None).await?;
 
         if !is_legacy {
             let estimate = provider.estimate_eip1559_fees(None).await.wrap_err("Failed to estimate EIP1559 fees. This chain might not support EIP1559, try adding --legacy to your command.")?;
diff --git a/crates/forge/tests/fixtures/zk/Gas.s.sol b/crates/forge/tests/fixtures/zk/Gas.s.sol
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {Script} from "forge-std/Script.sol";
+import {Greeter} from "src/Greeter.sol";
+
+contract GasScript is Script {
+    function run() public {
+        vm.startBroadcast();
+        Greeter greeter = new Greeter();
+        vm.stopBroadcast();
+    }
+}
diff --git a/crates/forge/tests/it/zk/gas.rs b/crates/forge/tests/it/zk/gas.rs
@@ -0,0 +1,132 @@
+use foundry_test_utils::{forgetest_async, util, TestProject};
+
+use foundry_test_utils::{util::OutputExt, ZkSyncNode};
+
+forgetest_async!(zk_script_execution_with_gas_price_specified_by_user, |prj, cmd| {
+    // Setup
+    setup_gas_prj(&mut prj);
+    let node = ZkSyncNode::start().await;
+    let url = node.url();
+    cmd.forge_fuse();
+    let private_key = get_rich_wallet_key();
+
+    // Create script args with gas price parameters
+    let script_args =
+        create_script_args(&private_key, url.as_str(), "--with-gas-price", "370000037");
+    let mut script_args = script_args.into_iter().collect::<Vec<_>>();
+    script_args.extend_from_slice(&["--priority-gas-price", "123123"]);
+
+    // Execute script and verify success
+    cmd.arg("script").args(&script_args);
+    let stdout = cmd.assert_success().get_output().stdout_lossy();
+    assert!(stdout.contains("ONCHAIN EXECUTION COMPLETE & SUCCESSFUL"));
+
+    // Verify transaction details from broadcast artifacts
+    let run_latest = foundry_common::fs::json_files(prj.root().join("broadcast").as_path())
+        .find(|file| file.ends_with("run-latest.json"))
+        .expect("No broadcast artifacts");
+
+    let json: serde_json::Value =
+        serde_json::from_str(&foundry_common::fs::read_to_string(run_latest).unwrap()).unwrap();
+
+    assert_eq!(json["transactions"].as_array().expect("broadcastable txs").len(), 1);
+
+    // Verify gas prices in transaction
+    let transaction_hash = json["receipts"][0]["transactionHash"].as_str().unwrap();
+    let stdout = cmd
+        .cast_fuse()
+        .arg("tx")
+        .arg(transaction_hash)
+        .arg("--rpc-url")
+        .arg(url.as_str())
+        .assert_success()
+        .get_output()
+        .stdout_lossy();
+
+    assert!(stdout.contains("maxFeePerGas         370000037"));
+    assert!(stdout.contains("maxPriorityFeePerGas 123123"));
+});
+
+forgetest_async!(zk_script_execution_with_gas_multiplier, |prj, cmd| {
+    // Setup
+    setup_gas_prj(&mut prj);
+    let node = ZkSyncNode::start().await;
+    let url = node.url();
+    cmd.forge_fuse();
+    let private_key = get_rich_wallet_key();
+
+    // Test with insufficient gas multiplier (should fail)
+    let insufficient_multiplier_args =
+        create_script_args(&private_key, &url, "--gas-estimate-multiplier", "1");
+    cmd.arg("script").args(&insufficient_multiplier_args);
+    cmd.assert_failure();
+    cmd.forge_fuse();
+
+    // Test with sufficient gas multiplier (should succeed)
+    let sufficient_multiplier_args =
+        create_script_args(&private_key, &url, "--gas-estimate-multiplier", "100");
+    cmd.arg("script").args(&sufficient_multiplier_args);
+    let stdout = cmd.assert_success().get_output().stdout_lossy();
+    assert!(stdout.contains("ONCHAIN EXECUTION COMPLETE & SUCCESSFUL"));
+});
+
+forgetest_async!(zk_script_execution_with_gas_per_pubdata, |prj, cmd| {
+    // Setup
+    setup_gas_prj(&mut prj);
+    let node = ZkSyncNode::start().await;
+    let url = node.url();
+    cmd.forge_fuse();
+    let private_key = get_rich_wallet_key();
+
+    // Test with unacceptable gas per pubdata (should fail)
+    let zero_pubdata_args = create_script_args(&private_key, &url, "--zk-gas-per-pubdata", "1");
+    cmd.arg("script").args(&zero_pubdata_args);
+    cmd.assert_failure();
+    cmd.forge_fuse();
+
+    // Test with sufficient gas per pubdata (should succeed)
+    let sufficient_pubdata_args =
+        create_script_args(&private_key, &url, "--zk-gas-per-pubdata", "3000");
+    cmd.arg("script").args(&sufficient_pubdata_args);
+    let stdout = cmd.assert_success().get_output().stdout_lossy();
+    assert!(stdout.contains("ONCHAIN EXECUTION COMPLETE & SUCCESSFUL"));
+});
+
+fn get_rich_wallet_key() -> String {
+    ZkSyncNode::rich_wallets()
+        .next()
+        .map(|(_, pk, _)| pk)
+        .expect("No rich wallets available")
+        .to_owned()
+}
+
+fn create_script_args<'a>(
+    private_key: &'a str,
+    url: &'a str,
+    gas_param: &'a str,
+    gas_value: &'a str,
+) -> Vec<&'a str> {
+    vec![
+        "--zk-startup",
+        "./script/Gas.s.sol",
+        "--private-key",
+        private_key,
+        "--chain",
+        "260",
+        "--rpc-url",
+        url,
+        "--slow",
+        "-vvvvv",
+        "--broadcast",
+        "--timeout",
+        "3",
+        gas_param,
+        gas_value,
+    ]
+}
+
+fn setup_gas_prj(prj: &mut TestProject) {
+    util::initialize(prj.root());
+    prj.add_script("Gas.s.sol", include_str!("../../fixtures/zk/Gas.s.sol")).unwrap();
+    prj.add_source("Greeter.sol", include_str!("../../../../../testdata/zk/Greeter.sol")).unwrap();
+}
diff --git a/crates/forge/tests/it/zk/mod.rs b/crates/forge/tests/it/zk/mod.rs
@@ -10,6 +10,7 @@ mod factory;
 mod factory_deps;
 mod fork;
 mod fuzz;
+mod gas;
 mod invariant;
 mod linking;
 mod logs;
diff --git a/crates/script/src/broadcast.rs b/crates/script/src/broadcast.rs
@@ -70,6 +70,7 @@ pub async fn send_transaction(
     is_fixed_gas_limit: bool,
     estimate_via_rpc: bool,
     estimate_multiplier: u64,
+    gas_per_pubdata: Option<u64>,
 ) -> Result<TxHash> {
     let zk_tx_meta =
         if let SendTransactionKind::Raw(tx, _) | SendTransactionKind::Unlocked(tx) = &mut kind {
@@ -141,7 +142,14 @@ pub async fn send_transaction(
                         },
                     );
                 }
-                foundry_zksync_core::estimate_gas(&mut zk_tx, &zk_provider).await?;
+
+                foundry_zksync_core::estimate_fee(
+                    &mut zk_tx,
+                    &zk_provider,
+                    estimate_multiplier,
+                    gas_per_pubdata,
+                )
+                .await?;
 
                 let zk_signer = alloy_zksync::wallet::ZksyncWallet::new(signer.default_signer());
                 let signed = zk_tx.build(&zk_signer).await?.encoded_2718();
@@ -317,7 +325,20 @@ impl BundledState {
                     self.args.with_gas_price,
                     self.args.priority_gas_price,
                 ) {
-                    (true, Some(gas_price), _) => (Some(gas_price.to()), None),
+                    (true, Some(gas_price), priority_fee) => (
+                        Some(gas_price.to()),
+                        if self.script_config.config.zksync.run_in_zk_mode() {
+                            // NOTE(zk): Zksync is marked as legacy in alloy chains but it is
+                            // compliant with EIP-1559 so we need to
+                            // pass down the user provided values
+                            priority_fee.map(|fee| Eip1559Estimation {
+                                max_fee_per_gas: gas_price.to(),
+                                max_priority_fee_per_gas: fee.to(),
+                            })
+                        } else {
+                            None
+                        },
+                    ),
                     (true, None, _) => (Some(provider.get_gas_price().await?), None),
                     (false, Some(max_fee_per_gas), Some(max_priority_fee_per_gas)) => (
                         None,
@@ -367,6 +388,15 @@ impl BundledState {
 
                                 if let Some(gas_price) = gas_price {
                                     tx.set_gas_price(gas_price);
+                                    if self.script_config.config.zksync.run_in_zk_mode() {
+                                        // NOTE(zk): Also set EIP-1559 fees for zk transactions
+                                        if let Some(eip1559_fees) = eip1559_fees {
+                                            tx.set_max_priority_fee_per_gas(
+                                                eip1559_fees.max_priority_fee_per_gas,
+                                            );
+                                            tx.set_max_fee_per_gas(eip1559_fees.max_fee_per_gas);
+                                        }
+                                    }
                                 } else {
                                     let eip1559_fees = eip1559_fees.expect("was set above");
                                     tx.set_max_priority_fee_per_gas(
@@ -417,6 +447,7 @@ impl BundledState {
                             *is_fixed_gas_limit,
                             estimate_via_rpc,
                             self.args.gas_estimate_multiplier,
+                            self.args.zk_gas_per_pubdata,
                         );
                         pending_transactions.push(fut);
                     }
diff --git a/crates/script/src/lib.rs b/crates/script/src/lib.rs
@@ -217,6 +217,10 @@ pub struct ScriptArgs {
 
     #[command(flatten)]
     pub retry: RetryArgs,
+
+    /// Gas per pubdata
+    #[clap(long = "zk-gas-per-pubdata", value_name = "GAS_PER_PUBDATA")]
+    pub zk_gas_per_pubdata: Option<u64>,
 }
 
 impl ScriptArgs {
diff --git a/crates/zksync/core/src/lib.rs b/crates/zksync/core/src/lib.rs
@@ -136,15 +136,24 @@ pub struct EstimatedGas {
 
 /// Estimates the gas parameters for the provided transaction.
 /// This will call `estimateFee` method on the rpc and set the gas parameters on the transaction.
-pub async fn estimate_gas<P: ZksyncProvider<T>, T: Transport + Clone>(
+pub async fn estimate_fee<P: ZksyncProvider<T>, T: Transport + Clone>(
     tx: &mut ZkTransactionRequest,
     provider: P,
+    estimate_multiplier: u64,
+    gas_per_pubdata: Option<u64>,
 ) -> Result<()> {
     let fee = provider.estimate_fee(tx.clone()).await?;
-    tx.set_gas_limit(fee.gas_limit);
-    tx.set_max_fee_per_gas(fee.max_fee_per_gas);
-    tx.set_max_priority_fee_per_gas(fee.max_priority_fee_per_gas);
-    tx.set_gas_per_pubdata(fee.gas_per_pubdata_limit);
+    tx.set_gas_limit(fee.gas_limit * estimate_multiplier / 100);
+    // If user provided a gas price, use it for both maxFeePerGas
+    let max_fee = tx.max_fee_per_gas().unwrap_or(fee.max_fee_per_gas);
+    let max_priority_fee = tx.max_priority_fee_per_gas().unwrap_or(fee.max_priority_fee_per_gas);
+    let gas_per_pubdata = match gas_per_pubdata {
+        Some(value) => rU256::from(value),
+        None => fee.gas_per_pubdata_limit,
+    };
+    tx.set_max_fee_per_gas(max_fee);
+    tx.set_max_priority_fee_per_gas(max_priority_fee);
+    tx.set_gas_per_pubdata(gas_per_pubdata);
 
     Ok(())
 }

Original file line number	Diff line number	Diff line change
`@@ -286,7 +286,7 @@ async fn cast_send_zk<P: Provider<T, AnyNetwork>, Z: ZksyncProvider<T>, T: Trans`
`286`	`286`	`zk_tx.set_paymaster_params(paymaster_params);`
`287`	`287`	`}`
`288`	`288`
`289`		`- foundry_zksync_core::estimate_gas(&mut zk_tx, &zk_provider).await?;`
	`289`	`+ foundry_zksync_core::estimate_fee(&mut zk_tx, &zk_provider, 130, None).await?;`
`290`	`290`
`291`	`291`	`let cast = ZkCast::new(zk_provider, Cast::new(provider));`
`292`	`292`	`let pending_tx = cast.send_zk(zk_tx).await?;`
Original file line number	Diff line number	Diff line change
`@@ -217,6 +217,10 @@ pub struct ScriptArgs {`
`217`	`217`
`218`	`218`	`#[command(flatten)]`
`219`	`219`	`pub retry: RetryArgs,`
	`220`	`+`
	`221`	`+ /// Gas per pubdata`
	`222`	`+ #[clap(long = "zk-gas-per-pubdata", value_name = "GAS_PER_PUBDATA")]`
	`223`	`+ pub zk_gas_per_pubdata: Option<u64>,`
`220`	`224`	`}`
`221`	`225`
`222`	`226`	`impl ScriptArgs {`