feat(wallet): add initializing wallet config

- update wallet initialization to use `bdk-cli
wallet init` command directly and read walletopts
- update README for how to use the bdk-cli wallet
init command
- fix clippy warnings
- update CHANGELOG

[Issue: #192]

Author: tvpeter

CHANGELOG.md

@@ -6,6 +6,7 @@ page. See [DEVELOPMENT_CYCLE.md](DEVELOPMENT_CYCLE.md) for more details.
 ## [Unreleased]
 
 - Removed MSRV and bumped Rust Edition to 2024
+- Add wallet configs initialization for initialiazing and saving wallet configs
 
 ## [1.0.0]
 

Justfile

@@ -100,30 +100,3 @@ descriptors private wallet=default_wallet:
 [group('rpc')]
 rpc command wallet=default_wallet:
     bitcoin-cli -datadir={{default_datadir}} -regtest -rpcwallet={{wallet}} -rpcuser={{rpc_user}} -rpcpassword={{rpc_password}} {{command}}
-
-[group('wallet')]
-init wallet_name ext_descriptor int_descriptor client_type url database_type='sqlite' rpc_user='user' rpc_password='password' force='false':
-    mkdir -p {{default_datadir}}
-    # Check if wallet configuration exists
-    if [ "{{force}}" = "false" ] && grep -Fx "[wallets.{{wallet_name}}]" {{default_datadir}}/config.toml > /dev/null; then \
-        echo "Error: Wallet '{{wallet_name}}' already configured in {{default_datadir}}/config.toml. Use --force to overwrite."; \
-        exit 1; \
-    fi
-    # Remove existing configuration if --force is true
-    if [ "{{force}}" = "true" ] && grep -Fx "[wallets.{{wallet_name}}]" {{default_datadir}}/config.toml > /dev/null; then \
-        sed -i.bak '/^\[wallets\.{{wallet_name}}\]/,/^\[/d' {{default_datadir}}/config.toml; \
-        sed -i.bak '/^\[wallets\.{{wallet_name}}\]/d' {{default_datadir}}/config.toml; \
-        rm {{default_datadir}}/config.toml.bak; \
-    fi
-    # Append new configuration
-    echo "" >> {{default_datadir}}/config.toml || touch {{default_datadir}}/config.toml
-    echo "[wallets.{{wallet_name}}]" >> {{default_datadir}}/config.toml
-    echo "name = \"{{wallet_name}}\"" >> {{default_datadir}}/config.toml
-    echo "ext_descriptor = \"{{ext_descriptor}}\"" >> {{default_datadir}}/config.toml
-    echo "int_descriptor = \"{{int_descriptor}}\"" >> {{default_datadir}}/config.toml
-    echo "database_type = \"sqlite\"" >> {{default_datadir}}/config.toml
-    echo "client_type = \"{{client_type}}\"" >> {{default_datadir}}/config.toml
-    echo "server_url = \"{{url}}\"" >> {{default_datadir}}/config.toml
-    echo "rpc_user = \"{{rpc_user}}\"" >> {{default_datadir}}/config.toml
-    echo "rpc_password = \"{{rpc_password}}\"" >> {{default_datadir}}/config.toml
-    echo "Wallet configuration for {{wallet_name}} added to {{default_datadir}}/config.toml"

README.md

@@ -194,68 +194,45 @@ Note: You can modify the `Justfile` to reflect your nodes' configuration values.
    cargo run --features rpc -- wallet -u "127.0.0.1:18443" -c rpc -a user:password balance
    ```
 
-### Initializing a Wallet with `just`
+### Initializing Wallet Configurations with `bdk-cli wallet init`
 
-When using `bdk-cli`, repeatedly specifying parameter values for each command can be tedious. The `just` command allows you to initialize a wallet with configuration values once, saving them for reuse in subsequent `bdk-cli` commands. 
-This eliminate the need to provide repetitive arguments. To set up a wallet with persistent configuration values, use the following just command:
+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.
 
-```shell
-just init <wallet_name> <ext_descriptor> <int_descriptor> <database_type> <client_type> <url> <rpc_user> <rpc_password> [--force]
-```
-The arguments must be provided in the order shown above. Replace each placeholder with the corresponding value:
-
-> * `wallet_name`: The unique name for your wallet (e.g., my_wallet)
-> * `ext_descriptor`: The external descriptor for generating receiving addresses (e.g., tr(tprv.../0/*)#checksum)
-> * `int_descriptor`: The internal descriptor for generating change addresses (e.g., tr(tprv.../1/*)#checksum)
-> * `database_type`: The database type for wallet persistence (e.g., sqlite). Defaults to `sqlite` if omitted
-> * `client_type`: The blockchain backend (e.g., electrum, esplora, rpc, cbf)
-> * `url`: The server URL for the blockchain backend (e.g., ssl://mempool.space:60602 for Electrum).
-> * `rpc_user`: The RPC username for rpc client type (e.g., user). Defaults to user if omitted.
-> * `rpc_password`: The RPC password for rpc client type (e.g., password). Defaults to password if omitted.
-> * `--force`: Optional. Overwrites existing configuration for the specified <wallet_name> if set. By default, `just init` fails if the wallet config values already exists.
-
-#### Example
-
-To initialize a wallet named `my_wallet` with `electrum` as the backend:
+To initialize a wallet configuration, use the following command structure:
 
 ```shell
-just init my_wallet "tr(tprv8Z.../0/*)#dtdqk3dx" "tr(tprv8Z.../1/*)#ulgptya7" sqlite electrum "ssl://mempool.space:60602" user password
+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>]
 ```
 
-To overwrite an existing wallet configuration:
+For example, to initialize a wallet named `my_wallet` with `electrum` as the backend on `signet` network:
 
 ```shell
