refactor(main): add runtime wallet module

- add wallet runtime module to serve as context
manager

Author: tvpeter

src/client.rs

@@ -1,5 +1,7 @@
 #[cfg(feature = "rpc")]
-use bdk_bitcoind_rpc::{Emitter, bitcoincore_rpc::RpcApi};
+use {bdk_bitcoind_rpc::{Emitter, bitcoincore_rpc::RpcApi},
+    bdk_wallet::chain::CanonicalizationParams,
+};
 #[cfg(feature = "esplora")]
 use bdk_esplora::EsploraAsyncExt;
 #[cfg(any(
@@ -14,7 +16,6 @@ use {
     bdk_wallet::{
         Wallet,
         bitcoin::{Transaction, Txid},
-        chain::CanonicalizationParams,
     },
     clap::ValueEnum,
     std::path::PathBuf,
@@ -79,7 +80,7 @@ pub(crate) enum BlockchainClient {
 impl BlockchainClient {
     pub async fn broadcast(&self, tx: Transaction) -> Result<Txid, Error> {
         match self {
-            // #[cfg(feature = "electrum")]
+            #[cfg(feature = "electrum")]
             Self::Electrum { client, .. } => client
                 .transaction_broadcast(&tx)
                 .map_err(|e| Error::Generic(e.to_string())),

src/handlers/mod.rs

@@ -102,12 +102,6 @@ pub trait AppCommand<C> {
 ))]
 pub trait AsyncAppCommand<C> {
     type Output: FormatOutput;
-    
+
     async fn execute(&self, ctx: &mut C) -> Result<Self::Output, Error>;
 }
-
-// context for online and online
-// => cli.rs
-// handlers/{mod for commands}
-// wallet subdir /
-// wallet-offline and wallet-online (client mod)

src/handlers/online.rs

@@ -170,7 +170,9 @@ impl AsyncAppCommand<AppContext<OnlineOperations<'_>>> for FullScanCommand {
                 sync_kyoto_client(wallet, client).await?;
             }
         }
-        Ok(StatusResult::new("Full scan completed successfully."))
+        Ok(StatusResult {
+            message: "Full scan completed successfully.".to_string(),
+        })
     }
 }
 
@@ -190,7 +192,7 @@ impl AsyncAppCommand<AppContext<OnlineOperations<'_>>> for SyncCommand {
         &self,
         ctx: &mut AppContext<OnlineOperations<'_>>,
     ) -> Result<Self::Output, Error> {
-        let mut wallet = &mut ctx.state.wallet;
+        let wallet = &mut ctx.state.wallet;
         let client = ctx.state.client;
         #[cfg(any(feature = "electrum", feature = "esplora"))]
         let request = wallet
@@ -267,12 +269,14 @@ impl AsyncAppCommand<AppContext<OnlineOperations<'_>>> for SyncCommand {
                 let mempool_txs = emitter.mempool()?;
                 wallet.apply_unconfirmed_txs(mempool_txs.update);
             }
-            // #[cfg(feature = "cbf")]
-            KyotoClient { client } => sync_kyoto_client(&mut wallet, client)
+            #[cfg(feature = "cbf")]
+            KyotoClient { client } => sync_kyoto_client(wallet, client)
                 .await
                 .map_err(|e| Error::Generic(e.to_string()))?,
         }
-        Ok(StatusResult::new("Wallet synced successfully."))
+        Ok(StatusResult {
+            message: "Wallet synced successfully.".to_string(),
+        })
     }
 }
 

src/handlers/repl.rs

@@ -1,13 +1,11 @@
-use bdk_wallet::{Wallet, bitcoin::Network};
-
-#[cfg(feature = "repl")]
-use crate::handlers::AppCommand;
 #[cfg(feature = "repl")]
-use crate::{handlers::AppContext, utils::output::FormatOutput};
+use {bdk_wallet::{Wallet, bitcoin::Network},
+crate::handlers::{AppCommand, AppContext},
+crate::utils::output::FormatOutput,
+clap::Parser,
+crate::commands::ReplSubCommand,
+};
 
-#[cfg(feature = "repl")]
-use crate::commands::ReplSubCommand;
-use clap::Parser;
 
 #[cfg(any(
     feature = "electrum",

src/main.rs

@@ -30,21 +30,12 @@ use bdk_redb::Store as RedbStore;
 use bdk_wallet::bitcoin::Network;
 use log::{debug, warn};
 
-#[cfg(any(
-    feature = "electrum",
-    feature = "esplora",
-    feature = "rpc",
-    feature = "cbf"
-))]
-use crate::client::new_blockchain_client;
 use crate::commands::{CliOpts, CliSubCommand, WalletSubCommand};
 use crate::error::BDKCliError as Error;
 use crate::handlers::{AppCommand, AppContext};
-#[cfg(any(feature = "sqlite", feature = "redb"))]
-use crate::persister::{Persister, new_persisted_wallet};
 use crate::utils::output::FormatOutput;
