implemented descriptor funtion

Author: AmosOO7

Cargo.lock

@@ -21,6 +21,7 @@ serde_json = "1.0"
 thiserror = "2.0.11"
 tokio = { version = "1", features = ["full"] }
 anyhow = "1.0"
+serde = { version = "1.0", features = ["derive"] }
 
 # Optional dependencies
 bdk_bitcoind_rpc = { version = "0.18.0", optional = true }

Cargo.toml

@@ -109,16 +109,54 @@ pub enum CliSubCommand {
         #[command(flatten)]
         wallet_opts: WalletOpts,
     },
-    GenerateDescriptor {
-        /// Optional BIP39 mnemonic phrase (if not provided, one will be randomly generated).
-        #[arg(short, long)]
-        mnemonic: Option<String>,
-        /// Password for mnemonic (optional).
-        #[arg(short, long)]
-        password: Option<String>,
-    },
+    /// Generate a random Bitcoin descriptor and mnemonic.
+    ///
+    /// This function generates a new 12-word BIP39 mnemonic phrase and uses it to derive a BIP32
+    /// extended private key (XPRV). It constructs two BIP86-compatible single-sig descriptors:
+    /// - An **external descriptor** used for receiving funds (`/0/*`)
+    /// - An **internal descriptor** used for change outputs (`/1/*`)
+    ///
+    /// These descriptors follow the standard derivation path `m/86h/0h/0h` for mainnet (or `86h/1h/0h`
+    /// for testnet), and use `wpkh` (native SegWit) script format.
+    ///
+    /// The output includes both the public and private forms of the descriptors, along with the mnemonic.
+    ///
+    /// > ⚠️ This feature is **EXPERIMENTAL** and is intended for testing or development. Do **not** use
+    /// > this output to secure real Bitcoin funds on mainnet.
+    ///
+    /// Returns a JSON object containing:
+    /// - `mnemonic`: the 12-word phrase
+    /// - `external_descriptor`: public and private forms for receive addresses
+    /// - `internal_descriptor`: public and private forms for change addresses
+
+    Descriptor(GenerateDescriptorArgs),
 }
+#[derive(Debug, Clone, PartialEq, Args)]
+pub struct GenerateDescriptorArgs {
+    /// Script type: BIP44 (Legacy), BIP49 (Nested), BIP84 (Native SegWit), or BIP86 (Taproot)
+    #[clap(value_enum)]
+    pub script_type: ScriptType,
+
+    /// Use multipath derivation (e.g. m/44'/0'/0'/*/*)
+    #[clap(long)]
+    pub multipath: bool,
 
+    /// Use weak key string instead of a fingerprinted xpub
+    #[clap(long)]
+    pub weak_keys: bool,
+
+    /// Specify the network: bitcoin, testnet, regtest, signet
+    #[clap(long, default_value = "testnet")]
+    pub network: Network,
+}
+
+#[derive(Debug, Clone, PartialEq, ValueEnum)]
+pub enum ScriptType {
+    Bip44,
+    Bip49,
+    Bip84,
+    Bip86,
+}
 /// Wallet operation subcommands.
 #[derive(Debug, Subcommand, Clone, PartialEq)]
 pub enum WalletSubCommand {

src/commands.rs

@@ -1,3 +1,5 @@
+use crate::commands::{GenerateDescriptorArgs, ScriptType};
+use bdk_wallet::bitcoin::Network as BdkNetwork;
 use bdk_wallet::keys::{GeneratableKey, GeneratedKey};
 use bdk_wallet::bitcoin::secp256k1::Secp256k1;
 use bdk_wallet::bitcoin::Network;
@@ -7,27 +9,41 @@ use bdk_wallet::bitcoin::bip32::Xpriv;
 use bdk_wallet::descriptor::Segwitv0;
 use anyhow::{Result, anyhow};
 
-pub fn handle_descriptor_generation(
-    network: Network,
-    _mnemonic_opt: Option<String>,
-    password: Option<String>,
-) -> Result<serde_json::Value> {
+pub fn generate_descriptor_from_args(args: GenerateDescriptorArgs) -> Result<serde_json::Value, anyhow::Error> {
+    // Convert CLI network to BDK network
+    let bdk_network = match args.network {
+        Network::Bitcoin => BdkNetwork::Bitcoin,
+        Network::Testnet => BdkNetwork::Testnet,
+        Network::Testnet4 => BdkNetwork::Testnet4,
+        Network::Regtest => BdkNetwork::Regtest,
+        Network::Signet => BdkNetwork::Signet,
+        _ => todo!(),
+    };
+
+    match args.script_type {
+        ScriptType::Bip84 => {
+            let json = generate_bip84_descriptor(bdk_network)?;
+            Ok(json)
+        }
+        _ => Err(anyhow!("Script type not supported yet")),
+    }
+    
+}
+
+pub fn generate_bip84_descriptor(network: Network) -> Result<serde_json::Value> {
     let secp = Secp256k1::new();
 
     let mnemonic: GeneratedKey<Mnemonic, Segwitv0> = Mnemonic::generate((WordCount::Words12, Language::English))
         .map_err(|e| anyhow!("Mnemonic generation failed: {:?}", e))?;
 
-    let password = password.unwrap_or_default();
-    let seed = mnemonic.to_seed(&password);
-
+    let seed = mnemonic.to_seed("");
     let xprv = Xpriv::new_master(network, &seed)
         .map_err(|e| anyhow!("Failed to create extended private key: {}", e))?;
 
     let origin = xprv.fingerprint(&secp);
-    let deriv_base = "/84h/1h/0h";
+    let deriv_base = "/84h/1h/0h"; // You might want to dynamically compute this based on args
     let xprv_str = xprv.to_string();
 
-    // Correct format strings with 4 placeholders
     let external_desc = format!("wpkh([{}{}]{}{})", origin, deriv_base, xprv_str, "/0/*");
     let internal_desc = format!("wpkh([{}{}]{}{})", origin, deriv_base, xprv_str, "/1/*");
 

src/descriptor_handler.rs

@@ -29,6 +29,9 @@ use bdk_wallet::bitcoin::bip32::{DerivationPath, KeySource};
 use bdk_wallet::bitcoin::consensus::encode::serialize_hex;
 use bdk_wallet::bitcoin::script::PushBytesBuf;
 use bdk_wallet::bitcoin::Network;
+use serde_json::Error as SerdeError;
+use serde::ser::Error as SerdeErrorTrait;
+
 #[cfg(any(
     feature = "electrum",
     feature = "esplora",
@@ -825,14 +828,22 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
             }
             Ok("".to_string())
         }
-        CliSubCommand::GenerateDescriptor { mnemonic, password } => {
-            let result = handle_descriptor_generation(network, mnemonic, password).map_err(|e| Error::Generic(e.to_string()))?;
-            serde_json::to_string_pretty(&result)
-        }
+        CliSubCommand::Descriptor(args) => handle_generate_descriptor(args),
     };
     result.map_err(|e| e.into())
 }
 
+
+
+pub fn handle_generate_descriptor(args: GenerateDescriptorArgs) -> Result<String, SerdeError> {
+    let descriptor = generate_descriptor_from_args(args)
+        .map_err(|e| SerdeErrorTrait::custom(e.to_string()))?;
+    serde_json::to_string_pretty(&descriptor)
+}
+
+
+
+
 #[cfg(feature = "repl")]
 async fn respond(
     network: Network,