feat(wallet-init): add list command

Author: tvpeter

CHANGELOG.md

@@ -4,8 +4,8 @@ Changelog info is also documented on the [GitHub releases](https://github.com/bi
 page. See [DEVELOPMENT_CYCLE.md](DEVELOPMENT_CYCLE.md) for more details.
 
 ## [Unreleased]
-- Add wallet configs initialization for initialiazing and saving wallet configs
 - Add wallet subcommand `config` to save wallet configs
+- Add wallet subcommand `list` to display saved configs
 
 ## [2.0.0]
 

src/commands.rs

@@ -108,9 +108,6 @@ pub enum CliSubCommand {
         /// Wallet name for this REPL session
         #[arg(env = "WALLET_NAME", short = 'w', long = "wallet", required = true)]
         wallet: String,
-
-        #[command(flatten)]
-        wallet_opts: WalletOpts,
     },
 }
 
@@ -136,6 +133,8 @@ pub enum WalletSubCommand {
     OnlineWalletSubCommand(OnlineWalletSubCommand),
     #[command(flatten)]
     OfflineWalletSubCommand(OfflineWalletSubCommand),
+    /// List all saved wallet configurations.
+    List,
 }
 
 #[derive(Clone, ValueEnum, Debug, Eq, PartialEq)]

src/config.rs

@@ -105,7 +105,6 @@ impl WalletConfig {
                 return Err(Error::Generic("Invalid database type".to_string()));
             }
         };
-
         #[cfg(any(
             feature = "electrum",
             feature = "esplora",
@@ -144,9 +143,9 @@ impl WalletConfig {
                 .clone()
                 .ok_or_else(|| Error::Generic(format!("Server url not found")))?,
             #[cfg(feature = "electrum")]
-            batch_size: 10,
+            batch_size: wallet_config.batch_size.unwrap_or(10),
             #[cfg(feature = "esplora")]
-            parallel_requests: 5,
+            parallel_requests: wallet_config.parallel_requests.unwrap_or(5),
             #[cfg(feature = "rpc")]
             basic_auth: (
                 wallet_config

src/handlers.rs

@@ -1160,6 +1160,139 @@ pub(crate) fn handle_compile_subcommand(
     }
 }
 
+/// Handle list subcommand to show all saved wallet configurations
+pub fn handle_list_subcommand(datadir: &Path, pretty: bool) -> Result<String, Error> {
+    let load_config = WalletConfig::load(datadir)?;
+
+    let config = match load_config {
+        Some(c) if !c.wallets.is_empty() => c,
+        _ => {
+            return Ok(if pretty {
+                "No wallet configurations found.".to_string()
+            } else {
+                serde_json::to_string_pretty(&json!({
+                    "wallets": []
+                }))?
+            });
+        }
+    };
+
+    if pretty {
+        let mut rows: Vec<Vec<CellStruct>> = vec![];
+
+        for (name, wallet_config) in config.wallets.iter() {
+            let mut row = vec![name.cell(), wallet_config.network.clone().cell()];
+
+            #[cfg(any(feature = "sqlite", feature = "redb"))]
+            row.push(wallet_config.database_type.clone().cell());
+
+            #[cfg(any(
+                feature = "electrum",
+                feature = "esplora",
+                feature = "rpc",
+                feature = "cbf"
+            ))]
+            {
+                let client_str = wallet_config.client_type.as_deref().unwrap_or("N/A");
+                row.push(client_str.cell());
+            }
+
+            #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
+            {
+                let url_str = wallet_config.server_url.as_deref().unwrap_or("N/A");
+                let display_url = if url_str.len() > 20 {
+                    shorten(url_str, 15, 10)
+                } else {
+                    url_str.to_string()
+                };
+                row.push(display_url.cell());
+            }
+
+            let ext_desc_display = if wallet_config.ext_descriptor.len() > 40 {
+                shorten(&wallet_config.ext_descriptor, 20, 15)
+            } else {
+                wallet_config.ext_descriptor.clone()
+            };
+            row.push(ext_desc_display.cell());
+
+            let has_int_desc = if wallet_config.int_descriptor.is_some() {
+                "Yes"
+            } else {
+                "No"
+            };
+            row.push(has_int_desc.cell());
+
+            rows.push(row);
+        }
+
+        let mut title_cells = vec!["Wallet Name".cell().bold(true), "Network".cell().bold(true)];
+
+        #[cfg(any(feature = "sqlite", feature = "redb"))]
+        title_cells.push("Database".cell().bold(true));
+
+        #[cfg(any(
+            feature = "electrum",
+            feature = "esplora",
+            feature = "rpc",
+            feature = "cbf"
+        ))]
+        title_cells.push("Client".cell().bold(true));
+
+        #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
+        title_cells.push("Server URL".cell().bold(true));
+
+        title_cells.push("External Desc".cell().bold(true));
+        title_cells.push("Internal Desc".cell().bold(true));
+
+        let table = rows
+            .table()
+            .title(title_cells)
+            .display()
+            .map_err(|e| Error::Generic(e.to_string()))?;
+
+        Ok(format!("{table}"))
+    } else {
+        let wallets_summary: Vec<_> = config
+            .wallets
+            .iter()
+            .map(|(name, wallet_config)| {
+                let mut wallet_json = json!({
+                    "name": name,
+                    "network": wallet_config.network,
+                    "ext_descriptor": wallet_config.ext_descriptor,
+                    "int_descriptor": wallet_config.int_descriptor,
+                });
+
+                #[cfg(any(feature = "sqlite", feature = "redb"))]
+                {
+                    wallet_json["database_type"] = json!(wallet_config.database_type.clone());
+                }
+
+                #[cfg(any(
+                    feature = "electrum",
+                    feature = "esplora",
+                    feature = "rpc",
+                    feature = "cbf"
+                ))]
+                {
+                    wallet_json["client_type"] = json!(wallet_config.client_type.clone());
+                }
+
+                #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
+                {
+                    wallet_json["server_url"] = json!(wallet_config.server_url.clone());
+                }
+
+                wallet_json
+            })
+            .collect();
+
+        Ok(serde_json::to_string_pretty(&json!({
+            "wallets": wallets_summary
+        }))?)
+    }
+}
+
 /// The global top level handler.
 pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
     let network = cli_opts.network;