-use crate::utils::prepare_wallet_db_dir;
-use crate::utils::{load_wallet_config, prepare_home_dir};
+use crate::utils::runtime::WalletRuntime;
+use crate::utils::{command_requires_db, prepare_home_dir};
 use clap::Parser;
 
 #[tokio::main]
@@ -81,70 +72,36 @@ async fn run(cli_opts: CliOpts) -> Result<(), Error> {
                 feature = "rpc",
                 feature = "cbf"
             ))]
-            WalletSubCommand::OnlineWalletSubCommand(online_cmd) => {
-                let (wallet_opts, network) = load_wallet_config(&home_dir, &wallet_name)?;
-
-                let database_path = prepare_wallet_db_dir(&home_dir, &wallet_name)?;
-                #[cfg(any(feature = "sqlite", feature = "redb"))]
-                let mut persister: Persister = match &wallet_opts.database_type {
-                    #[cfg(feature = "sqlite")]
-                    crate::persister::DatabaseType::Sqlite => {
-                        let db_file = database_path.join("wallet.sqlite");
-                        let connection = bdk_wallet::rusqlite::Connection::open(db_file)?;
-                        Persister::Connection(connection)
-                    }
-                    #[cfg(feature = "redb")]
-                    crate::persister::DatabaseType::Redb => {
-                        use crate::persister::Persister;
-
-                        let db = std::sync::Arc::new(bdk_redb::redb::Database::create(
-                            home_dir.join("wallet.redb"),
-                        )?);
-                        let store = RedbStore::new(db, wallet_name)?;
-                        log::debug!("Redb database opened successfully");
-                        Persister::RedbStore(store)
-                    }
-                };
+            WalletSubCommand::OnlineWalletSubCommand(cmd) => {
+                let runtime = WalletRuntime::load(&home_dir, &wallet_name)?;
 
-                let mut wallet = new_persisted_wallet(network, &mut persister, &wallet_opts)?;
+                let mut wallet = runtime.build_wallet(true)?;
+                let client = runtime.build_client(&wallet)?;
 
-                let client = new_blockchain_client(&wallet_opts, &wallet, database_path)?;
-
-                let mut ctx =
-                    AppContext::new_online_wallet(network, home_dir, &mut wallet, &client);
+                let mut ctx = AppContext::new_online_wallet(
+                    runtime.network,
+                    runtime.home_dir.clone(),
+                    &mut wallet,
+                    &client,
+                );
 
-                online_cmd.execute(&mut ctx).await?;
+                cmd.execute(&mut ctx).await?;
             }
-            WalletSubCommand::OfflineWalletSubCommand(offline_cmd) => {
-                let (wallet_opts, network) = load_wallet_config(&home_dir, &wallet_name)?;
-
-                let database_path = prepare_wallet_db_dir(&home_dir, &wallet_name)?;
-
-                #[cfg(any(feature = "sqlite", feature = "redb"))]
-                let mut persister: Persister = match &wallet_opts.database_type {
-                    #[cfg(feature = "sqlite")]
-                    crate::persister::DatabaseType::Sqlite => {
-                        let db_file = database_path.join("wallet.sqlite");
-                        let connection = bdk_wallet::rusqlite::Connection::open(db_file)?;
-                        Persister::Connection(connection)
-                    }
-                    #[cfg(feature = "redb")]
-                    crate::persister::DatabaseType::Redb => {
-                        use crate::persister::Persister;
-                        let db = std::sync::Arc::new(bdk_redb::redb::Database::create(
-                            home_dir.join("wallet.redb"),
-                        )?);
-                        let store = RedbStore::new(db, wallet_name)?;
-                        Persister::RedbStore(store)
-                    }
-                };
 
-                let mut wallet = new_persisted_wallet(network, &mut persister, &wallet_opts)?;
+            WalletSubCommand::OfflineWalletSubCommand(cmd) => {
+                let runtime = WalletRuntime::load(&home_dir, &wallet_name)?;
 
-                let mut ctx = AppContext::new_offline_wallet(network, home_dir, &mut wallet);
+                let mut wallet = runtime.build_wallet(command_requires_db(&cmd))?;
+
+                let mut ctx = AppContext::new_offline_wallet(
+                    runtime.network,
+                    runtime.home_dir.clone(),
+                    &mut wallet,
+                );
 
-                offline_cmd.execute(&mut ctx)?;
+                cmd.execute(&mut ctx)?;
             }
+
             WalletSubCommand::Config(mut config_cmd) => {
                 config_cmd.wallet_opts.wallet = Some(wallet_name);
 
@@ -156,107 +113,87 @@ async fn run(cli_opts: CliOpts) -> Result<(), Error> {
 
         CliSubCommand::Key { subcommand } => {
             let mut ctx = AppContext::new(cli_opts.network, home_dir);
+
             subcommand.execute(&mut ctx)?;
         }
-        CliSubCommand::Descriptor(descriptor_command) => {
+
+        CliSubCommand::Descriptor(cmd) => {
             let mut ctx = AppContext::new(cli_opts.network, home_dir);
-            descriptor_command
-                .execute(&mut ctx)?
-                .write_out(std::io::stdout())?;
+
+            cmd.execute(&mut ctx)?.write_out(std::io::stdout())?;
         }
+
         CliSubCommand::Wallets(cmd) => {
             let mut ctx = AppContext::new(cli_opts.network, home_dir);
+
             cmd.execute(&mut ctx)?.write_out(std::io::stdout())?;
         }
+
         CliSubCommand::Repl {
             wallet: wallet_name,
         } => {
             #[cfg(feature = "repl")]
             {
-                let (wallet_opts, network) = load_wallet_config(&home_dir, &wallet_name)?;
-                let database_path = prepare_wallet_db_dir(&home_dir, &wallet_name)?;
-
-                #[cfg(any(feature = "sqlite", feature = "redb"))]
-                let mut persister: Persister = match &wallet_opts.database_type {
-                    #[cfg(feature = "sqlite")]
-                    crate::persister::DatabaseType::Sqlite => {
-                        let db_file = database_path.join("wallet.sqlite");
-                        let connection = bdk_wallet::rusqlite::Connection::open(db_file)?;
-                        Persister::Connection(connection)
-                    }
-                    #[cfg(feature = "redb")]
-                    crate::persister::DatabaseType::Redb => {
-                        use crate::persister::Persister;
-                        let db = std::sync::Arc::new(bdk_redb::redb::Database::create(
-                            home_dir.join("wallet.redb"),
-                        )?);
-                        let store = RedbStore::new(db, wallet_name.clone())?;
-                        Persister::RedbStore(store)
-                    }
-                };
+                let runtime = WalletRuntime::load(&home_dir, &wallet_name)?;
 
-                let mut wallet = new_persisted_wallet(network, &mut persister, &wallet_opts)?;
+                let mut wallet = runtime.build_wallet(true)?;
 
                 #[cfg(any(
                     feature = "electrum",
                     feature = "esplora",
                     feature = "rpc",
                     feature = "cbf"
                 ))]
-                let client = Some(new_blockchain_client(&wallet_opts, &wallet, database_path)?);
+                let client = runtime.build_client(&wallet).ok();
 
                 println!(
-                    "Entering REPL mode for wallet '{}'. Type 'exit' to quit.",
+                    "Entering REPL mode for wallet '{}'. \
+                     Type 'exit' to quit.",
                     wallet_name
                 );
 
                 loop {
                     let line = crate::handlers::repl::readline()?;
+
                     if line.trim().is_empty() {
                         continue;
                     }
 
-                    // Pass it to our newly refactored respond function
                     let should_exit = crate::handlers::repl::respond(
-                        network,
+                        runtime.network,
                         &mut wallet,
                         #[cfg(any(
                             feature = "electrum",
                             feature = "esplora",
                             feature = "rpc",
                             feature = "cbf"
                         ))]
-                        client.as_ref(), 
+                        client.as_ref(),
                         &line,
-                        home_dir.clone(),
+                        runtime.home_dir.clone(),
                         &cli_opts,
                     )
                     .await
-                    .map_err(Error::Generic)?; 
+                    .map_err(Error::Generic)?;
 
-                    // Break the loop if the user typed `exit`
                     if should_exit {
                         break;
                     }
                 }
             }
