feat: add support for descriptor generation from keys and mnemonics

This enhancement introduces a new `descriptor` subcommand to `bdk-cli`, allowing users to generate wallet descriptors from either extended private keys (xprv), or fresh BIP39 mnemonics.
It supports standard script types (BIP44, BIP49, BIP84, BIP86) and outputs both public and private descriptors for external and internal branches.
The design improves developer and user experience by enabling easier wallet creation and script descriptor introspection.

Closes #175

Author: AmosOO7

src/commands.rs

@@ -13,7 +13,6 @@
 //! All subcommands are defined in the below enums.
 
 #![allow(clippy::large_enum_variant)]
-
 use bdk_wallet::bitcoin::{
     bip32::{DerivationPath, Xpriv},
     Address, Network, OutPoint, ScriptBuf,
@@ -104,6 +103,42 @@ 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.
+    ///
+    /// 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, value_parser = clap::value_parser!(u8).range(44..=86))]
+    pub r#type: u8, // 44, 49, 84, 86
+
+    #[clap(long)]
+    pub multipath: bool,
+
+    pub key: Option<String>, // Positional argument (tprv/tpub/xprv/xpub)
 }
 
 /// Wallet operation subcommands.

src/error.rs

@@ -94,6 +94,33 @@ pub enum BDKCliError {
     #[cfg(feature = "cbf")]
     #[error("BDK-Kyoto update error: {0}")]
     KyotoUpdateError(#[from] bdk_kyoto::UpdateError),
+
+    #[error("Mnemonic generation failed: {0}")]
+    MnemonicGenerationError(String),
+
+    #[error("Xpriv creation failed: {0}")]
+    XprivCreationError(String),
+
+    #[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 derivation path: {0}")]
+    InvalidDerivationPath(String),
+
+    #[error("Unsupported script type: {0}")]
+    UnsupportedScriptType(u8),
+
+    #[error("Descriptor key conversion failed: {0}")]
+    DescriptorKeyError(String),
+
+    #[error("Invalid arguments: {0}")]
+    InvalidArguments(String),
 }
 
 impl From<ExtractTxError> for BDKCliError {

src/handlers.rs

@@ -22,9 +22,22 @@ use bdk_wallet::bitcoin::consensus::encode::serialize_hex;
 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::keys::bip39::WordCount;
+use bdk_wallet::keys::{GeneratableKey, GeneratedKey};
+use bdk_wallet::serde::ser::Error as SerdeErrorTrait;
+use serde_json::json;
+use serde_json::Error as SerdeError;
+use serde_json::Value;
+
+#[cfg(any(
+    feature = "electrum",
+    feature = "esplora",
+    feature = "cbf",
+    feature = "rpc"
+))]
+use bdk_wallet::bitcoin::Transaction;
+use bdk_wallet::bitcoin::{Amount, FeeRate, Psbt, Sequence};
 #[cfg(feature = "sqlite")]
 use bdk_wallet::rusqlite::Connection;
 #[cfg(feature = "compiler")]
@@ -33,18 +46,18 @@ use bdk_wallet::{
     miniscript::policy::Concrete,
 };
 use bdk_wallet::{KeychainKind, SignOptions, Wallet};
+use std::fmt;
+use std::str::FromStr;
 
 use bdk_wallet::keys::DescriptorKey::Secret;
-use bdk_wallet::keys::{DerivableKey, DescriptorKey, ExtendedKey, GeneratableKey, GeneratedKey};
+use bdk_wallet::keys::{DerivableKey, DescriptorKey, ExtendedKey};
 use bdk_wallet::miniscript::miniscript;
-use serde_json::json;
 use std::collections::BTreeMap;
 #[cfg(any(feature = "electrum", feature = "esplora"))]
 use std::collections::HashSet;
 use std::convert::TryFrom;
 #[cfg(any(feature = "repl", feature = "electrum", feature = "esplora"))]
 use std::io::Write;
-use std::str::FromStr;
 
 #[cfg(feature = "electrum")]
 use crate::utils::BlockchainClient::Electrum;
@@ -61,7 +74,7 @@ use tokio::select;
 ))]
 use {
     crate::commands::OnlineWalletSubCommand::*,
-    bdk_wallet::bitcoin::{consensus::Decodable, hex::FromHex, Transaction},
+    bdk_wallet::bitcoin::{consensus::Decodable, hex::FromHex},
 };
 #[cfg(feature = "esplora")]
 use {crate::utils::BlockchainClient::Esplora, bdk_esplora::EsploraAsyncExt};
@@ -900,6 +913,13 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
             }
             Ok("".to_string())
         }
+        CliSubCommand::Descriptor(args) => {
+            let network = cli_opts.network;
+            let descriptor = generate_descriptor_from_args(args.clone(), network)
+                .map_err(|e| SerdeError::custom(e.to_string()))?;
+            let json = serde_json::to_string_pretty(&descriptor)?;
+            Ok(json)
+        }
     };
     result.map_err(|e| e.into())
 }
@@ -971,6 +991,57 @@ fn readline() -> Result<String, Error> {
     Ok(buffer)
 }
 
+pub fn generate_descriptor_from_args(
+    args: GenerateDescriptorArgs,
+    network: Network,
+) -> Result<serde_json::Value, Error> {
+    match (args.multipath, args.key.as_ref()) {
+        (true, Some(key)) => generate_multipath_descriptor(&network, args.r#type, key),
+        (false, Some(key)) => generate_standard_descriptor(&network, args.r#type, key),
+        (false, None) => {
+            // New default: generate descriptor from fresh mnemonic (for script_type 84 only)
+            if args.r#type == 84 {
+                generate_new_bip84_descriptor_with_mnemonic(network)
+            } else {
+                Err(Error::Generic(
+                    "Only script type 84 is supported for mnemonic-based generation".to_string(),
+                ))
+            }
+        }
+        _ => Err(Error::InvalidArguments(
+            "Invalid arguments: please provide a key or a weak string".to_string(),
+        )),
+    }
+}
+
+pub fn generate_standard_descriptor(
+    network: &Network,
+    script_type: u8,
+    key: &str,
+) -> Result<Value, Error> {
+    let descriptor_type = match script_type {
+        44 => DescriptorType::Bip44,
+        49 => DescriptorType::Bip49,
+        84 => DescriptorType::Bip84,
+        86 => DescriptorType::Bip86,
+        _ => return Err(Error::UnsupportedScriptType(script_type)),
+    };
+
+    generate_descriptor_from_key_by_type(network, key, descriptor_type)
+}
+
+impl fmt::Display for DescriptorType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match self {
+            DescriptorType::Bip44 => "bip44",
+            DescriptorType::Bip49 => "bip49",
+            DescriptorType::Bip84 => "bip84",
+            DescriptorType::Bip86 => "bip86",
+        };
+        write!(f, "{}", s)
+    }
+}
+
 #[cfg(any(
     feature = "electrum",
     feature = "esplora",