@@ -1298,6 +1431,14 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
             let result = handle_config_subcommand(&home_dir, network, wallet, &wallet_opts, force)?;
             Ok(result)
         }
+        CliSubCommand::Wallet {
+            wallet: _,
+            subcommand: WalletSubCommand::List,
+        } => {
+            let home_dir = prepare_home_dir(cli_opts.datadir)?;
+            let result = handle_list_subcommand(&home_dir, pretty)?;
+            Ok(result)
+        }
         CliSubCommand::Key {
             subcommand: key_subcommand,
         } => {
@@ -1315,21 +1456,19 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
         #[cfg(feature = "repl")]
         CliSubCommand::Repl {
             wallet: wallet_name,
-            mut wallet_opts,
         } => {
             let network = cli_opts.network;
             let home_dir = prepare_home_dir(cli_opts.datadir.clone())?;
-            wallet_opts.wallet = Some(wallet_name.clone());
 
             let config = WalletConfig::load(&home_dir)?.ok_or(Error::Generic(format!(
-                "No config found for wallet {}",
+                "No config found for wallet {}, please run 'config' command first.",
                 wallet_name.clone()
             )))?;
-            let loaded_wallet_opts = config.get_wallet_opts(&wallet_name)?;
+            let wallet_opts = config.get_wallet_opts(&wallet_name)?;
 
             #[cfg(any(feature = "sqlite", feature = "redb"))]
             let (mut wallet, mut persister) = {
-                let mut persister: Persister = match &loaded_wallet_opts.database_type {
+                let mut persister: Persister = match &wallet_opts.database_type {
                     #[cfg(feature = "sqlite")]
                     DatabaseType::Sqlite => {
                         let database_path = prepare_wallet_db_dir(&home_dir, &wallet_name)?;
@@ -1348,7 +1487,7 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
                         Persister::RedbStore(store)
                     }
                 };
-                let wallet = new_persisted_wallet(network, &mut persister, &loaded_wallet_opts)?;
+                let wallet = new_persisted_wallet(network, &mut persister, &wallet_opts)?;
                 (wallet, persister)
             };
             #[cfg(not(any(feature = "sqlite", feature = "redb")))]
@@ -1448,6 +1587,13 @@ async fn respond(
             .map_err(|e| e.to_string())?;
             Some(value)
         }
+        ReplSubCommand::Wallet {
+            subcommand: WalletSubCommand::List,
+        } => {
+            let value =
+                handle_list_subcommand(&_datadir, cli_opts.pretty).map_err(|e| e.to_string())?;
+            Some(value)
+        }
         ReplSubCommand::Key { subcommand } => {
             let value = handle_key_subcommand(network, subcommand, cli_opts.pretty)
                 .map_err(|e| e.to_string())?;