Merge pull request #1900 from mintlayer/feature/wallet-show-change-address

Add option to list change addresses in the wallet

Author: OBorce

node-gui/backend/src/backend_impl.rs

@@ -223,7 +223,7 @@ impl Backend {
             .flatten();
 
         let addresses = controller
-            .get_issued_addresses(account_index)
+            .get_issued_addresses(account_index, false)
             .await
             .map_err(|e| BackendError::WalletError(e.to_string()))?
             .into_iter()
@@ -1244,7 +1244,7 @@ impl Backend {
                     }
                 };
 
-                match controller.get_issued_addresses(account_id.account_index()).await {
+                match controller.get_issued_addresses(account_id.account_index(), false).await {
                     Ok(addresses) => {
                         for info in addresses {
                             Self::send_event(

test/functional/test_framework/wallet_cli_controller.py

@@ -430,14 +430,14 @@ async def submit_transaction(self, transaction: str, do_not_store: bool = False)
 
     async def list_pool_ids(self) -> List[PoolData]:
         output = await self._write_command("staking-list-pools\n", can_be_empty=True)
-        self.log.info(f"pools: {output}");
+        self.log.info(f"pools: {output}")
         pattern = r"Pool Id: ([a-zA-Z0-9]+), Pledge: (\d+[.]?\d+), Balance: (\d+[.]?\d+), Creation Block Height: (\d+), Creation block timestamp: (\d+), Staker: ([a-zA-Z0-9]+), Decommission Key: ([a-zA-Z0-9]+), VRF Public Key: ([a-zA-Z0-9]+)"
         matches = re.findall(pattern, output)
         return [PoolData(pool_id, pledge, balance, int(height), timestamp, staker, decommission_key, vrf_public_key) for pool_id, pledge, balance, height, timestamp, staker, decommission_key, vrf_public_key in matches]
 
     async def list_pools_for_decommission(self) -> List[PoolData]:
         output = await self._write_command("staking-list-owned-pools-for-decommission\n", can_be_empty=True)
-        self.log.info(f"pools: {output}");
+        self.log.info(f"pools: {output}")
         pattern = r"Pool Id: ([a-zA-Z0-9]+), Pledge: (\d+[.]?\d+), Balance: (\d+[.]?\d+), Creation Block Height: (\d+), Creation block timestamp: (\d+), Staker: ([a-zA-Z0-9]+), Decommission Key: ([a-zA-Z0-9]+), VRF Public Key: ([a-zA-Z0-9]+)"
         matches = re.findall(pattern, output)
         return [PoolData(pool_id, pledge, balance, int(height), timestamp, staker, decommission_key, vrf_public_key) for pool_id, pledge, balance, height, timestamp, staker, decommission_key, vrf_public_key in matches]
@@ -477,15 +477,15 @@ async def rescan(self) -> str:
         return await self._write_command("wallet-rescan\n")
 
     async def start_staking(self) -> str:
-        return await self._write_command(f"staking-start\n")
+        return await self._write_command("staking-start\n")
 
     async def stop_staking(self) -> str:
-        return await self._write_command(f"staking-stop\n")
+        return await self._write_command("staking-stop\n")
 
     async def staking_status(self) -> str:
-        return await self._write_command(f"staking-status\n")
+        return await self._write_command("staking-status\n")
 
-    async def generate_block(self, transactions: [str]) -> str:
+    async def generate_block(self, transactions: List[str]) -> str:
         return await self._write_command(f"generate-block {transactions}\n")
 
     async def get_standalone_addresses(self) -> str:
@@ -494,8 +494,9 @@ async def get_standalone_addresses(self) -> str:
     async def get_standalone_address_details(self, address: str) -> str:
         return await self._write_command(f"standalone-address-details {address}\n")
 
-    async def get_addresses_usage(self) -> str:
-        return await self._write_command("address-show\n")
+    async def get_addresses_usage(self, with_change: bool = False) -> str:
+        include_change = "--include-change" if with_change else ""
+        return await self._write_command(f"address-show {include_change}\n")
 
     async def get_vrf_addresses_usage(self) -> str:
         return await self._write_command("staking-show-vrf-public-keys\n")
@@ -515,7 +516,7 @@ async def get_balance(self, with_locked: str = 'unlocked', utxo_states: List[str
         return await self._write_command(f"account-balance {with_locked} {' '.join(utxo_states)}\n")
 
     async def list_pending_transactions(self) -> List[str]:
-        output = await self._write_command(f"transaction-list-pending\n")
+        output = await self._write_command("transaction-list-pending\n")
         pattern = r'Id<Transaction>\{([^}]*)\}'
         return re.findall(pattern, output)
 

test/functional/test_framework/wallet_rpc_controller.py

@@ -238,14 +238,14 @@ async def reveal_public_key_as_hex(self, address: Optional[str] = None) -> str:
         return self._write_command("address_reveal_public_key", [self.account, address])['result']['public_key_hex']
 
     async def new_address(self) -> str:
-        return self._write_command(f"address_new", [self.account])['result']['address']
+        return self._write_command("address_new", [self.account])['result']['address']
 
     async def add_standalone_multisig_address(self, min_required_signatures: int, pub_keys: List[str], label: Optional[str] = None) -> str:
         return self._write_command("standalone_add_multisig", [self.account, min_required_signatures, pub_keys, label, None])['result']
 
     async def list_utxos(self, utxo_types: str = '', with_locked: str = '', utxo_states: List[str] = []) -> List[UtxoOutpoint]:
         outputs = self._write_command("account_utxos", [self.account, utxo_types, with_locked, ''.join(utxo_states)])['result']
-        return [UtxoOutpoint(tx_id=match["outpoint"]["source_id"]["content"]['tx_id'], index=int(match["outpoint"]['index'])) for match in outputs]
+        return [UtxoOutpoint(id=match["outpoint"]["source_id"]["content"]['tx_id'], index=int(match["outpoint"]['index'])) for match in outputs]
 
     async def get_transaction(self, tx_id: str) -> str:
         return self._write_command("transaction_get", [self.account, tx_id])['result']
@@ -270,12 +270,12 @@ async def issue_new_token(self,
                               number_of_decimals: int,
                               metadata_uri: str,
                               destination_address: str,
-                              token_supply: Optional[int] = None,
+                              token_supply_fixed: Optional[int] = None,
                               is_freezable: bool = True):
-        if token_supply is None:
+        if token_supply_fixed is None:
             token_supply = { "type": "Lockable" }
         else:
-            token_supply = { "type": "Fixed", "content": {'decimal': str(token_supply)} }
+            token_supply = { "type": "Fixed", "content": {'decimal': str(token_supply_fixed)} }
 
         result = self._write_command('token_issue_new', [
             self.account,
@@ -375,7 +375,7 @@ async def decommission_stake_pool(self, pool_id: str, address: str) -> str:
         return "The transaction was submitted successfully"
 
     async def submit_transaction(self, transaction: str, do_not_store: bool = False) -> str:
-        result = self._write_command(f"node_submit_transaction", [transaction, do_not_store, {}])
+        result = self._write_command("node_submit_transaction", [transaction, do_not_store, {}])
         if 'result' in result:
             return f"The transaction was submitted successfully\n\n{result['result']['tx_id']}"
         else:
@@ -397,7 +397,7 @@ async def create_delegation(self, address: str, pool_id: str) -> Optional[str]:
         return self._write_command("delegation_create", [self.account, address, pool_id, {'in_top_x_mb': 5}])['result']['delegation_id']
 
     async def stake_delegation(self, amount: int, delegation_id: str) -> str:
-        self._write_command(f"delegation_stake", [self.account, {'decimal': str(amount)}, delegation_id, {'in_top_x_mb': 5}])['result']
+        self._write_command("delegation_stake", [self.account, {'decimal': str(amount)}, delegation_id, {'in_top_x_mb': 5}])['result']
         return "Success"
 
     async def list_delegation_ids(self) -> List[DelegationData]:
@@ -412,22 +412,22 @@ async def sync(self) -> str:
         return "Success"
 
     async def start_staking(self) -> str:
-        self._write_command(f"staking_start", [self.account])['result']
+        self._write_command("staking_start", [self.account])['result']
         return "Staking started successfully"
 
     async def stop_staking(self) -> str:
-        self._write_command(f"staking_stop", [self.account])['result']
+        self._write_command("staking_stop", [self.account])['result']
         return "Success"
 
     async def staking_status(self) -> str:
-        result = self._write_command(f"staking_status", [self.account])['result']
+        result = self._write_command("staking_status", [self.account])['result']
         if result == "Staking":
             return "Staking"
         else:
             return "Not staking"
 
-    async def get_addresses_usage(self) -> str:
-        return self._write_command("address_show", [self.account])['result']
+    async def get_addresses_usage(self, with_change: bool = False) -> str:
+        return self._write_command("address_show", [self.account, with_change])['result']
 
     async def get_balance(self, with_locked: str = 'unlocked', utxo_states: List[str] = ['confirmed']) -> str:
         with_locked = with_locked.capitalize()