fix comments

Author: OBorce

test/functional/test_framework/wallet_cli_controller.py

@@ -301,8 +301,9 @@ async def create_from_cold_address(self, address: str, amount: int, selected_utx
         change_address_str = '' if change_address is None else f"--change {change_address}"
         return await self._write_command(f"transaction-create-from-cold-input {address} {amount} {str(selected_utxo)} {change_address_str}\n")
 
-    async def sweep_addresses(self, destination_address: str, from_addresses: List[str] = []) -> str:
-        return await self._write_command(f"address-sweep-spendable {destination_address} {' '.join(from_addresses)}\n")
+    async def sweep_addresses(self, destination_address: str, from_addresses: List[str] = [], all_addresses: bool = False) -> str:
+        all_addresses_str = "--all" if all_addresses else ""
+        return await self._write_command(f"address-sweep-spendable {destination_address} {' '.join(from_addresses)} {all_addresses_str}\n")
 
     async def sweep_delegation(self, destination_address: str, delegation_id: str) -> str:
         return await self._write_command(f"staking-sweep-delegation {destination_address} {delegation_id}\n")

test/functional/test_framework/wallet_rpc_controller.py

@@ -25,7 +25,7 @@
 import base64
 from operator import itemgetter
 
-from typing import Optional, List, Union
+from typing import Optional, List, Union, TypedDict
 
 from test_framework.util import assert_in, rpc_port
 from test_framework.wallet_controller_common import PartialSigInfo, TokenTxOutput, UtxoOutpoint, WalletCliControllerBase
@@ -46,6 +46,16 @@ def to_json(self):
         else:
             return {'Transfer': [ { 'Coin': {"atoms": str(self.atoms)} }, f"HexifiedDestination{{0x02{self.pub_key_hex}}}" ]}
 
+@dataclass
+class Balances:
+    coins: str
+    tokens: dict
+
+class NewTxResult(TypedDict):
+    tx_id: str
+    tx: str
+    fees: Balances
+    broadcasted: bool
 
 @dataclass
 class PoolData:
@@ -295,30 +305,30 @@ async def issue_new_token(self,
         else:
             return None, result['error']
 
-    async def mint_tokens(self, token_id: str, address: str, amount: int) -> str:
+    async def mint_tokens(self, token_id: str, address: str, amount: int) -> NewTxResult:
         return self._write_command("token_mint", [self.account, token_id, address, {'decimal': str(amount)}, {'in_top_x_mb': 5}])['result']
 
     # Note: unlike mint_tokens, this function behaves identically both for wallet_cli_controller and wallet_rpc_controller.
     async def mint_tokens_or_fail(self, token_id: str, address: str, amount: int):
         # self.mint_tokens already fails on error
         await self.mint_tokens(token_id, address, amount)
 
-    async def unmint_tokens(self, token_id: str, amount: int) -> str:
+    async def unmint_tokens(self, token_id: str, amount: int) -> NewTxResult:
         return self._write_command("token_unmint", [self.account, token_id, {'decimal': str(amount)}, {'in_top_x_mb': 5}])['result']
 
-    async def lock_token_supply(self, token_id: str) -> str:
+    async def lock_token_supply(self, token_id: str) -> NewTxResult:
         return self._write_command("token_lock_supply", [self.account, token_id, {'in_top_x_mb': 5}])['result']
 
-    async def freeze_token(self, token_id: str, is_unfreezable: str) -> str:
+    async def freeze_token(self, token_id: str, is_unfreezable: str) -> NewTxResult:
         return self._write_command("token_freeze", [self.account, token_id, is_unfreezable, {'in_top_x_mb': 5}])['result']
 
-    async def unfreeze_token(self, token_id: str) -> str:
+    async def unfreeze_token(self, token_id: str) -> NewTxResult:
         return self._write_command("token_unfreeze", [self.account, token_id, {'in_top_x_mb': 5}])['result']
 
-    async def change_token_authority(self, token_id: str, new_authority: str) -> str:
+    async def change_token_authority(self, token_id: str, new_authority: str) -> NewTxResult:
         return self._write_command("token_change_authority", [self.account, token_id, new_authority, {'in_top_x_mb': 5}])['result']
 
-    async def change_token_metadata_uri(self, token_id: str, new_metadata_uri: str) -> str:
+    async def change_token_metadata_uri(self, token_id: str, new_metadata_uri: str) -> NewTxResult:
         return self._write_command("token_change_metadata_uri", [self.account, token_id, new_metadata_uri, {'in_top_x_mb': 5}])['result']
 
     async def issue_new_nft(self,
@@ -571,7 +581,7 @@ async def create_htlc_transaction(self,
                          secret_hash: str,
                          spend_address: str,
                          refund_address: str,
-                         refund_lock_for_blocks: int) -> str:
+                         refund_lock_for_blocks: int) -> NewTxResult:
         timelock = { "type": "ForBlockCount", "content": refund_lock_for_blocks }
         htlc = { "secret_hash": secret_hash, "spend_address": spend_address, "refund_address": refund_address, "refund_timelock": timelock }
         object = [self.account, {'decimal': str(amount)}, token_id, htlc, {'in_top_x_mb': 5}]

test/functional/wallet_htlc_refund.py

@@ -128,7 +128,7 @@ async def async_test(self):
             assert_equal(await wallet.get_best_block(), block_id)
 
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 151", balance)
+            assert_in("Coins amount: 151", balance)
             assert_not_in("Tokens", balance)
 
             # issue a valid token
@@ -142,7 +142,7 @@ async def async_test(self):
             self.generate_block()
             assert_in("Success", await wallet.sync())
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 50", balance)
+            assert_in("Coins amount: 50", balance)
             assert_not_in("Tokens", balance)
 
             amount_to_mint = random.randint(1, 10000)
@@ -153,7 +153,7 @@ async def async_test(self):
             assert_in("Success", await wallet.sync())
             balance = await wallet.get_balance()
             print(balance)
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_in(f"Token: {token_id} amount: {amount_to_mint}", balance)
 
             ########################################################################################
@@ -165,7 +165,7 @@ async def async_test(self):
 
             alice_amount_to_swap = amount_to_mint
             alice_htlc_tx = await wallet.create_htlc_transaction(alice_amount_to_swap, token_id, alice_secret_hash, bob_address, refund_address, 6)
-            alice_signed_tx_obj = signed_tx_obj.decode(ScaleBytes("0x" + alice_htlc_tx))
+            alice_signed_tx_obj = signed_tx_obj.decode(ScaleBytes("0x" + alice_htlc_tx['tx']))
             alice_htlc_outputs = alice_signed_tx_obj['transaction']['outputs']
             alice_htlc_change_dest = alice_htlc_outputs[1]['Transfer'][1]
             alice_htlc_tx_id = hash_object(base_tx_obj, alice_signed_tx_obj['transaction'])
@@ -200,7 +200,7 @@ async def async_test(self):
 
             bob_amount_to_swap = 150
             bob_htlc_tx = await wallet.create_htlc_transaction(bob_amount_to_swap, None, alice_secret_hash, alice_address, refund_address, 6)
-            bob_signed_tx_obj = signed_tx_obj.decode(ScaleBytes("0x" + bob_htlc_tx))
+            bob_signed_tx_obj = signed_tx_obj.decode(ScaleBytes("0x" + bob_htlc_tx['tx']))
             bob_htlc_outputs = bob_signed_tx_obj['transaction']['outputs']
             bob_htlc_change_dest = bob_htlc_outputs[1]['Transfer'][1]
             bob_htlc_tx_id = hash_object(base_tx_obj, bob_signed_tx_obj['transaction'])
@@ -227,7 +227,7 @@ async def async_test(self):
             alice_refund_ptx = output.split('\n')[2]
 
             # Alice's htlc tx can now be broadcasted
-            output = await wallet.submit_transaction(alice_htlc_tx)
+            output = await wallet.submit_transaction(alice_htlc_tx['tx'])
             assert_in("The transaction was submitted successfully", output)
 
             # Alice signs Bob's refund
@@ -238,22 +238,22 @@ async def async_test(self):
             bob_refund_ptx = output.split('\n')[2]
 
             # Bob's htlc tx can now be broadcasted
-            output = await wallet.submit_transaction(bob_htlc_tx)
+            output = await wallet.submit_transaction(bob_htlc_tx['tx'])
             assert_in("The transaction was submitted successfully", output)
 
             self.generate_block()
             assert_in("Success", await wallet.sync())
 
             # Check Alice's balance
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_not_in("Tokens", balance)
 
             # Check Bob's balance now
             await self.switch_to_wallet(wallet, 'bob_wallet')
             assert_in("Success", await wallet.sync())
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_not_in("Tokens", balance)
 
             ########################################################################################
@@ -270,7 +270,7 @@ async def async_test(self):
             assert_in("Spending at height 9, locked until height 10", output)
 
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_not_in("Tokens", balance)
 
             # Bob signs and spends the refund
@@ -286,7 +286,7 @@ async def async_test(self):
             assert_in("Spending at height 9, locked until height 10", output)
 
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_not_in("Tokens", balance)
 
             ########################################################################################
@@ -304,7 +304,7 @@ async def async_test(self):
             self.generate_block()
             assert_in("Success", await wallet.sync())
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_not_in("Tokens", balance)
 
             self.generate_block()
@@ -316,13 +316,13 @@ async def async_test(self):
             await self.switch_to_wallet(wallet, 'alice_wallet')
             assert_in("Success", await wallet.sync())
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_in(f"Token: {token_id} amount: {alice_amount_to_swap}", balance)
 
             await self.switch_to_wallet(wallet, 'bob_wallet')
             assert_in("Success", await wallet.sync())
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 150", balance)
+            assert_in(f"Coins amount: {bob_amount_to_swap}", balance)
             assert_not_in("Tokens", balance)
 
 

test/functional/wallet_htlc_spend.py

@@ -131,7 +131,7 @@ async def async_test(self):
             assert_equal(await wallet.get_best_block(), block_id)
 
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 151", balance)
+            assert_in("Coins amount: 151", balance)
             assert_not_in("Tokens", balance)
 
             # issue a valid token
@@ -142,7 +142,7 @@ async def async_test(self):
             self.generate_block()
             assert_in("Success", await wallet.sync())
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 50", balance)
+            assert_in("Coins amount: 50", balance)
             assert_not_in("Tokens", balance)
 
             amount_to_mint = random.randint(1, 10000)
@@ -152,7 +152,7 @@ async def async_test(self):
             self.generate_block()
             assert_in("Success", await wallet.sync())
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_in(f"Token: {token_id} amount: {amount_to_mint}", balance)
 
             ########################################################################################
@@ -164,7 +164,7 @@ async def async_test(self):
             alice_amount_to_swap = amount_to_mint
             refund_address = await wallet.add_standalone_multisig_address(2, [alice_pub_key, bob_pub_key], None)
             alice_htlc_tx = await wallet.create_htlc_transaction(alice_amount_to_swap, token_id, alice_secret_hash, bob_address, refund_address, 2)
-            output = await wallet.submit_transaction(alice_htlc_tx)
+            output = await wallet.submit_transaction(alice_htlc_tx['tx'])
             alice_htlc_tx_id = output.split('\n')[2]
             self.generate_block()
             assert_in("Success", await wallet.sync())
@@ -175,7 +175,7 @@ async def async_test(self):
 
             bob_amount_to_swap = 150
             bob_htlc_tx = await wallet.create_htlc_transaction(bob_amount_to_swap, None, alice_secret_hash, alice_address, refund_address, 2)
-            output = await wallet.submit_transaction(bob_htlc_tx)
+            output = await wallet.submit_transaction(bob_htlc_tx['tx'])
             bob_htlc_tx_id = output.split('\n')[2]
             self.generate_block()
             assert_in("Success", await wallet.sync())
@@ -189,7 +189,7 @@ async def async_test(self):
             random_secret_hex = random_secret.hex()
 
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_not_in("Tokens", balance)
 
             # Alice can't spend Alice's htlc without a secret
@@ -214,7 +214,7 @@ async def async_test(self):
             assert_in("Success", await wallet.sync())
 
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_not_in("Tokens", balance)
 
             # Bob can't spend it without secret
@@ -264,7 +264,7 @@ async def async_test(self):
             assert_in("Success", await wallet.sync())
 
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 150", balance)
+            assert_in(f"Coins amount: {bob_amount_to_swap}", balance)
             assert_not_in("Tokens", balance)
 
             ########################################################################################
@@ -283,7 +283,7 @@ async def async_test(self):
             assert_in("Success", await wallet.sync())
 
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             assert_in(f"Token: {token_id} amount: {alice_amount_to_swap}", balance)
 
 

test/functional/wallet_sweep_address.py

@@ -149,14 +149,14 @@ def make_locked_output(pub_key_bytes):
             acc1_address = await wallet.new_address()
 
             await wallet.select_account(0)
-            assert_in("The transaction was submitted successfully", await wallet.sweep_addresses(acc1_address, addresses))
+            assert_in("The transaction was submitted successfully", await wallet.sweep_addresses(acc1_address, all_addresses=True))
 
             block_id = self.generate_block()
             assert_in("Success", await wallet.sync())
 
             # check we sent all our coins
             balance = await wallet.get_balance()
-            assert_in(f"Coins amount: 0", balance)
+            assert_in("Coins amount: 0", balance)
             # check we still have the locked balance
 
             balance = await wallet.get_balance('locked')

wallet/src/account/mod.rs

@@ -507,7 +507,7 @@ impl<K: AccountKeyChains> Account<K> {
     pub fn sweep_addresses(
         &mut self,
         destination: Destination,
-        request: SendRequest,
+        mut request: SendRequest,
         current_fee_rate: FeeRate,
     ) -> WalletResult<SendRequest> {
         let mut grouped_inputs = group_preselected_inputs(
@@ -566,6 +566,7 @@ impl<K: AccountKeyChains> Account<K> {
             destination,
         );
         outputs.push(coin_output);
+        request.add_fee(Currency::Coin, total_fee)?;
 
         Ok(request.with_outputs(outputs))
     }

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

@@ -131,14 +131,17 @@ where
 
     pub fn new_tx_command(new_tx: RpcNewTransaction, chain_config: &ChainConfig) -> ConsoleCommand {
         let status_text = if new_tx.broadcasted {
-            let summary = new_tx.tx.take().transaction().text_summary(chain_config);
+            let mut summary = new_tx.tx.take().transaction().text_summary(chain_config);
+            format_fees(&mut summary, &new_tx.fees);
+
             format!(
                 "{summary}\nThe transaction was submitted successfully with ID:\n{}",
                 id_to_hex_string(*new_tx.tx_id.as_hash())
             )
         } else {
             let hex = new_tx.tx.to_string();
-            let summary = new_tx.tx.take().transaction().text_summary(chain_config);
+            let mut summary = new_tx.tx.take().transaction().text_summary(chain_config);
+            format_fees(&mut summary, &new_tx.fees);
 
             format!("{summary}\nThe transaction was created and is ready to be submitted:\n{hex}",)
         };
@@ -805,7 +808,7 @@ where
             }
 
             WalletCommand::ConfigBroadcast { broadcast } => {
-                self.config.broadcast_to_mempool = broadcast;
+                self.config.broadcast_to_mempool = broadcast.to_bool();
                 Ok(ConsoleCommand::Print(format!(
                     "Broadcast to Mempool set to: {broadcast:?}"
                 )))
@@ -1430,6 +1433,7 @@ where
                         selected_account,
                         destination_address,
                         addresses,
+                        all,
                         self.config,
                     )
                     .await?;

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

@@ -309,7 +309,10 @@ pub enum WalletCommand {
     ///
     /// The effect of this is not preserved when the CLI wallet is closed.
     #[clap(name = "config-broadcast")]
-    ConfigBroadcast { broadcast: bool },
+    ConfigBroadcast {
+        #[arg(value_enum)]
+        broadcast: YesNo,
+    },
 
     #[clap(name = "account-create")]
     CreateNewAccount { name: Option<String> },

wallet/wallet-controller/src/synced_controller.rs

@@ -68,7 +68,7 @@ use wallet_types::{
 use crate::{
     helpers::{fetch_token_info, fetch_utxo, into_balances, tx_to_partially_signed_tx},
     runtime_wallet::RuntimeWallet,
-    types::{Balances, GenericCurrencyTransfer, NewTransaction},
+    types::{Balances, GenericCurrencyTransfer, NewTransaction, SweepFromAddresses},
     ControllerConfig, ControllerError,
 };
 
@@ -568,7 +568,7 @@ where
     pub async fn sweep_addresses(
         &mut self,
         destination_address: Destination,
-        from_addresses: BTreeSet<Destination>,
+        from_addresses: SweepFromAddresses,
     ) -> Result<NewTransaction, ControllerError<T>> {
         let selected_utxos = self.wallet.get_utxos(
             self.account_index,
@@ -584,7 +584,7 @@ where
             .into_iter()
             .filter(|(_, output)| {
                 get_tx_output_destination(output, &|_| None, HtlcSpendingCondition::Skip)
-                    .is_some_and(|dest| from_addresses.is_empty() || from_addresses.contains(&dest))
+                    .is_some_and(|dest| from_addresses.should_sweep_address(&dest))
             })
             .collect::<Vec<_>>();