Update functions and command

Author: AmosOO7

Cargo.lock

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

Cargo.toml

@@ -140,9 +140,6 @@ pub struct GenerateDescriptorArgs {
     #[clap(long)]
     pub multipath: bool,
 
-    #[clap(long)]
-    pub weak: Option<String>, // If present, user supplied a weak string
-
     pub key: Option<String>, // Positional argument (tprv/tpub/xprv/xpub)
 }
 

src/commands.rs

@@ -8,20 +8,24 @@ use bdk_wallet::bitcoin::Network;
 use bdk_wallet::descriptor::Segwitv0;
 use bdk_wallet::keys::bip39::{Language, Mnemonic, WordCount};
 use bdk_wallet::keys::{GeneratableKey, GeneratedKey};
-use bdk_wallet::miniscript::{Descriptor, DescriptorPublicKey};
+
+use bdk_wallet::bitcoin::bip32::DerivationPath;
+use bdk_wallet::descriptor::{Descriptor, DescriptorPublicKey};
+
+use bdk_wallet::keys::{DescriptorSecretKey, IntoDescriptorKey};
+use miniscript::descriptor::{DescriptorXKey, Wildcard};
+
+ use std::str::FromStr;
 
 pub fn generate_descriptor_from_args(args: GenerateDescriptorArgs) -> Result<Value, anyhow::Error> {
-    match (args.weak.as_ref(), args.multipath, args.key.as_ref()) {
-        (Some(weak_str), _, _) => {
-            generate_descriptor_from_weak_string(&args.network, args.r#type, weak_str)
-        }
-        (None, true, Some(key)) => {
+    match (args.multipath, args.key.as_ref()) {
+        (true, Some(key)) => {
             generate_multipath_descriptor(&args.network, args.r#type, key)
         }
-        (None, false, Some(key)) => {
+        (false, Some(key)) => {
             generate_standard_descriptor(&args.network, args.r#type, key)
         }
-        (None, false, None) => {
+        (false, None) => {
             // New default: generate descriptor from fresh mnemonic (for script_type 84 only maybe)
             if args.r#type == 84 {
                 generate_new_bip84_descriptor_with_mnemonic(args.network)
@@ -43,15 +47,20 @@ pub fn generate_new_bip84_descriptor_with_mnemonic(network: Network) -> Result<s
             .map_err(|e| anyhow!("Mnemonic generation failed: {:?}", e))?;
 
     let seed = mnemonic.to_seed("");
-    let xprv = Xpriv::new_master(network, &seed)
+    let master_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"; // You might want to dynamically compute this based on args
-    let xprv_str = xprv.to_string();
+    // Derive to account level: m/84'/1'/0'
+    let deriv_path = DerivationPath::from_str("m/84h/1h/0h")?;
+    let account_xprv = master_xprv.derive_priv(&secp, &deriv_path)?;
 
-    let external_desc = format!("wpkh([{}{}]{}{})", origin, deriv_base, xprv_str, "/0/*");
-    let internal_desc = format!("wpkh([{}{}]{}{})", origin, deriv_base, xprv_str, "/1/*");
+    let fingerprint = master_xprv.fingerprint(&secp);
+
+    let xprv_str = account_xprv.to_string();
+
+    // Build descriptors using proper derivation suffix
+    let external_desc = format!("wpkh([{}{}]{}{})", fingerprint, deriv_path, xprv_str, "/0/*");
+    let internal_desc = format!("wpkh([{}{}]{}{})", fingerprint, deriv_path, xprv_str, "/1/*");
 
     let (desc, keymap) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, &external_desc)
         .map_err(|e| anyhow!("Failed to parse external descriptor: {}", e))?;
@@ -72,15 +81,6 @@ pub fn generate_new_bip84_descriptor_with_mnemonic(network: Network) -> Result<s
     }))
 }
 
-fn generate_descriptor_from_weak_string(
-    network: &Network,
-    script_type: u8,
-    weak_str: &str,
-) -> Result<Value, anyhow::Error> {
-    // TODO: replace with real weak key generation logic
-    let fake_xprv = format!("xprv-from-{}", weak_str);
-    generate_standard_descriptor(network, script_type, &fake_xprv)
-}
 
 fn generate_multipath_descriptor(
     _network: &Network,
@@ -108,15 +108,59 @@ fn generate_standard_descriptor(
 pub fn generate_bip84_descriptor_from_key(
     network: &Network,
     key: &str,
-) -> Result<Value, anyhow::Error> {
-    // Adjust derivation paths according to BIP84
-    let external = format!("wpkh([{fingerprint}/84'/1'/0']{key}/0/*)", fingerprint = "00000000");
-    let internal = format!("wpkh([{fingerprint}/84'/1'/0']{key}/1/*)", fingerprint = "00000000");
+) -> Result<serde_json::Value, anyhow::Error> {
+    let secp = Secp256k1::new();
+    let derivation_path: DerivationPath = "m/84h/1h/0h".parse()?;
+    let xprv: Xpriv = key.parse().map_err(|e| anyhow!("Invalid xprv: {e}"))?;
+    let fingerprint = xprv.fingerprint(&secp);
 
-    Ok(json!({
+    let make_desc_key = |branch: u32| -> Result<(String, String)> {
+        let branch_path: DerivationPath = DerivationPath::from_str(&format!("{branch}"))?;
+
+        let desc_xprv = DescriptorXKey {
+            origin: Some((fingerprint, derivation_path.clone())), // only account-level path
+            xkey: xprv,
+            derivation_path: branch_path, // just the change (0 for external, 1 for internal)
+            wildcard: Wildcard::Unhardened,
+        };
+
+    
+        let desc_secret = DescriptorSecretKey::XPrv(desc_xprv);
+    
+        // Use the BDK extract() to get both descriptor and keymap
+        let (desc_key, keymap, _) = IntoDescriptorKey::<Segwitv0>::into_descriptor_key(desc_secret.clone())?
+        .extract(&secp)?;
+    
+        // Create the public descriptor from the public key
+        let public_descriptor = Descriptor::new_wpkh(desc_key.clone())?;
+    
+        // Here, we need to ensure that `desc_secret` is a valid descriptor type
+        // for the private descriptor; we must use DescriptorPublicKey
+        let private_descriptor = Descriptor::new_wpkh(desc_key)?;
+    
+        // Convert both to string representations
+        let public_descriptor_str = public_descriptor.to_string();
+        let private_descriptor_str = private_descriptor.to_string_with_secret(&keymap);
+    
+        Ok((public_descriptor_str, private_descriptor_str))
+    };
+    
+    
+
+    let (external_pub, external_priv) = make_desc_key(0)?;
+    let (internal_pub, internal_priv) = make_desc_key(1)?;
+
+    Ok(serde_json::json!({
         "type": "bip84",
-        "external": external,
-        "internal": internal,
+        "external": {
+            "public": external_pub,
+            "private": external_priv,
+        },
+        "internal": {
+            "public": internal_pub,
+            "private": internal_priv,
+        },
+        "fingerprint": fingerprint.to_string(),
         "network": network.to_string()
     }))
 }