Group up Software and Trezor args in separate subcommands

Author: OBorce

node-gui/backend/src/backend_impl.rs

@@ -550,7 +550,7 @@ impl Backend {
                             handles_client,
                             file_path.clone(),
                             wallet_events,
-                            Some(HardwareWalletType::Trezor),
+                            Some(HardwareWalletType::Trezor { device_id: None }),
                         )
                         .await?;
 
@@ -626,7 +626,6 @@ impl Backend {
                 false,
                 ScanBlockchain::ScanNoWait,
                 hardware_wallet,
-                None,
             )
             .await
             .map_err(|err| BackendError::WalletError(err.to_string()))?;

test/functional/test_framework/wallet_cli_controller.py

@@ -166,17 +166,17 @@ async def _write_command(self, cmd: str, can_be_empty: bool = False) -> str:
     async def create_wallet(self, name: str = "wallet", mnemonic: Optional[str] = None) -> str:
         wallet_file = os.path.join(self.node.datadir, name)
         mnemonic_str = "" if mnemonic is None else f'"{mnemonic}"'
-        return await self._write_command(f"wallet-create \"{wallet_file}\" store-seed-phrase {mnemonic_str}\n")
+        return await self._write_command(f"wallet-create software \"{wallet_file}\" store-seed-phrase {mnemonic_str}\n")
 
     async def open_wallet(self, name: str, password: Optional[str] = None, force_change_wallet_type: bool = False) -> str:
         password_str = password if password else ""
         force_change_wallet_type_str = "--force-change-wallet-type" if force_change_wallet_type else ""
         wallet_file = os.path.join(self.node.datadir, name)
-        return await self._write_command(f"wallet-open \"{wallet_file}\" {password_str} {force_change_wallet_type_str}\n")
+        return await self._write_command(f"wallet-open software \"{wallet_file}\" {password_str} {force_change_wallet_type_str}\n")
 
     async def recover_wallet(self, mnemonic: str, name: str = "recovered_wallet") -> str:
         wallet_file = os.path.join(self.node.datadir, name)
-        return await self._write_command(f"wallet-recover \"{wallet_file}\" store-seed-phrase \"{mnemonic}\"\n")
+        return await self._write_command(f"wallet-recover software \"{wallet_file}\" store-seed-phrase \"{mnemonic}\"\n")
 
     async def close_wallet(self) -> str:
         return await self._write_command("wallet-close\n")

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

@@ -33,25 +33,20 @@ use node_comm::node_traits::NodeInterface;
 use serialization::{hex::HexEncode, hex_encoded::HexEncoded};
 use utils::qrcode::{QrCode, QrCodeError};
 use wallet::version::get_version;
-use wallet_controller::types::{GenericTokenTransfer, WalletTypeArgs};
+use wallet_controller::types::GenericTokenTransfer;
 use wallet_rpc_client::wallet_rpc_traits::{PartialOrSignedTx, WalletInterface};