-just init-wallet my_wallet "tr(tprv8Z.../0/*)#dtdqk3dx" "tr(tprv8Z.../1/*)#ulgptya7" sqlite electrum "ssl://mempool.space:60602" user password --force
+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"
 ```
 
-You can omit the following arguments to use their default values:
+To overwrite an existing wallet configuration, use the  `--force` flag at the end of the command.
 
-`database_type`: Defaults to sqlite.
-`rpc_user`: Defaults to user.
-`rpc_password`: Defaults to password.
+You can omit the following arguments to use their default values:
 
-For example, to initialize a wallet with default database_type, rpc_user, and rpc_password:
+`network`: Defaults to `testnet`
 
-```shell
-just init-wallet my_wallet "tr(tprv8Z.../0/*)#dtdqk3dx" "tr(tprv8Z.../1/*)#ulgptya7" electrum "ssl://mempool.space:60602"
-```
+`database_type`: Defaults to `sqlite`
 
 #### Using Saved Configuration
 
-After initializing a wallet with `just init`, the configuration is saved in `~/.bdk-bitcoin/config.toml`. You can then run `bdk-cli` wallet commands without specifying the parameters, referencing only the wallet name and network.
+After a wallet is initialized, you can then run `bdk-cli` wallet commands without specifying the parameters, referencing only the wallet subcommand.
 
-With the wallet `my_wallet` initialized, generate a new address and sync the wallet as follow:
+For example, with the wallet `my_wallet` initialized, generate a new address and sync the wallet as follow:
 
 ```shell
-cargo run --features electrum,sqlite -- -n signet wallet -w my_wallet new_address
+cargo run wallet -w my_wallet new_address
 
-cargo run --features electrum,sqlite -- -n signet wallet -w my_wallet sync
+cargo run --features electrum wallet -w my_wallet sync
 ```
 
-#### Notes:
+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`).
 
 ## Minimum Supported Rust Version (MSRV)
 

src/commands.rs

@@ -20,7 +20,7 @@ use bdk_wallet::bitcoin::{
     Address, Network, OutPoint, ScriptBuf,
     bip32::{DerivationPath, Xpriv},
 };
-use clap::{value_parser, Args, Parser, Subcommand, ValueEnum};
+use clap::{Args, Parser, Subcommand, ValueEnum, value_parser};
 use std::path::Path;
 
 #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
@@ -112,6 +112,14 @@ pub enum CliSubCommand {
 /// Wallet operation subcommands.
 #[derive(Debug, Subcommand, Clone, PartialEq)]
 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,
+    },
     #[cfg(any(
         feature = "electrum",
         feature = "esplora",
@@ -173,13 +181,7 @@ pub struct WalletOpts {
     #[arg(env = "CLIENT_TYPE", short = 'c', long, value_enum)]
     pub client_type: Option<ClientType>,
     #[cfg(feature = "sqlite")]
-    #[arg(
-        env = "DATABASE_TYPE",
-        short = 'd',
-        long,
-        value_enum,
-        default_value = "sqlite"
-    )]
+    #[arg(env = "DATABASE_TYPE", short = 'd', long, value_enum)]
     pub database_type: Option<DatabaseType>,
     /// Sets the server url.
     #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]

src/config.rs

@@ -5,38 +5,39 @@
     feature = "cbf"
 ))]
 use crate::commands::ClientType;
-use crate::commands::{DatabaseType, WalletOpts};
+#[cfg(feature = "sqlite")]
+use crate::commands::DatabaseType;
+use crate::commands::WalletOpts;
 use crate::error::BDKCliError as Error;
-use serde::Deserialize;
+use bdk_wallet::bitcoin::Network;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
 use std::path::Path;
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct WalletConfig {
+    pub network: Network,
     pub wallets: HashMap<String, WalletConfigInner>,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct WalletConfigInner {
     pub name: String,
+    pub network: String,
     pub ext_descriptor: String,
     pub int_descriptor: String,
+    #[cfg(feature = "sqlite")]
     pub database_type: String,
     #[cfg(any(
         feature = "electrum",
         feature = "esplora",
         feature = "rpc",
         feature = "cbf"
     ))]
