- Updated error calls on functions in handlers and commands, and also deleted redundant errors that were created.

- Updated the comment on the descriptor command, also added comments to the inputs for the subcommands.
- Added possiblevalues for the descriptor types in the subcommand
- Made the descriptor type format consistent
- Fixed duplicated on invalidArguments call

Author: AmosOO7

src/commands.rs

@@ -17,7 +17,7 @@ use bdk_wallet::bitcoin::{
     Address, Network, OutPoint, ScriptBuf,
     bip32::{DerivationPath, Xpriv},
 };
-use clap::{Args, Parser, Subcommand, ValueEnum, value_parser};
+use clap::{Args, Parser, Subcommand, ValueEnum, value_parser, builder::TypedValueParser};
 
 #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
 use crate::utils::parse_proxy_auth;
@@ -106,10 +106,10 @@ pub enum CliSubCommand {
         #[command(flatten)]
         wallet_opts: WalletOpts,
     },
-    /// Descriptor generation operations.
-    ///
-    /// Allows users to generate Bitcoin wallet descriptors from either an extended key (e.g., Xprv/Xpub) or by generating a new random mnemonic phrase.
-    /// This feature is intended for development and testing. Exercise caution when using descriptors created this way in production environments.
+    /// Output Descriptors operations.
+    /// 
+    /// Generate output descriptors from either extended key (Xprv/Xpub) or mnemonic phrase.
+    /// This feature is intended for development and testing purposes only.
     Descriptor {
         #[clap(subcommand)]
         subcommand: DescriptorSubCommand,
@@ -488,12 +488,19 @@ pub enum ReplSubCommand {
 pub enum DescriptorSubCommand {
     /// Generate a descriptor
     Generate {
-        #[clap(long = "type", value_parser = clap::value_parser!(u8).range(44..=86), short = 't', default_value = "84")]
-        r#type: u8, // 44, 49, 84, 86
-
+        /// Descriptor type (script type).
+        #[arg(
+            long = "type",
+            short = 't',
+            value_parser = clap::builder::PossibleValuesParser::new(["44", "49", "84", "86"])
+                .map(|s| s.parse::<u8>().unwrap()),
+            default_value = "84"
+        )]
+        r#type: u8,
+        /// Enable multipath descriptors
         #[arg(long = "multipath", short = 'm', default_value_t = false)]
         multipath: bool,
-
+        /// Optional key input
         key: Option<String>,
     },
 

src/error.rs

@@ -113,11 +113,8 @@ pub enum BDKCliError {
     #[error("Descriptor parsing failed: {0}")]
     DescriptorParsingError(String),
 
-    #[error("Invalid extended public key (xpub): {0}")]
-    InvalidXpub(String),
-
-    #[error("Invalid extended private key (xprv): {0}")]
-    InvalidXprv(String),
+    #[error("Invalid extended key (xpub): {0}")]
+    InvalidKey(String),
 
     #[error("Invalid derivation path: {0}")]
     InvalidDerivationPath(String),

src/handlers.rs

@@ -41,11 +41,11 @@ use bdk_wallet::{
 use cli_table::{Cell, CellStruct, Style, Table, format::Justify};
 
 use bdk_wallet::keys::{
-    DerivableKey, DescriptorKey, DescriptorKey::Secret, ExtendedKey, GeneratableKey, GeneratedKey,
-    bip39::WordCount, DescriptorPublicKey,
+    DerivableKey, DescriptorKey, DescriptorKey::Secret, DescriptorPublicKey, ExtendedKey,
+    GeneratableKey, GeneratedKey, bip39::WordCount,
 };
 use bdk_wallet::miniscript::miniscript;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 use std::collections::BTreeMap;
 #[cfg(any(feature = "electrum", feature = "esplora"))]
 use std::collections::HashSet;
@@ -1352,16 +1352,11 @@ pub fn handle_descriptor_subcommand(
             key,
         } => {
             let (descriptor_type, derivation_path_str) = match r#type {
-                44 => (DescriptorType::Bip44, "m/44'/1'/0'"),
-                49 => (DescriptorType::Bip49, "m/49'/1'/0'"),
-                84 => (DescriptorType::Bip84, "m/84'/1'/0'"),
-                86 => (DescriptorType::Bip86, "m/86'/1'/0'"),
-                _ => {
-                    return Err(Error::Generic(format!(
-                        "Unsupported script type {}",
-                        r#type
-                    )))
-                }
+                44 => (DescriptorType::Bip44, "m/44h/1h/0h"),
+                49 => (DescriptorType::Bip49, "m/49h/1h/0h"),
+                84 => (DescriptorType::Bip84, "m/84h/1h/0h"),
+                86 => (DescriptorType::Bip86, "m/86h/1h/0h"),
+                _ => return Err(Error::UnsupportedScriptType(r#type)),
             };
 
             match (multipath, key.as_ref()) {
@@ -1380,7 +1375,7 @@ pub fn handle_descriptor_subcommand(
                 }
                 (false, None) => generate_new_descriptor_with_mnemonic(network, descriptor_type),
                 _ => Err(Error::InvalidArguments(
-                    "Invalid arguments: provide a key or weak string".to_string(),
+                    "Provide a key or weak string".to_string(),
                 )),
             }
         }

src/utils.rs

@@ -47,15 +47,15 @@ use bdk_wallet::descriptor::{
     Segwitv0, {Descriptor, DescriptorPublicKey},
 };
 use bdk_wallet::keys::{
-    bip39::WordCount,
     DerivableKey, ExtendedKey,
+    bip39::WordCount,
     {DescriptorSecretKey, GeneratableKey, GeneratedKey, IntoDescriptorKey},
 };
 use bdk_wallet::miniscript::{
-    descriptor::{DescriptorXKey, Wildcard},
     Tap,
+    descriptor::{DescriptorXKey, Wildcard},
 };
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 /// Parse the recipient (Address,Amount) argument from cli input.
 pub(crate) fn parse_recipient(s: &str) -> Result<(ScriptBuf, u64), String> {
@@ -537,7 +537,7 @@ pub fn generate_multipath_descriptor(
     let (fingerprint, make_desc): (_, DescriptorBuilderFn) = if is_private {
         let xprv: Xpriv = key
             .parse()
-            .map_err(|e| Error::InvalidXprv(format!("Invalid xprv: {e}")))?;
+            .map_err(|e| Error::InvalidKey(format!("Invalid xprv: {e}")))?;
         let fingerprint = xprv.fingerprint(&secp);
 
         let closure = move |change: u32| -> Result<(String, Option<String>), Error> {
@@ -578,7 +578,7 @@ pub fn generate_multipath_descriptor(
     } else {
         let xpub: Xpub = key
             .parse()
-            .map_err(|e| Error::InvalidXpub(format!("Invalid xpub: {e}")))?;
+            .map_err(|e| Error::InvalidKey(format!("Invalid xpub: {e}")))?;
         let fingerprint = xpub.fingerprint();
 
         let closure = move |change: u32| -> Result<(String, Option<String>), Error> {
@@ -638,7 +638,7 @@ pub fn generate_bip_descriptor_from_key(
 
     let xprv: Xpriv = key
         .parse()
-        .map_err(|e| Error::InvalidXprv(format!("Invalid xprv: {e}")))?;
+        .map_err(|e| Error::InvalidKey(format!("Invalid xprv: {e}")))?;
 
     let fingerprint = xprv.fingerprint(&secp);
 
@@ -722,7 +722,7 @@ pub fn generate_descriptor_from_mnemonic_string(
 
     let xprv = xprv
         .derive_priv(&secp, &derivation_path)
-        .map_err(|e| Error::InvalidXprv(format!("Failed to derive xprv: {e}")))?;
+        .map_err(|e| Error::InvalidKey(format!("Failed to derive xprv: {e}")))?;
 
     generate_bip_descriptor_from_key(
         &network,