-use wallet_rpc_lib::{
-    cmdline::CliHardwareWalletType,
-    types::{
-        Balances, ComposedTransaction, ControllerConfig, MnemonicInfo, NewTransaction, NftMetadata,
-        RpcInspectTransaction, RpcSignatureStats, RpcSignatureStatus, RpcStandaloneAddressDetails,
-        RpcValidatedSignatures, TokenMetadata,
-    },
+use wallet_rpc_lib::types::{
+    Balances, ComposedTransaction, ControllerConfig, HardwareWalletType, MnemonicInfo,
+    NewTransaction, NftMetadata, RpcInspectTransaction, RpcSignatureStats, RpcSignatureStatus,
+    RpcStandaloneAddressDetails, RpcValidatedSignatures, TokenMetadata,
 };
 
-use wallet_types::{
-    partially_signed_transaction::PartiallySignedTransaction, seed_phrase::StoreSeedPhrase,
-};
+use wallet_types::partially_signed_transaction::PartiallySignedTransaction;
 
 use crate::{
     errors::WalletCliCommandError, helper_types::parse_generic_token_transfer,
     CreateWalletDeviceSelectMenu, ManageableWalletCommand, OpenWalletDeviceSelectMenu,
-    WalletManagementCommand,
+    OpenWalletSubCommand, WalletManagementCommand,
 };
 
 use self::local_state::WalletWithState;
@@ -150,36 +145,17 @@ where
         WalletCliCommandError<N>: From<E>,
     {
         match command {
-            WalletManagementCommand::CreateWallet {
-                wallet_path,
-                mnemonic,
-                whether_to_store_seed_phrase,
-                passphrase,
-                hardware_wallet,
-                trezor_device_id,
-            } => {
-                let store_seed_phrase =
-                    whether_to_store_seed_phrase.map_or(StoreSeedPhrase::DoNotStore, Into::into);
-                let wallet_args = hardware_wallet.map_or(
-                    WalletTypeArgs::Software {
-                        mnemonic,
-                        passphrase,
-                        store_seed_phrase,
-                    },
-                    |h| h.into_wallet_args(trezor_device_id),
-                );
+            WalletManagementCommand::CreateWallet { wallet } => {
+                let (wallet_path, wallet_args) = wallet.into_path_and_wallet_args();
+
                 let response =
                     self.wallet().await?.create_wallet(wallet_path.clone(), wallet_args).await?;
 
                 if let Some(devices) = response.multiple_devices_available {
                     match devices {
                         wallet_rpc_lib::types::MultipleDevicesAvailable::Trezor { devices } => {
-                            let choices = CreateWalletDeviceSelectMenu::new(
-                                devices,
-                                wallet_path,
-                                CliHardwareWalletType::Trezor,
-                                false,
-                            );
+                            let choices =
+                                CreateWalletDeviceSelectMenu::new(devices, wallet_path, false);
                             return Ok(ConsoleCommand::ChoiceMenu(Box::new(choices)));
                         }
                     }
@@ -208,38 +184,17 @@ where
                 })
             }
 
-            WalletManagementCommand::RecoverWallet {
-                wallet_path,
-                mnemonic,
-                whether_to_store_seed_phrase,
-                passphrase,
-                hardware_wallet,
-                trezor_device_id,
-            } => {
-                let hardware_wallet = hardware_wallet.map(Into::into);
+            WalletManagementCommand::RecoverWallet { wallet } => {
+                let (wallet_path, wallet_args) = wallet.into_path_and_wallet_args();
 
-                let response = self
-                    .wallet()
-                    .await?
-                    .recover_wallet(
-                        wallet_path.clone(),
-                        whether_to_store_seed_phrase.is_some_and(|x| x.to_bool()),
-                        mnemonic,
-                        passphrase,
-                        hardware_wallet,
-                        trezor_device_id,
-                    )
-                    .await?;
+                let response =
+                    self.wallet().await?.recover_wallet(wallet_path.clone(), wallet_args).await?;
 
                 if let Some(devices) = response.multiple_devices_available {
                     match devices {
                         wallet_rpc_lib::types::MultipleDevicesAvailable::Trezor { devices } => {
-                            let choices = CreateWalletDeviceSelectMenu::new(
-                                devices,
-                                wallet_path,
-                                CliHardwareWalletType::Trezor,
-                                true,
-                            );
+                            let choices =
+                                CreateWalletDeviceSelectMenu::new(devices, wallet_path, true);
                             return Ok(ConsoleCommand::ChoiceMenu(Box::new(choices)));
                         }
                     }
@@ -255,14 +210,31 @@ where
                 })
             }
 
-            WalletManagementCommand::OpenWallet {
-                wallet_path,
-                encryption_password,
-                force_change_wallet_type,
-                hardware_wallet,
-                trezor_device_id,
-            } => {
-                let hardware_wallet = hardware_wallet.map(Into::into);
+            WalletManagementCommand::OpenWallet { wallet } => {
+                let (wallet_path, encryption_password, force_change_wallet_type, hardware_wallet) =
+                    match wallet {
+                        OpenWalletSubCommand::Software {
+                            wallet_path,
+                            encryption_password,
+                            force_change_wallet_type,
+                        } => (
+                            wallet_path,
+                            encryption_password,
+                            force_change_wallet_type,
+                            None,
+                        ),
+                        OpenWalletSubCommand::Trezor {
+                            wallet_path,
+                            encryption_password,
+                            device_id,
+                        } => (
+                            wallet_path,
+                            encryption_password,
+                            false,
+                            Some(HardwareWalletType::Trezor { device_id }),
+                        ),
+                    };
+
                 let response = self
                     .wallet()
                     .await?
@@ -271,7 +243,6 @@ where
                         encryption_password.clone(),
                         Some(force_change_wallet_type),
                         hardware_wallet,
-                        trezor_device_id,
                     )
                     .await?;
 
@@ -288,8 +259,6 @@ where
                                 devices,
                                 wallet_path,
                                 encryption_password,
-                                force_change_wallet_type,
-                                CliHardwareWalletType::Trezor,
                             );
                             return Ok(ConsoleCommand::ChoiceMenu(Box::new(choices)));
                         }