move create HTLC to return tx fees

Author: OBorce

wallet/src/wallet/mod.rs

@@ -1178,23 +1178,6 @@ where
         )
     }
 
-    fn for_account_rw_unlocked_and_check_tx(
-        &mut self,
-        account_index: U31,
-        additional_info: TxAdditionalInfo,
-        f: impl FnOnce(&mut Account<P::K>, &mut StoreTxRwUnlocked<B>) -> WalletResult<SendRequest>,
-    ) -> WalletResult<SignedTransaction> {
-        Ok(self
-            .for_account_rw_unlocked_and_check_tx_generic(
-                account_index,
-                additional_info,
-                |account, db_tx| Ok((f(account, db_tx)?, ())),
-                |err| err,
-            )?
-            .0
-            .tx)
-    }
-
     fn for_account_rw_unlocked_and_check_tx_with_fees(
         &mut self,
         account_index: U31,
@@ -2134,9 +2117,9 @@ where
         current_fee_rate: FeeRate,
         consolidate_fee_rate: FeeRate,
         additional_info: TxAdditionalInfo,
-    ) -> WalletResult<SignedTransaction> {
+    ) -> WalletResult<SignedTxWithFees> {
         let latest_median_time = self.latest_median_time;
-        self.for_account_rw_unlocked_and_check_tx(
+        self.for_account_rw_unlocked_and_check_tx_with_fees(
             account_index,
             additional_info,
             |account, db_tx| {

wallet/src/wallet/tests.rs

@@ -5553,7 +5553,8 @@ fn create_htlc_and_spend(#[case] seed: Seed) {
             FeeRate::from_amount_per_kb(Amount::ZERO),
             TxAdditionalInfo::new(),
         )
-        .unwrap();
+        .unwrap()
+        .tx;
     let create_htlc_tx_id = create_htlc_tx.transaction().get_id();
     let (_, block2) = create_block(
         &chain_config,
@@ -5693,7 +5694,8 @@ fn create_htlc_and_refund(#[case] seed: Seed) {
             FeeRate::from_amount_per_kb(Amount::ZERO),
             TxAdditionalInfo::new(),
         )
-        .unwrap();
+        .unwrap()
+        .tx;
     let create_htlc_tx_id = create_htlc_tx.transaction().get_id();
 
     let refund_tx = Transaction::new(

wallet/types/src/lib.rs

@@ -28,20 +28,20 @@ pub mod wallet_tx;
 pub mod wallet_type;
 pub mod with_locked;
 
-use std::collections::BTreeMap;
-
 pub use account_id::{
     AccountDerivationPathId, AccountId, AccountKeyPurposeId, AccountWalletCreatedTxId,
     AccountWalletTxId,
 };
 pub use account_info::AccountInfo;
+pub use currency::Currency;
+pub use keys::{KeyPurpose, KeychainUsageState, RootKeys};
+pub use wallet_tx::{BlockInfo, WalletTx};
+
 use common::{
     chain::{SignedTransaction, Transaction},
     primitives::Amount,
 };
-pub use currency::Currency;
-pub use keys::{KeyPurpose, KeychainUsageState, RootKeys};
-pub use wallet_tx::{BlockInfo, WalletTx};
+use std::collections::BTreeMap;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SignedTxWithFees {

wallet/wallet-cli-commands/src/command_handler/mod.rs

@@ -140,7 +140,7 @@ where
             let hex = new_tx.tx.to_string();
             let summary = new_tx.tx.take().transaction().text_summary(chain_config);
 
-            format!("{summary}\nThe transaction was created and ready to be submitted:\n{hex}",)
+            format!("{summary}\nThe transaction was created and is ready to be submitted:\n{hex}",)
         };
 
         ConsoleCommand::Print(status_text)

wallet/wallet-cli-commands/src/lib.rs

@@ -302,9 +302,12 @@ pub enum WalletCommand {
     #[command(flatten)]
     ColdCommands(ColdWalletCommand),
 
-    /// Configure broadcasting to Mempool to true of false.
-    /// By default it is set to true. If set to false, any command that creates a transaction will
-    /// return it to the user and will need to be submitted manually with the command `node-submit-transaction`
+    /// Configure broadcasting to Mempool to true or false.
+    ///
+    /// If set to false, any command that creates a transaction will return it to the user and not submit it automatically.
+    /// The transaction will need to be submitted manually with the command `node-submit-transaction`.
+    ///
+    /// The effect of this is not preserved when the CLI wallet is closed.
     #[clap(name = "config-broadcast")]
     ConfigBroadcast { broadcast: bool },
 

wallet/wallet-controller/src/runtime_wallet.rs

@@ -1123,7 +1123,7 @@ impl<B: storage::Backend + 'static> RuntimeWallet<B> {
         current_fee_rate: FeeRate,
         consolidate_fee_rate: FeeRate,
         additional_info: TxAdditionalInfo,
-    ) -> WalletResult<SignedTransaction> {
+    ) -> WalletResult<SignedTxWithFees> {
         match self {
             RuntimeWallet::Software(w) => w.create_htlc_tx(
                 account_index,

wallet/wallet-controller/src/synced_controller.rs

@@ -1111,19 +1111,26 @@ where
         output_value: OutputValue,
         htlc: HashedTimelockContract,
         additional_info: TxAdditionalInfo,
-    ) -> Result<SignedTransaction, ControllerError<T>> {
+    ) -> Result<NewTransaction, ControllerError<T>> {
         let (current_fee_rate, consolidate_fee_rate) =
             self.get_current_and_consolidation_fee_rate().await?;
 
-        let result = self.wallet.create_htlc_tx(
+        let SignedTxWithFees { tx, fees } = self.wallet.create_htlc_tx(
             self.account_index,
             output_value,
             htlc,
             current_fee_rate,
             consolidate_fee_rate,
             additional_info,
         )?;
-        Ok(result)
+
+        let fees = into_balances(&self.rpc_client, self.chain_config, fees).await?;
+
+        Ok(NewTransaction {
+            tx,
+            fees,
+            broadcasted: false,
+        })
     }
 
     pub async fn create_order(

wallet/wallet-controller/src/types/mod.rs

@@ -35,9 +35,8 @@ use common::{
 };
 pub use seed_phrase::SeedWithPassPhrase;
 pub use standalone_key::AccountStandaloneKeyDetails;
-pub use transaction::NewTransaction;
 pub use transaction::{
-    InspectTransaction, SignatureStats, TransactionToInspect, ValidatedSignatures,
+    InspectTransaction, NewTransaction, SignatureStats, TransactionToInspect, ValidatedSignatures,
 };
 use utils::ensure;
 use wallet::signer::trezor_signer::FoundDevice;

wallet/wallet-rpc-client/src/handles_client/mod.rs

@@ -1107,7 +1107,7 @@ where
         token_id: Option<String>,
         htlc: RpcHashedTimelockContract,
         config: ControllerConfig,
-    ) -> Result<HexEncoded<SignedTransaction>, Self::Error> {
+    ) -> Result<RpcNewTransaction, Self::Error> {
         self.wallet_rpc
             .create_htlc_transaction(
                 account_index,
@@ -1117,7 +1117,6 @@ where
                 config,
             )
             .await
-            .map(HexEncoded::new)
             .map_err(WalletRpcHandlesClientError::WalletRpcError)
     }
 

wallet/wallet-rpc-client/src/rpc_client/client_impl.rs

@@ -1015,7 +1015,7 @@ impl WalletInterface for ClientWalletRpc {
         token_id: Option<String>,
         htlc: RpcHashedTimelockContract,
         config: ControllerConfig,
-    ) -> Result<HexEncoded<SignedTransaction>, Self::Error> {
+    ) -> Result<RpcNewTransaction, Self::Error> {
         let options = TransactionOptions::from_controller_config(&config);
         WalletRpcClient::create_htlc_transaction(
             &self.http_client,

wallet/wallet-rpc-client/src/wallet_rpc_traits.rs

@@ -506,7 +506,7 @@ pub trait WalletInterface {
         token_id: Option<String>,
         htlc: RpcHashedTimelockContract,
         config: ControllerConfig,
-    ) -> Result<HexEncoded<SignedTransaction>, Self::Error>;
+    ) -> Result<RpcNewTransaction, Self::Error>;
 
     #[allow(clippy::too_many_arguments)]
     async fn create_order(

wallet/wallet-rpc-lib/src/rpc/interface.rs

@@ -739,7 +739,7 @@ trait WalletRpc {
         token_id: Option<RpcAddress<TokenId>>,
         htlc: RpcHashedTimelockContract,
         options: TransactionOptions,
-    ) -> rpc::RpcResult<HexEncoded<SignedTransaction>>;
+    ) -> rpc::RpcResult<RpcNewTransaction>;
 
     /// Create an order for exchanging "given" amount of an arbitrary currency (coins or tokens) for
     /// an arbitrary amount of "asked" currency.

wallet/wallet-rpc-lib/src/rpc/mod.rs

@@ -1511,7 +1511,7 @@ where
         token_id: Option<RpcAddress<TokenId>>,
         htlc: RpcHashedTimelockContract,
         config: ControllerConfig,
-    ) -> WRpcResult<SignedTransaction, N> {
+    ) -> WRpcResult<RpcNewTransaction, N> {
         let secret_hash = HtlcSecretHash::decode_all(&mut htlc.secret_hash.as_bytes())
             .map_err(|_| RpcError::InvalidHtlcSecretHash)?;
 
@@ -1571,6 +1571,7 @@ where
                         .create_htlc_tx(value, htlc, additional_info)
                         .await
                         .map_err(RpcError::Controller)
+                        .map(RpcNewTransaction::new)
                 })
             })
             .await?

wallet/wallet-rpc-lib/src/rpc/server_impl.rs

@@ -1110,16 +1110,15 @@ where
         token_id: Option<RpcAddress<TokenId>>,
         htlc: RpcHashedTimelockContract,
         options: TransactionOptions,
-    ) -> rpc::RpcResult<HexEncoded<SignedTransaction>> {
+    ) -> rpc::RpcResult<RpcNewTransaction> {
         let config = ControllerConfig {
             in_top_x_mb: options.in_top_x_mb(),
             broadcast_to_mempool: true,
         };
 
         rpc::handle_result(
             self.create_htlc_transaction(account_arg.index::<N>()?, amount, token_id, htlc, config)
-                .await
-                .map(HexEncoded::new),
+                .await,
         )
     }