dev(sozo): use TransationOption instead of FeeOption (#1927)

* use TransactionOption instead of FeeOption

* clean up

* print more info about error

* implement TransactionExt for AccountDeployment

bin/sozo/src/commands/account.rs

@@ -8,9 +8,9 @@ use starknet::signers::LocalWallet;
 use starknet_crypto::FieldElement;
 use tracing::trace;
 
-use super::options::fee::FeeOptions;
 use super::options::signer::SignerOptions;
 use super::options::starknet::StarknetOptions;
+use super::options::transaction::TransactionOptions;
 use crate::utils;
 
 #[derive(Debug, Args)]
@@ -43,11 +43,15 @@ pub enum AccountCommand {
         signer: SignerOptions,
 
         #[clap(flatten)]
-        fee: FeeOptions,
+        transaction: TransactionOptions,
 
         #[clap(long, help = "Simulate the transaction only")]
         simulate: bool,
 
+        #[clap(long, help = "Only estimate transaction fee without sending transaction")]
+        #[arg(global = true)]
+        estimate_only: bool,
+
         #[clap(long, help = "Provide transaction nonce manually")]
         nonce: Option<FieldElement>,
 
@@ -97,20 +101,21 @@ impl AccountArgs {
                 AccountCommand::Deploy {
                     starknet,
                     signer,
-                    fee,
+                    transaction,
                     simulate,
+                    estimate_only,
                     nonce,
                     poll_interval,
                     file,
                     no_confirmation,
                 } => {
                     let provider = starknet.provider(env_metadata.as_ref())?;
-                    let signer: LocalWallet = signer.signer(env_metadata.as_ref(), false)?;
-                    let fee_setting = fee.into_setting()?;
+                    let signer = signer.signer(env_metadata.as_ref(), false)?;
+                    let txn_action = transaction.to_txn_action(simulate, estimate_only)?;
                     trace!(
                         ?starknet,
                         ?signer,
-                        ?fee_setting,
+                        ?txn_action,
                         simulate,
                         ?nonce,
                         poll_interval,
@@ -121,8 +126,7 @@ impl AccountArgs {
                     account::deploy(
                         provider,
                         signer,
-                        fee_setting,
-                        simulate,
+                        txn_action,
                         nonce,
                         poll_interval,
                         file,

bin/sozo/src/commands/options/mod.rs

@@ -1,5 +1,4 @@
 pub mod account;
-pub mod fee;
 pub mod signer;
 pub mod starknet;
 pub mod transaction;

bin/sozo/src/commands/options/transaction.rs

@@ -1,5 +1,6 @@
+use anyhow::{bail, Result};
 use clap::Args;
-use dojo_world::migration::TxnConfig;
+use dojo_world::migration::{TxnAction, TxnConfig};
 use starknet::core::types::FieldElement;
 use tracing::trace;
 
@@ -38,6 +39,24 @@ pub struct TransactionOptions {
     pub receipt: bool,
 }
 
+impl TransactionOptions {
+    pub fn to_txn_action(&self, simulate: bool, estimate_only: bool) -> Result<TxnAction> {
+        match (estimate_only, simulate) {
+            (true, true) => {
+                bail!("Both `--estimate-only` and `--simulate` cannot be used at same time.")
+            }
+            (true, false) => Ok(TxnAction::Estimate),
+            (false, true) => Ok(TxnAction::Simulate),
+            (false, false) => Ok(TxnAction::Send {
+                wait: self.wait,
+                receipt: self.receipt,
+                max_fee_raw: self.max_fee_raw,
+                fee_estimate_multiplier: self.fee_estimate_multiplier,
+            }),
+        }
+    }
+}
+
 impl From<TransactionOptions> for TxnConfig {
     fn from(value: TransactionOptions) -> Self {
         trace!(

bin/sozo/src/main.rs

@@ -23,7 +23,8 @@ fn main() {
     let ui = Ui::new(args.ui_verbosity(), OutputFormat::Text);
 
     if let Err(err) = cli_main(args) {
-        ui.anyhow(&err);
+        ui.error(format!("{err}"));
+        err.chain().skip(1).for_each(|clause| eprintln!("reason: {:?}", clause));
         exit(1);
     }
 }

crates/dojo-world/src/migration/mod.rs

@@ -108,6 +108,20 @@ pub struct TxnConfig {
     pub max_fee_raw: Option<FieldElement>,
 }
 
+#[derive(Debug, Copy, Clone)]
+pub enum TxnAction {
+    Send {
+        wait: bool,
+        receipt: bool,
+        max_fee_raw: Option<FieldElement>,
+        /// The multiplier for how much the actual transaction max fee should be relative to the
+        /// estimated fee. If `None` is provided, the multiplier is set to `1.1`.
+        fee_estimate_multiplier: Option<f64>,
+    },
+    Estimate,
+    Simulate,
+}
+
 impl TxnConfig {
     pub fn init_wait() -> Self {
         Self { wait: true, ..Default::default() }

crates/dojo-world/src/utils.rs

@@ -4,11 +4,14 @@ use std::task::{Context, Poll};
 use std::time::Duration;
 
 use futures::FutureExt;
-use starknet::accounts::{AccountError, ConnectedAccount, Declaration, Execution};
+use starknet::accounts::{
+    AccountDeployment, AccountError, AccountFactory, AccountFactoryError, ConnectedAccount,
+    Declaration, Execution,
+};
 use starknet::core::types::{
-    DeclareTransactionResult, ExecutionResult, FieldElement, InvokeTransactionResult,
-    MaybePendingTransactionReceipt, PendingTransactionReceipt, StarknetError,
-    TransactionFinalityStatus, TransactionReceipt, TransactionStatus,
+    DeclareTransactionResult, DeployAccountTransactionResult, ExecutionResult, FieldElement,
+    InvokeTransactionResult, MaybePendingTransactionReceipt, PendingTransactionReceipt,
+    StarknetError, TransactionFinalityStatus, TransactionReceipt, TransactionStatus,
 };
 use starknet::providers::{Provider, ProviderError};
 use tokio::time::{Instant, Interval};
@@ -335,27 +338,23 @@ pub fn block_number_from_receipt(receipt: &TransactionReceipt) -> u64 {
 /// Helper trait to abstract away setting `TxnConfig` configurations before sending a transaction
 /// Implemented by types from `starknet-accounts` like `Execution`, `Declaration`, etc...
 #[allow(async_fn_in_trait)]
-pub trait TransactionExt<T>
-where
-    T: ConnectedAccount + Sync,
-{
+pub trait TransactionExt<T> {
     type R;
+    type U;
 
     /// Sets `fee_estimate_multiplier` and `max_fee_raw` from `TxnConfig` if its present before
     /// calling `send` method on the respective type.
     /// NOTE: If both are specified `max_fee_raw` will take precedence and `fee_estimate_multiplier`
     /// will be ignored by `starknet-rs`
-    async fn send_with_cfg(
-        self,
-        txn_config: &TxnConfig,
-    ) -> Result<Self::R, AccountError<T::SignError>>;
+    async fn send_with_cfg(self, txn_config: &TxnConfig) -> Result<Self::R, Self::U>;
 }
 
 impl<T> TransactionExt<T> for Execution<'_, T>
 where
     T: ConnectedAccount + Sync,
 {
     type R = InvokeTransactionResult;
+    type U = AccountError<T::SignError>;
 
     async fn send_with_cfg(
         mut self,
@@ -378,6 +377,7 @@ where
     T: ConnectedAccount + Sync,
 {
     type R = DeclareTransactionResult;
+    type U = AccountError<T::SignError>;
 
     async fn send_with_cfg(
         mut self,
@@ -395,6 +395,29 @@ where
     }
 }
 
+impl<T> TransactionExt<T> for AccountDeployment<'_, T>
+where
+    T: AccountFactory + Sync,
+{
+    type R = DeployAccountTransactionResult;
+    type U = AccountFactoryError<T::SignError>;
+
+    async fn send_with_cfg(
+        mut self,
+        txn_config: &TxnConfig,
+    ) -> Result<Self::R, AccountFactoryError<<T>::SignError>> {
+        if let TxnConfig { fee_estimate_multiplier: Some(fee_est_mul), .. } = txn_config {
+            self = self.fee_estimate_multiplier(*fee_est_mul);
+        }
+
+        if let TxnConfig { max_fee_raw: Some(max_raw_f), .. } = txn_config {
+            self = self.max_fee(*max_raw_f);
+        }
+
+        self.send().await
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use assert_matches::assert_matches;