-
-            #[cfg(not(feature = "repl"))]
-            {
-                return Err(Error::Generic(
-                    "The 'repl' feature is not enabled in this build.".into(),
-                ));
-            }
         }
+
         CliSubCommand::Completions { shell } => {
             shell;
         }
+
         #[cfg(feature = "compiler")]
         CliSubCommand::Compile(cmd) => {
             let mut ctx = AppContext::new(cli_opts.network, home_dir);
+
             cmd.execute(&mut ctx)?.write_out(std::io::stdout())?;
         }
-    };
+    }
 
     Ok(())
 }

src/persister.rs

@@ -1,8 +1,8 @@
-#[cfg(any(feature = "sqlite", feature = "redb"))]
 use crate::commands::WalletOpts;
 use crate::error::BDKCliError as Error;
 #[cfg(any(feature = "sqlite", feature = "redb"))]
-use bdk_wallet::{KeychainKind, PersistedWallet, bitcoin::Network};
+use bdk_wallet::{KeychainKind, PersistedWallet};
+use bdk_wallet::bitcoin::Network;
 use bdk_wallet::{Wallet, WalletPersister};
 use clap::ValueEnum;
 
@@ -25,6 +25,7 @@ pub(crate) enum Persister {
     RedbStore(bdk_redb::Store),
 }
 
+#[cfg(any(feature = "sqlite", feature = "redb"))]
 impl WalletPersister for Persister {
     type Error = Error;
 
@@ -97,7 +98,6 @@ where
     Ok(wallet)
 }
 
-#[cfg(not(any(feature = "sqlite", feature = "redb")))]
 pub(crate) fn new_wallet(network: Network, wallet_opts: &WalletOpts) -> Result<Wallet, Error> {
     let ext_descriptor = wallet_opts.ext_descriptor.clone();
     let int_descriptor = wallet_opts.int_descriptor.clone();