feat(wallet): add initializing wallet config

- move init subcommand to use existing walletopts
- add --use-config to use saved config
- add fetching required params before clap parsing

Author: tvpeter

CHANGELOG.md

@@ -8,7 +8,8 @@ page. See [DEVELOPMENT_CYCLE.md](DEVELOPMENT_CYCLE.md) for more details.
 - Removed MSRV and bumped Rust Edition to 2024
 - Add `--pretty` top level flag for formatting commands output in a tabular format
 - Updated `bdk_wallet ` to  `2.1.0`,  `bdk_bitcoind_rpc` to `0.21.0`, `bdk_esplora` to `0.22.1`, `bdk_kyoto` to `0.13.1` 
-- Add wallet configs initialization for initialiazing and saving wallet configs
+- Add wallet subcommand `init` to save wallet configs
+- Add an optional flag `--use-config` to use saved configs for a wallet
 
 ## [1.0.0]
 

README.md

@@ -203,24 +203,24 @@ 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 `bdk-cli wallet init`
+## Initializing Wallet Configurations with `init` Subcommand
 
-The `bdk-cli wallet init` command simplifies wallet setup 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 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.
 
 To initialize a wallet configuration, use the following command structure:
 
 ```shell
-cargo run --features <list-of-features> -- -n <network> wallet init --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>]
+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
 ```
 
 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 init -w my_wallet -e "tr(tprv8Z.../0/*)#dtdqk3dx" -i "tr(tprv8Z.../1/*)#ulgptya7" -d sqlite -c electrum -u "ssl://mempool.space:60602"
+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
 ```
 
-To overwrite an existing wallet configuration, use the  `--force` flag at the end of the command.
+To overwrite an existing wallet configuration, use the  `--force` flag after the `init` sub-command.
 
 You can omit the following arguments to use their default values:
 
@@ -235,12 +235,9 @@ After a wallet is initialized, you can then run `bdk-cli` wallet commands withou
 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 new_address
+cargo run wallet -w my_wallet --use-config new_address
 
-cargo run --features electrum wallet -w my_wallet sync
+cargo run --features electrum wallet -w my_wallet --use-config sync
 ```
 
 Note that each wallet has its own configuration, allowing multiple wallets with different configurations.
-
-* Each wallet has its own configuration, allowing multiple wallets with different settings (e.g., different descriptors or backends). 
-* You can override saved configuration values for a single command by specifying them explicitly (e.g., `--client-type esplora` or `--url https://mempool.space/signet/api`).

src/commands.rs

@@ -117,8 +117,6 @@ pub enum CliSubCommand {
 pub enum WalletSubCommand {
     /// Initialize a wallet configuration and save to `config.toml`.
     Init {
-        #[command(flatten)]
-        wallet_opts: WalletOpts,
         /// Overwrite existing wallet configuration if it exists.
         #[arg(long = "force", default_value_t = false)]
         force: bool,
@@ -184,15 +182,15 @@ pub struct WalletOpts {
         feature = "rpc",
         feature = "cbf"
     ))]
-    #[arg(env = "CLIENT_TYPE", short = 'c', long, value_enum)]
-    pub client_type: Option<ClientType>,
+    #[arg(env = "CLIENT_TYPE", short = 'c', long, value_enum, required=true)]
+    pub client_type: ClientType,
     #[cfg(any(feature = "sqlite", feature = "redb"))]
-    #[arg(env = "DATABASE_TYPE", short = 'd', long, value_enum)]
-    pub database_type: Option<DatabaseType>,
+    #[arg(env = "DATABASE_TYPE", short = 'd', long, value_enum, required=true)]
+    pub database_type: DatabaseType,
     /// Sets the server url.
     #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
-    #[arg(env = "SERVER_URL", short = 'u', long)]
-    pub url: Option<String>,
+    #[arg(env = "SERVER_URL", short = 'u', long, required=true)]
+    pub url: String,
     /// Electrum batch size.
     #[cfg(feature = "electrum")]
     #[arg(env = "ELECTRUM_BATCH_SIZE", short = 'b', long, default_value = "10")]
@@ -215,7 +213,7 @@ pub struct WalletOpts {
         value_parser = parse_proxy_auth,
         default_value = "user:password",
     )]
