feat: add support for descriptor generation from keys and mnemonics

- Created Subcommnds for the descriptor command; generate and info
- Created function to get descriptors from mnemonics
- Ensured consistent fingerprint when generating descriptors from both mnemonic and key
- Removed the previously inserted path variable

Author: AmosOO7

src/commands.rs

@@ -103,47 +103,15 @@ pub enum CliSubCommand {
         #[command(flatten)]
         wallet_opts: WalletOpts,
     },
-    /// Generate a Bitcoin descriptor either from a provided (Xprv, Xpub) or by generating a new random mnemonic.
+    /// Descriptor generation operations.
     ///
-    /// This function supports two modes:
-    ///
-    /// 1. **Using a provided XPRV**:
-    ///    - Generates BIP32-based descriptors from the provided extended private key.
-    ///    - Derives both external (`/0/*`) and internal (`/1/*`) paths.
-    ///    - Automatically detects the script type from the `--type` flag (e.g., BIP44, BIP49, BIP84, BIP86).
-    ///
-    /// 2. **Generating a new mnemonic**:
-    ///    - Creates a new 12-word BIP39 mnemonic phrase.
-    ///    - Derives a BIP32 root XPRV using the standard derivation path based on the selected script type.
-    ///    - Constructs external and internal descriptors using that XPRV.
-    ///
-    /// The output is a prettified JSON object containing:
-    /// - `mnemonic` (if generated): the 12-word seed phrase.
-    /// - `external`: public and private descriptors for receive addresses (`/0/*`)
-    /// - `internal`: public and private descriptors for change addresses (`/1/*`)
-    /// - `fingerprint`: master key fingerprint used in the descriptors
-    /// - `network`: either `mainnet`, `testnet`, `signet`, `regtest`, or `testnet4`
-    /// - `type`: one of `bip44`, `bip49`, `bip84`, or `bip86`
-    ///
-    /// > ⚠️ **Security Warning**: This feature is intended for testing and development purposes.
-    /// > Do **not** use generated descriptors or mnemonics to secure real Bitcoin funds on mainnet.
-    ///
-    Descriptor(GenerateDescriptorArgs),
-}
-#[derive(Debug, Clone, PartialEq, Args)]
-pub struct GenerateDescriptorArgs {
-    #[clap(long = "type", value_parser = clap::value_parser!(u8).range(44..=86), short = 't', default_value = "84")]
-    pub r#type: u8, // 44, 49, 84, 86
-
-    #[arg(long = "multipath", short = 'm', default_value_t = false)]
-    pub multipath: bool,
-
-    #[arg(long)]
-    pub path: Option<String>,
-
-    pub key: Option<String>,
+    /// 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.
+    Descriptor {
+        #[clap(subcommand)]
+        subcommand: DescriptorSubCommand,
+    },
 }
-
 /// Wallet operation subcommands.
 #[derive(Debug, Subcommand, Clone, PartialEq)]
 pub enum WalletSubCommand {
@@ -509,3 +477,20 @@ pub enum ReplSubCommand {
     /// Exit REPL loop.
     Exit,
 }
+/// Subcommands for Key operations.
+#[derive(Debug, Subcommand, Clone, PartialEq, Eq)]
+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
+
+        #[arg(long = "multipath", short = 'm', default_value_t = false)]
+        multipath: bool,
+
+        key: Option<String>,
+    },
+
+    /// Show info about a given descriptor
+    Info { descriptor: String },
+}

src/handlers.rs

@@ -23,19 +23,21 @@ use bdk_wallet::bitcoin::script::PushBytesBuf;
 use bdk_wallet::bitcoin::Network;
 use bdk_wallet::bitcoin::{secp256k1::Secp256k1, Txid};
 use bdk_wallet::bitcoin::{Amount, FeeRate, Psbt, Sequence};
-use bdk_wallet::descriptor::Segwitv0;
+use bdk_wallet::descriptor::{Descriptor, Segwitv0};
 use bdk_wallet::keys::bip39::WordCount;
 #[cfg(feature = "sqlite")]
 use bdk_wallet::rusqlite::Connection;
 #[cfg(feature = "compiler")]
 use bdk_wallet::{
-    descriptor::{Descriptor, Legacy, Miniscript},
+    descriptor::{Legacy, Miniscript},
     miniscript::policy::Concrete,
 };
 use bdk_wallet::{KeychainKind, SignOptions, Wallet};
 
 use bdk_wallet::keys::DescriptorKey::Secret;