-    pub client_type: String,
-    #[cfg(any(
-        feature = "electrum",
-        feature = "esplora",
-        feature = "rpc",
-        feature = "cbf"
-    ))]
-    pub server_url: String,
+    pub client_type: Option<String>,
+    #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
+    pub server_url: Option<String>,
     #[cfg(feature = "rpc")]
     pub rpc_user: String,
     #[cfg(feature = "rpc")]
@@ -51,27 +52,54 @@ impl WalletConfig {
             return Ok(None);
         }
         let config_content = fs::read_to_string(&config_path)
-            .map_err(|e| Error::Generic(format!("Failed to read config file: {}", e)))?;
+            .map_err(|e| Error::Generic(format!("Failed to read config file: {e}")))?;
         let config: WalletConfig = toml::from_str(&config_content)
-            .map_err(|e| Error::Generic(format!("Failed to parse config file: {}", e)))?;
+            .map_err(|e| Error::Generic(format!("Failed to parse config file: {e}")))?;
         Ok(Some(config))
     }
 
+    /// Save configuration to a TOML file
+    pub fn save(&self, datadir: &Path) -> Result<(), Error> {
+        let config_path = datadir.join("config.toml");
+        let config_content = toml::to_string_pretty(self)
+            .map_err(|e| Error::Generic(format!("Failed to serialize config: {e}")))?;
+        fs::create_dir_all(datadir)
+            .map_err(|e| Error::Generic(format!("Failed to create directory {datadir:?}: {e}")))?;
+        fs::write(&config_path, config_content).map_err(|e| {
+            Error::Generic(format!("Failed to write config file {config_path:?}: {e}"))
+        })?;
+        log::debug!("Saved config to {config_path:?}");
+        Ok(())
+    }
+
     /// Get config for a wallet
     pub fn get_wallet_opts(&self, wallet_name: &str) -> Result<WalletOpts, Error> {
         let wallet_config = self
             .wallets
             .get(wallet_name)
-            .ok_or_else(|| Error::Generic(format!("Wallet {} not found in config", wallet_name)))?;
+            .ok_or_else(|| Error::Generic(format!("Wallet {wallet_name} not found in config")))?;
+
+        let _network = match wallet_config.network.as_str() {
+            "bitcoin" => Network::Bitcoin,
+            "testnet" => Network::Testnet,
+            "regtest" => Network::Regtest,
+            "signet" => Network::Signet,
+            _ => {
+                return Err(Error::Generic(format!(
+                    "Invalid network: {network}",
+                    network = wallet_config.network
+                )));
+            }
+        };
 
         #[cfg(feature = "sqlite")]
         let database_type = match wallet_config.database_type.as_str() {
             "sqlite" => DatabaseType::Sqlite,
             _ => {
                 return Err(Error::Generic(format!(
-                    "Invalid database type: {}",
-                    wallet_config.database_type
-                )))
+                    "Invalid database type: {database_type}",
+                    database_type = wallet_config.database_type
+                )));
             }
         };
 
@@ -81,21 +109,17 @@ impl WalletConfig {
             feature = "rpc",
             feature = "cbf"
         ))]
-        let client_type = match wallet_config.client_type.as_str() {
+        let client_type = match wallet_config.client_type.as_deref() {
             #[cfg(feature = "electrum")]
-            "electrum" => ClientType::Electrum,
+            Some("electrum") => Some(ClientType::Electrum),
             #[cfg(feature = "esplora")]
-            "esplora" => ClientType::Esplora,
+            Some("esplora") => Some(ClientType::Esplora),
             #[cfg(feature = "rpc")]
-            "rpc" => ClientType::Rpc,
+            Some("rpc") => Some(ClientType::Rpc),
             #[cfg(feature = "cbf")]
-            "cbf" => ClientType::Cbf,
-            _ => {
-                return Err(Error::Generic(format!(
-                    "Invalid client type: {}",
-                    wallet_config.client_type
-                )))
-            }
+            Some("cbf") => Some(ClientType::Cbf),
+            Some(other) => return Err(Error::Generic(format!("Invalid client type: {other}"))),
+            None => None,
         };
 
         Ok(WalletOpts {
@@ -109,11 +133,11 @@ impl WalletConfig {
                 feature = "rpc",
                 feature = "cbf"
             ))]
-            client_type: Some(client_type),
+            client_type,
             #[cfg(feature = "sqlite")]
             database_type: Some(database_type),
             #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
-            url: Some(wallet_config.server_url.clone()),
+            url: wallet_config.server_url.clone(),
             #[cfg(feature = "electrum")]
             batch_size: 10,
             #[cfg(feature = "esplora")]