-    pub basic_auth: Option<(String, String)>,
+    pub basic_auth: (String, String),
     #[cfg(feature = "rpc")]
     /// Sets an optional cookie authentication.
     #[arg(env = "COOKIE")]
@@ -226,56 +224,48 @@ pub struct WalletOpts {
 }
 
 impl WalletOpts {
-    /// Load configuration from TOML file and merge with CLI options
+    /// Merges optional configuration values from config.toml into the current WalletOpts.
     pub fn load_config(&mut self, wallet_name: &str, datadir: &Path) -> Result<(), Error> {
         if let Some(config) = WalletConfig::load(datadir)? {
             if let Ok(config_opts) = config.get_wallet_opts(wallet_name) {
-                self.wallet = self.wallet.take().or(config_opts.wallet);
                 self.verbose = self.verbose || config_opts.verbose;
-                self.ext_descriptor = self.ext_descriptor.take().or(config_opts.ext_descriptor);
-                self.int_descriptor = self.int_descriptor.take().or(config_opts.int_descriptor);
-                #[cfg(any(
-                    feature = "electrum",
-                    feature = "esplora",
-                    feature = "rpc",
-                    feature = "cbf"
-                ))]
-                {
-                    self.client_type = self.client_type.clone().or(config_opts.client_type);
-                }
-                #[cfg(any(feature = "sqlite", feature = "redb"))]
-                {
-                    // prioritizing the config.toml value for database type as it has a default value
-                    self.database_type = config_opts.database_type.or(self.database_type.clone());
-                }
-                #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
-                {
-                    self.url = self.url.take().or(config_opts.url);
-                }
                 #[cfg(feature = "electrum")]
                 {
                     self.batch_size = if self.batch_size != 10 {
-                        config_opts.batch_size
-                    } else {
                         self.batch_size
+                    } else {
+                        config_opts.batch_size
                     };
                 }
                 #[cfg(feature = "esplora")]
                 {
                     self.parallel_requests = if self.parallel_requests != 5 {
-                        config_opts.parallel_requests
-                    } else {
                         self.parallel_requests
+                    } else {
+                        config_opts.parallel_requests
                     };
                 }
                 #[cfg(feature = "rpc")]
                 {
-                    self.basic_auth = self.basic_auth.take().or(config_opts.basic_auth);
+                    self.basic_auth = if self.basic_auth != ("user".into(), "password".into()) {
+                        self.basic_auth.clone()
+                    } else {
+                        config_opts.basic_auth
+                    };
                     self.cookie = self.cookie.take().or(config_opts.cookie);
                 }
                 #[cfg(feature = "cbf")]
                 {
-                    self.compactfilter_opts = config_opts.compactfilter_opts;
+                    if self.compactfilter_opts.conn_count == 2
+                        && config_opts.compactfilter_opts.conn_count != 2
+                    {
+                        self.compactfilter_opts.conn_count =
+                            config_opts.compactfilter_opts.conn_count;
+                    }
+                    if self.compactfilter_opts.skip_blocks.is_none() {
+                        self.compactfilter_opts.skip_blocks =
+                            config_opts.compactfilter_opts.skip_blocks;
+                    }
                 }
             }
         }

src/config.rs

