refactor(handlers): Apply app context

- apply app context with state to all the modules
- cover case for commands when db is not required

Author: tvpeter

src/handlers/config.rs

@@ -10,6 +10,7 @@ use crate::client::ClientType;
 use crate::commands::WalletOpts;
 use crate::config::{WalletConfig, WalletConfigInner};
 use crate::error::BDKCliError as Error;
+use crate::handlers::Init;
 use crate::handlers::{AppCommand, AppContext};
 #[cfg(feature = "sqlite")]
 use crate::persister::DatabaseType;
@@ -27,10 +28,10 @@ pub struct SaveConfigCommand {
     pub(crate) wallet_opts: WalletOpts,
 }
 
-impl AppCommand for SaveConfigCommand {
+impl AppCommand<AppContext<Init>> for SaveConfigCommand {
     type Output = StatusResult;
 
-    fn execute(&self, ctx: &mut AppContext<'_>) -> Result<Self::Output, Error> {
+    fn execute(&self, ctx: &mut AppContext<Init>) -> Result<Self::Output, Error> {
         if ctx.network == Network::Bitcoin {
             eprintln!("WARNING: Configuring for Bitcoin MAINNET. Experimental software!");
         }
@@ -144,10 +145,10 @@ impl AppCommand for SaveConfigCommand {
 #[derive(Args, Debug, Clone, PartialEq)]
 pub struct ListWalletsCommand {}
 
-impl AppCommand for ListWalletsCommand {
+impl AppCommand<AppContext<Init>> for ListWalletsCommand {
     type Output = WalletsListResult;
 
-    fn execute(&self, ctx: &mut AppContext) -> Result<Self::Output, Error> {
+    fn execute(&self, ctx: &mut AppContext<Init>) -> Result<Self::Output, Error> {
         let config = match WalletConfig::load(&ctx.datadir)? {
             Some(cfg) => cfg,
             None => return Err(Error::Generic("No wallets configured yet.".into())),

src/handlers/descriptor.rs

@@ -1,3 +1,4 @@
+use crate::handlers::Init;
 use crate::utils::types::DescriptorResult;
 use crate::{
     error::BDKCliError as Error,
@@ -38,10 +39,10 @@ pub struct DescriptorCommand {
     /// Optional key: xprv, xpub, or mnemonic phrase
     key: Option<String>,
 }
-impl AppCommand for DescriptorCommand {
+impl AppCommand<AppContext<Init>> for DescriptorCommand {
     type Output = DescriptorResult;
 
-    fn execute(&self, ctx: &mut AppContext) -> Result<Self::Output, Error> {
+    fn execute(&self, ctx: &mut AppContext<Init>) -> Result<Self::Output, Error> {
         match &self.key {
             Some(key) => {
                 if is_mnemonic(key) {
@@ -68,10 +69,10 @@ pub struct CompileCommand {
 }
 
 #[cfg(feature = "compiler")]
-impl AppCommand for CompileCommand {
+impl AppCommand<AppContext<Init>> for CompileCommand {
     type Output = DescriptorResult;
 
-    fn execute(&self, _ctx: &mut AppContext) -> Result<Self::Output, Error> {
+    fn execute(&self, _ctx: &mut AppContext<Init>) -> Result<Self::Output, Error> {
         let policy: Concrete<String> = Concrete::from_str(&self.policy)
             .map_err(|e| Error::Generic(format!("Invalid policy: {e}")))?;
 

src/handlers/key.rs

@@ -1,5 +1,6 @@
 use crate::commands::KeySubCommand;
 use crate::error::BDKCliError as Error;
+use crate::handlers::Init;
 use crate::handlers::{AppCommand, AppContext};
 use crate::utils::output::FormatOutput;
 use crate::utils::types::KeyResult;
@@ -15,7 +16,7 @@ use bdk_wallet::miniscript::{self, Segwitv0};
 use clap::Parser;
 
 impl KeySubCommand {
-    pub fn execute(&self, ctx: &mut AppContext) -> Result<(), Error> {
+    pub fn execute(&self, ctx: &mut AppContext<Init>) -> Result<(), Error> {
         match self {
             KeySubCommand::Generate(generate_key_command) => generate_key_command
                 .execute(ctx)?
@@ -44,10 +45,10 @@ pub struct GenerateKeyCommand {
     password: Option<String>,
 }
 
-impl AppCommand for GenerateKeyCommand {
+impl AppCommand<AppContext<Init>> for GenerateKeyCommand {
     type Output = KeyResult;
 
-    fn execute(&self, ctx: &mut AppContext) -> Result<Self::Output, Error> {
+    fn execute(&self, ctx: &mut AppContext<Init>) -> Result<Self::Output, Error> {
         let secp = Secp256k1::new();
         let mnemonic_type = match self.word_count {
             12 => WordCount::Words12,
@@ -88,10 +89,10 @@ pub struct DeriveKeyCommand {
     path: DerivationPath,
 }
 
-impl AppCommand for DeriveKeyCommand {
+impl AppCommand<AppContext<Init>> for DeriveKeyCommand {
     type Output = KeyResult;
 
-    fn execute(&self, ctx: &mut AppContext) -> Result<Self::Output, Error> {
+    fn execute(&self, ctx: &mut AppContext<Init>) -> Result<Self::Output, Error> {
         let secp = Secp256k1::new();
 
         let derived_xprv = &self.xprv.derive_priv(&secp, &self.path)?;
@@ -134,10 +135,10 @@ pub struct RestoreKeyCommand {
     password: Option<String>,
 }
 
-impl AppCommand for RestoreKeyCommand {
+impl AppCommand<AppContext<Init>> for RestoreKeyCommand {
     type Output = KeyResult;
 
-    fn execute(&self, ctx: &mut AppContext) -> Result<Self::Output, Error> {
+    fn execute(&self, ctx: &mut AppContext<Init>) -> Result<Self::Output, Error> {
         let secp = Secp256k1::new();
 
         let mnemonic = Mnemonic::parse_in(Language::English, &self.mnemonic)?;