-use bdk_wallet::keys::{DerivableKey, DescriptorKey, ExtendedKey, GeneratableKey, GeneratedKey};
+use bdk_wallet::keys::{
+    DerivableKey, DescriptorKey, DescriptorPublicKey, ExtendedKey, GeneratableKey, GeneratedKey,
+};
 use bdk_wallet::miniscript::miniscript;
 use serde_json::{json, Value};
 use std::collections::BTreeMap;
@@ -901,9 +903,11 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
             }
             Ok("".to_string())
         }
-        CliSubCommand::Descriptor(args) => {
+        CliSubCommand::Descriptor {
+            subcommand: descriptor_subcommand,
+        } => {
             let network = cli_opts.network;
-            let descriptor = generate_descriptor_from_args(args.clone(), network)
+            let descriptor = handle_descriptor_subcommand(network, descriptor_subcommand)
                 .map_err(|e| Error::Generic(e.to_string()))?;
             let json = serde_json::to_string_pretty(&descriptor)?;
             Ok(json)
@@ -979,49 +983,71 @@ fn readline() -> Result<String, Error> {
     Ok(buffer)
 }
 
-pub fn generate_descriptor_from_args(
-    args: GenerateDescriptorArgs,
+pub fn handle_descriptor_subcommand(
     network: Network,
-) -> Result<serde_json::Value, Error> {
-    let descriptor_type = match args.r#type {
-        44 => DescriptorType::Bip44,
-        49 => DescriptorType::Bip49,
-        84 => DescriptorType::Bip84,
-        86 => DescriptorType::Bip86,
-        _ => {
-            return Err(Error::Generic(format!(
-                "Unsupported script type {}",
-                args.r#type
-            )))
-        }
-    };
-    if args.multipath && args.path.is_some() {
-        return Err(Error::InvalidArguments(
-            "Path can not be called here".to_string(),
-        ));
-    }
-    if args.path.is_some() && args.key.is_none() {
-        return Err(Error::InvalidArguments(
-            "Custom path requires a key".to_string(),
-        ));
-    }
-    match (args.multipath, args.key.as_ref()) {
-        (true, Some(key)) => generate_multipath_descriptor(&network, args.r#type, key),
-        (false, Some(key)) => {
-            if let Some(path) = args.path.as_ref() {
-                // Use descriptor from custom derivation path
-                generate_bip_descriptor_from_key(&network, key, path, descriptor_type)
-            } else {
-                generate_standard_descriptor(&network, args.r#type, key)
+    subcommand: DescriptorSubCommand,
+) -> Result<Value, Error> {
+    match subcommand {
+        DescriptorSubCommand::Generate {
+            r#type,
+            multipath,
+            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
+                    )))
+                }
+            };
+
+            match (multipath, key.as_ref()) {
+                (true, Some(k)) => generate_multipath_descriptor(&network, r#type, k),
+                (false, Some(k)) => {
+                    if is_mnemonic(k) {
+                        generate_descriptor_from_mnemonic_string(
+                            k,
+                            network,
+                            derivation_path_str,
+                            descriptor_type,
+                        )
+                    } else {
+                        generate_standard_descriptor(&network, r#type, k)
+                    }
+                }
+                (false, None) => generate_new_descriptor_with_mnemonic(network, descriptor_type),
+                _ => Err(Error::InvalidArguments(
+                    "Invalid arguments: provide a key or weak string".to_string(),
+                )),
             }
         }
-        (false, None) => {
-            // Generate from fresh mnemonic
-            generate_new_descriptor_with_mnemonic(network, descriptor_type)
+        DescriptorSubCommand::Info { descriptor } => {
+            let parsed: Descriptor<DescriptorPublicKey> = descriptor
+                .parse()
+                .map_err(|e| Error::Generic(format!("Failed to parse descriptor: {}", e)))?;
+
+            let checksum = parsed.to_string();
+            let script_type = match parsed {
+                Descriptor::Wpkh(_) => "wpkh",
+                Descriptor::Pkh(_) => "pkh",
+                Descriptor::Sh(_) => "sh",
+                Descriptor::Tr(_) => "tr",
+                _ => "other",
+            };
+
+            let json = json!({
+                "descriptor": checksum,
+                "type": script_type,
+                "is_multipath": descriptor.contains("/*"),
+            });
+
+            Ok(json)
         }
-        _ => Err(Error::InvalidArguments(
-            "Invalid arguments: please provide a key or a weak string".to_string(),
-        )),
     }
 }