@@ -23,11 +23,11 @@ pub struct WalletConfig {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct WalletConfigInner {
-    pub name: String,
+    pub wallet: String,
     pub network: String,
     pub ext_descriptor: String,
-    pub int_descriptor: String,
-    #[cfg(feature = "sqlite")]
+    pub int_descriptor: Option<String>,
+    #[cfg(any(feature = "sqlite", feature = "redb"))]
     pub database_type: String,
     #[cfg(any(
         feature = "electrum",
@@ -39,9 +39,15 @@ pub struct WalletConfigInner {
     #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
     pub server_url: Option<String>,
     #[cfg(feature = "rpc")]
-    pub rpc_user: String,
+    pub rpc_user: Option<String>,
     #[cfg(feature = "rpc")]
-    pub rpc_password: String,
+    pub rpc_password: Option<String>,
+    #[cfg(feature = "electrum")]
+    pub batch_size: Option<usize>,
+    #[cfg(feature = "esplora")]
+    pub parallel_requests: Option<usize>,
+    #[cfg(feature = "rpc")]
+    pub cookie: Option<String>,
 }
 
 impl WalletConfig {
@@ -85,21 +91,18 @@ impl WalletConfig {
             "regtest" => Network::Regtest,
             "signet" => Network::Signet,
             _ => {
-                return Err(Error::Generic(format!(
-                    "Invalid network: {network}",
-                    network = wallet_config.network
-                )));
+                return Err(Error::Generic("Invalid network".to_string()));
             }
         };
 
-        #[cfg(feature = "sqlite")]
+        #[cfg(any(feature = "sqlite", feature = "redb"))]
         let database_type = match wallet_config.database_type.as_str() {
+            #[cfg(feature = "sqlite")]
             "sqlite" => DatabaseType::Sqlite,
+            #[cfg(feature = "redb")]
+            "redb" => DatabaseType::Redb,
             _ => {
-                return Err(Error::Generic(format!(
-                    "Invalid database type: {database_type}",
-                    database_type = wallet_config.database_type
-                )));
+                return Err(Error::Generic("Invalid database type".to_string()));
             }
         };
 
@@ -111,44 +114,52 @@ impl WalletConfig {
         ))]
         let client_type = match wallet_config.client_type.as_deref() {
             #[cfg(feature = "electrum")]
-            Some("electrum") => Some(ClientType::Electrum),
+            Some("electrum") => ClientType::Electrum,
             #[cfg(feature = "esplora")]
-            Some("esplora") => Some(ClientType::Esplora),
+            Some("esplora") => ClientType::Esplora,
             #[cfg(feature = "rpc")]
-            Some("rpc") => Some(ClientType::Rpc),
+            Some("rpc") => ClientType::Rpc,
             #[cfg(feature = "cbf")]
-            Some("cbf") => Some(ClientType::Cbf),
-            Some(other) => return Err(Error::Generic(format!("Invalid client type: {other}"))),
-            None => None,
+            Some("cbf") => ClientType::Cbf,
+            _ => return Err(Error::Generic(format!("Invalid client type"))),
         };
 
         Ok(WalletOpts {
-            wallet: Some(wallet_config.name.clone()),
+            wallet: Some(wallet_config.wallet.clone()),
             verbose: false,
             ext_descriptor: Some(wallet_config.ext_descriptor.clone()),
-            int_descriptor: Some(wallet_config.int_descriptor.clone()),
+            int_descriptor: wallet_config.int_descriptor.clone(),
             #[cfg(any(
                 feature = "electrum",
                 feature = "esplora",
                 feature = "rpc",
                 feature = "cbf"
             ))]
             client_type,
-            #[cfg(feature = "sqlite")]
-            database_type: Some(database_type),
+            #[cfg(any(feature = "sqlite", feature = "redb"))]
+            database_type,
             #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
-            url: wallet_config.server_url.clone(),
+            url: wallet_config
+                .server_url
+                .clone()
+                .ok_or_else(|| Error::Generic(format!("Server url not found")))?,
             #[cfg(feature = "electrum")]
             batch_size: 10,
             #[cfg(feature = "esplora")]
             parallel_requests: 5,
             #[cfg(feature = "rpc")]
-            basic_auth: Some((
-                wallet_config.rpc_user.clone(),
-                wallet_config.rpc_password.clone(),
-            )),
+            basic_auth: (
+                wallet_config
+                    .rpc_user
+                    .clone()
+                    .unwrap_or_else(|| "user".into()),
+                wallet_config
+                    .rpc_password
+                    .clone()
+                    .unwrap_or_else(|| "password".into()),
+            ),
             #[cfg(feature = "rpc")]
-            cookie: None,
+            cookie: wallet_config.cookie.clone(),
             #[cfg(feature = "cbf")]
             compactfilter_opts: crate::commands::CompactFilterOpts {
                 conn_count: 2,