Add basic support for zksync fields in tx

crates/cast/bin/cmd/estimate.rs

@@ -2,6 +2,8 @@ use crate::tx::{CastTxBuilder, SenderKind};
 use alloy_primitives::U256;
 use alloy_provider::Provider;
 use alloy_rpc_types::BlockId;
+use alloy_zksync::network::transaction_request::TransactionRequest as ZkTransactionRequest;
+use cast::ZkTransactionOpts;
 use clap::Parser;
 use eyre::Result;
 use foundry_cli::{
@@ -39,6 +41,10 @@ pub struct EstimateArgs {
 
     #[command(flatten)]
     eth: EthereumOpts,
+
+    /// Zksync Transaction
+    #[command(flatten)]
+    zksync: ZkTransactionOpts,
 }
 
 #[derive(Debug, Parser)]
@@ -67,10 +73,11 @@ pub enum EstimateSubcommands {
 
 impl EstimateArgs {
     pub async fn run(self) -> Result<()> {
-        let Self { to, mut sig, mut args, mut tx, block, eth, command } = self;
+        let Self { to, mut sig, mut args, mut tx, block, eth, command, zksync } = self;
 
         let config = Config::from(&eth);
         let provider = utils::get_provider(&config)?;
+        //let provider = utils::get_provider_zksync(&config)?;
         let sender = SenderKind::from_wallet_opts(eth.wallet).await?;
 
         let code = if let Some(EstimateSubcommands::Create {
@@ -99,7 +106,15 @@ impl EstimateArgs {
             .build_raw(sender)
             .await?;
 
-        let gas = provider.estimate_gas(&tx).block(block.unwrap_or_default()).await?;
+        let gas = if zksync.has_zksync_args() {
+            let zk_provider = utils::get_provider_zksync(&config)?;
+            let mut zk_tx: ZkTransactionRequest = tx.inner.clone().into();
+            zksync.apply_to_tx(&mut zk_tx);
+            zk_provider.estimate_gas(&zk_tx).await?
+        } else {
+            provider.estimate_gas(&tx).block(block.unwrap_or_default()).await?
+        };
+
         sh_println!("{gas}")?;
         Ok(())
     }

crates/cast/src/zksync.rs

@@ -1,11 +1,14 @@
 //! Contains zksync specific logic for foundry's `cast` functionality
 
 use alloy_network::AnyNetwork;
+use alloy_primitives::{Address, Bytes, U256};
 use alloy_provider::{PendingTransactionBuilder, Provider};
 use alloy_transport::Transport;
 use alloy_zksync::network::{
-    transaction_request::TransactionRequest as ZkTransactionRequest, Zksync,
+    transaction_request::TransactionRequest as ZkTransactionRequest,
+    unsigned_tx::eip712::PaymasterParams, Zksync,
 };
+use clap::Parser;
 use eyre::Result;
 
 use crate::Cast;
@@ -63,3 +66,59 @@ where
         Ok(res)
     }
 }
+
+#[derive(Clone, Debug, Parser)]
+#[command(next_help_heading = "Transaction options")]
+pub struct ZkTransactionOpts {
+    // /// Use ZKSync
+    // #[arg(long, default_value_ifs([("paymaster_address", ArgPredicate::IsPresent,
+    // "true"),("paymaster_input", ArgPredicate::IsPresent, "true")]))] pub zksync: bool,
+    /// Paymaster address for the ZKSync transaction
+    #[arg(long = "zk-paymaster-address", requires = "paymaster_input")]
+    pub paymaster_address: Option<Address>,
+
+    /// Paymaster input for the ZKSync transaction
+    #[arg(long = "zk-paymaster-input", requires = "paymaster_address")]
+    pub paymaster_input: Option<Bytes>,
+
+    /// Factory dependencies for the ZKSync transaction
+    #[arg(long = "zk-factory-deps")]
+    pub factory_deps: Vec<Bytes>,
+
+    /// Custom signature for the ZKSync transaction
+    #[arg(long = "zk-custom-signature")]
+    pub custom_signature: Option<Bytes>,
+
+    /// Gas per pubdata for the ZKSync transaction
+    #[arg(long = "zk-gas-per-pubdata")]
+    pub gas_per_pubdata: Option<U256>,
+}
+
+impl ZkTransactionOpts {
+    pub fn has_zksync_args(&self) -> bool {
+        self.paymaster_address.is_some() ||
+            !self.factory_deps.is_empty() ||
+            self.custom_signature.is_some() ||
+            self.gas_per_pubdata.is_some()
+    }
+
+    pub fn apply_to_tx(&self, tx: &mut ZkTransactionRequest) {
+        if let Some(gas_per_pubdata) = self.gas_per_pubdata {
+            tx.set_gas_per_pubdata(gas_per_pubdata)
+        }
+
+        if !self.factory_deps.is_empty() {
+            tx.set_factory_deps(self.factory_deps.clone());
+        }
+
+        if let Some(custom_signature) = &self.custom_signature {
+            tx.set_custom_signature(custom_signature.clone());
+        }
+
+        if let (Some(paymaster), Some(paymaster_input)) =
+            (self.paymaster_address, self.paymaster_input.clone())
+        {
+            tx.set_paymaster_params(PaymasterParams { paymaster, paymaster_input });
+        }
+    }
+}