feat(wallet-init): add wallets command

- add wallets command
- add warning for using priv descriptors
- update readme
- add loading network from config

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 `wallets` command to list all wallets saved configs
 
 ## [2.0.0]
 

README.md

@@ -203,41 +203,43 @@ cargo run --pretty -n signet wallet -w {wallet_name} -d sqlite balance
 ```
 This is available for wallet, key, repl and compile features. When ommitted, outputs default to `JSON`.
 
-## Initializing Wallet Configurations with `init` Subcommand
+## Saving and using wallet configurations
 
-The `wallet init` sub-command simplifies wallet operations by saving configuration parameters to `config.toml` in the data directory (default `~/.bdk-bitcoin/config.toml`). This allows you to run subsequent `bdk-cli wallet` commands without repeatedly specifying configuration details, easing wallet operations.
+The `wallet config` sub-command allows you to save wallet settings to a `config.toml` file in the default directory (`~/.bdk-bitcoin/`) or custom directory specified with the `--datadir` flag. This eliminate the need to repeatedly specify descriptors, client types, and other parameters for each command. Once configured, you can use any wallet command by simply specifying the wallet name. All other parameters are automatically loaded from the saved configuration.
 
-To initialize a wallet configuration, use the following command structure:
+To save a wallet settings:
 
 ```shell
-cargo run --features <list-of-features> -- -n <network> wallet --wallet <wallet_name> --ext-descriptor <ext_descriptor> --int-descriptor <int_descriptor>  --client-type <client_type>  --url <server_url> [--database-type <database_type>] [--rpc-user <rpc_user>]
-  [--rpc-password <rpc_password>] init
+cargo run --features <list-of-features> -- -n <network> wallet --wallet <wallet_name> config [ -f ] --ext-descriptor <ext_descriptor> --int-descriptor <int_descriptor>  --client-type <client_type>  --url <server_url> [--database-type <database_type>] [--rpc-user <rpc_user>]
+  [--rpc-password <rpc_password>] 
 ```
 
 For example, to initialize a wallet named `my_wallet` with `electrum` as the backend on `signet` network:
 
 ```shell
-cargo run --features electrum -- -n signet wallet -w my_wallet -e "tr(tprv8Z.../0/*)#dtdqk3dx" -i "tr(tprv8Z.../1/*)#ulgptya7" -d sqlite -c electrum -u "ssl://mempool.space:60602" init
+cargo run --features electrum -- -n signet wallet -w my_wallet config -e "tr(tprv8Z.../0/*)#dtdqk3dx" -i "tr(tprv8Z.../1/*)#ulgptya7" -d sqlite -c electrum -u "ssl://mempool.space:60602"
 ```
 
-To overwrite an existing wallet configuration, use the  `--force` flag after the `init` sub-command.
+To overwrite an existing wallet configuration, use the  `--force` flag after the `config` sub-command.
 
-You can omit the following arguments to use their default values:
+#### Using a Configured Wallet
 
-`network`: Defaults to `testnet`
+Once configured, use any wallet command with just the wallet name:
 
-`database_type`: Defaults to `sqlite`
-
-#### Using Saved Configuration
-
-After a wallet is initialized, you can then run `bdk-cli` wallet commands without specifying the parameters, referencing only the wallet subcommand.
-
-For example, with the wallet `my_wallet` initialized, generate a new address and sync the wallet as follow:
 
 ```shell
-cargo run wallet -w my_wallet --use-config new_address
+cargo run --features electrum wallet -w my_wallet  new_address
 
-cargo run --features electrum wallet -w my_wallet --use-config sync
+cargo run --features electrum wallet -w my_wallet full_scan
 ```
 
 Note that each wallet has its own configuration, allowing multiple wallets with different configurations.
+
+#### View all saved Wallet Configs
+
+To view all saved wallet configurations:
+
+```shell
+cargo run wallets`
+```
+You can also use the `--pretty` flag for a formatted output.

src/commands.rs

@@ -108,10 +108,9 @@ 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,
     },
+    /// List all saved wallet configurations.
+    Wallets,
 }
 
 /// Wallet operation subcommands.

src/config.rs

@@ -90,6 +90,7 @@ impl WalletConfig {
             "testnet" => Network::Testnet,
             "regtest" => Network::Regtest,
             "signet" => Network::Signet,
+            "testnet4" => Network::Testnet4,
             _ => {
                 return Err(Error::Generic("Invalid network".to_string()));
             }
@@ -105,7 +106,6 @@ impl WalletConfig {
                 return Err(Error::Generic("Invalid database type".to_string()));
             }
         };
-
         #[cfg(any(
             feature = "electrum",
             feature = "esplora",
