Update functions

Author: AmosOO7

src/descriptor_handler.rs

@@ -17,6 +17,9 @@ use miniscript::descriptor::{DescriptorXKey, Wildcard};
 
  use std::str::FromStr;
 
+ use miniscript::Tap;
+
+
 pub fn generate_descriptor_from_args(args: GenerateDescriptorArgs) -> Result<Value, anyhow::Error> {
     match (args.multipath, args.key.as_ref()) {
         (true, Some(key)) => {
@@ -169,13 +172,58 @@ pub fn generate_bip86_descriptor_from_key(
     network: &Network,
     key: &str,
 ) -> Result<Value, anyhow::Error> {
-    let external = format!("tr([{}/86'/1'/0']{}/0/*)", "00000000", key);
-    let internal = format!("tr([{}/86'/1'/0']{}/1/*)", "00000000", key);
+    let secp = Secp256k1::new();
+    let derivation_path: DerivationPath = "m/86h/1h/0h".parse()?;
+    let xprv: Xpriv = key.parse().map_err(|e| anyhow!("Invalid xprv: {e}"))?;
+    let fingerprint = xprv.fingerprint(&secp);
+
+    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::<Tap>::into_descriptor_key(desc_secret.clone())?
+        .extract(&secp)?;
+    
+        // Create the public descriptor from the public key
+        let public_descriptor = Descriptor::new_tr(desc_key.clone(),None)?;
+    
+        // 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_tr(desc_key,None)?;
+    
+        // 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))
+    };
+    
+    
 
-    Ok(json!({
+    let (external_pub, external_priv) = make_desc_key(0)?;
+    let (internal_pub, internal_priv) = make_desc_key(1)?;
+
+    Ok(serde_json::json!({
         "type": "bip86",
-        "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()
     }))
 }
@@ -185,13 +233,58 @@ pub fn generate_bip49_descriptor_from_key(
     network: &Network,
     key: &str,
 ) -> Result<Value, anyhow::Error> {
-    let external = format!("sh(wpkh([{}/49'/1'/0']{}/0/*))", "00000000", key);
-    let internal = format!("sh(wpkh([{}/49'/1'/0']{}/1/*))", "00000000", key);
+    let secp = Secp256k1::new();
+    let derivation_path: DerivationPath = "m/49h/1h/0h".parse()?;
+    let xprv: Xpriv = key.parse().map_err(|e| anyhow!("Invalid xprv: {e}"))?;
+    let fingerprint = xprv.fingerprint(&secp);
+
+    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_sh_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_sh_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(json!({
+    Ok(serde_json::json!({
         "type": "bip49",
-        "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()
     }))
 }
@@ -200,13 +293,58 @@ pub fn generate_bip44_descriptor_from_key(
     network: &Network,
     key: &str,
 ) -> Result<Value, anyhow::Error> {
-    let external = format!("pkh([{}/44'/1'/0']{}/0/*)", "00000000", key);
-    let internal = format!("pkh([{}/44'/1'/0']{}/1/*)", "00000000", key);
+    let secp = Secp256k1::new();
+    let derivation_path: DerivationPath = "m/44h/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_pkh(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_pkh(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": "bip44",
-        "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()
     }))
 }