@@ -144,9 +144,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
@@ -161,10 +161,7 @@ impl WalletConfig {
             #[cfg(feature = "rpc")]
             cookie: wallet_config.cookie.clone(),
             #[cfg(feature = "cbf")]
-            compactfilter_opts: crate::commands::CompactFilterOpts {
-                conn_count: 2,
-                skip_blocks: None,
-            },
+            compactfilter_opts: crate::commands::CompactFilterOpts { conn_count: 2 },
         })
     }
 }

src/handlers.rs

@@ -859,6 +859,35 @@ pub fn handle_config_subcommand(
     wallet_opts: &WalletOpts,
     force: bool,
 ) -> Result<String, Error> {
+    if network == Network::Bitcoin {
+        eprintln!(
+            "WARNING: You are configuring a wallet for Bitcoin MAINNET.\n\
+             This software is experimental and not recommended for use with real funds.\n\
+             Consider using a testnet for testing purposes. \n"
+        );
+    }
+
+    let ext_descriptor = wallet_opts.ext_descriptor.clone();
+    let int_descriptor = wallet_opts.int_descriptor.clone();
+
+    if ext_descriptor.contains("xprv") || ext_descriptor.contains("tprv") {
+        eprintln!(
+            "WARNING: Your external descriptor contains PRIVATE KEYS.\n\
+             Private keys will be saved in PLAINTEXT in the config file.\n\
+             This is a security risk. Consider using public descriptors instead."
+        );
+    }
+
+    if let Some(ref internal_desc) = int_descriptor {
+        if internal_desc.contains("xprv") || internal_desc.contains("tprv") {
+            eprintln!(
+                "WARNING: Your internal descriptor contains PRIVATE KEYS.\n\
+                 Private keys will be saved in PLAINTEXT in the config file.\n\
+                 This is a security risk. Consider using public descriptors instead."
+            );
+        }
+    }
+
     let mut config = WalletConfig::load(datadir)?.unwrap_or(WalletConfig {
         network,
         wallets: HashMap::new(),
@@ -870,8 +899,6 @@ pub fn handle_config_subcommand(
         )));
     }
 
-    let ext_descriptor = wallet_opts.ext_descriptor.clone();
-    let int_descriptor = wallet_opts.int_descriptor.clone();
     #[cfg(any(
         feature = "electrum",
         feature = "esplora",
@@ -1143,9 +1170,141 @@ pub(crate) fn handle_compile_subcommand(
     }
 }
 
+/// Handle wallets command to show all saved wallet configurations
+pub fn handle_wallets_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;
     let pretty = cli_opts.pretty;
     let subcommand = cli_opts.subcommand.clone();
 
@@ -1162,9 +1321,8 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
         } => {
             let home_dir = prepare_home_dir(cli_opts.datadir)?;
 
-            let config = WalletConfig::load(&home_dir)?
-                .ok_or(Error::Generic("No config found".to_string()))?;
-            let wallet_opts = config.get_wallet_opts(&wallet)?;
+            let (wallet_opts, network) = load_wallet_config(&home_dir, &wallet)?;
+
             let database_path = prepare_wallet_db_dir(&home_dir, &wallet)?;
 
             #[cfg(any(feature = "sqlite", feature = "redb"))]
@@ -1220,13 +1378,10 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
             wallet: wallet_name,
             subcommand: WalletSubCommand::OfflineWalletSubCommand(offline_subcommand),
         } => {
-            let network = cli_opts.network;
             let datadir = cli_opts.datadir.clone();
             let home_dir = prepare_home_dir(datadir)?;
-            let config = WalletConfig::load(&home_dir)?.ok_or(Error::Generic(format!(
-                "No config found for wallet '{wallet_name}'"
-            )))?;
-            let wallet_opts = config.get_wallet_opts(&wallet_name)?;
+            let (wallet_opts, network) = load_wallet_config(&home_dir, &wallet_name)?;
+
             #[cfg(any(feature = "sqlite", feature = "redb"))]
             let result = {
                 let mut persister: Persister = match &wallet_opts.database_type {
@@ -1281,9 +1436,15 @@ 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::Wallets => {
+            let home_dir = prepare_home_dir(cli_opts.datadir)?;
+            let result = handle_wallets_subcommand(&home_dir, pretty)?;
+            Ok(result)
+        }
         CliSubCommand::Key {
             subcommand: key_subcommand,
         } => {
+            let network = cli_opts.network;
             let result = handle_key_subcommand(network, key_subcommand, pretty)?;
             Ok(result)
         }
@@ -1292,27 +1453,20 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
             policy,
             script_type,
         } => {
+            let network = cli_opts.network;
             let result = handle_compile_subcommand(network, policy, script_type, pretty)?;
             Ok(result)
         }
         #[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 {}",
-                wallet_name.clone()
-            )))?;
-            let loaded_wallet_opts = config.get_wallet_opts(&wallet_name)?;
+            let (wallet_opts, network) = load_wallet_config(&home_dir, &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)?;
@@ -1331,7 +1485,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")))]