fixes error with default generation

Author: AmosOO7

src/commands.rs

@@ -143,7 +143,6 @@ pub struct GenerateDescriptorArgs {
     pub key: Option<String>, // Positional argument (tprv/tpub/xprv/xpub)
 }
 
-
 #[derive(Debug, Clone, PartialEq, ValueEnum)]
 pub enum ScriptType {
     Bip44,

src/descriptor_handler.rs

@@ -1,5 +1,3 @@
-use serde_json::Value;
-use serde_json::json;
 use crate::commands::GenerateDescriptorArgs;
 use anyhow::{anyhow, Result};
 use bdk_wallet::bitcoin::bip32::Xpriv;
@@ -8,40 +6,39 @@ 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 serde_json::json;
+use serde_json::Value;
 
 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;
-
- use miniscript::Tap;
+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)) => {
-            generate_multipath_descriptor(&args.network, args.r#type, key)
-        }
-        (false, Some(key)) => {
-            generate_standard_descriptor(&args.network, args.r#type, key)
-        }
+        (true, Some(key)) => generate_multipath_descriptor(&args.network, args.r#type, key),
+        (false, Some(key)) => generate_standard_descriptor(&args.network, args.r#type, key),
         (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)
             } else {
-                Err(anyhow!("Only script type 84 is supported for mnemonic-based generation"))
+                Err(anyhow!(
+                    "Only script type 84 is supported for mnemonic-based generation"
+                ))
             }
         }
-        _ => Err(anyhow!("Invalid arguments: please provide a key or a weak string")),
+        _ => Err(anyhow!(
+            "Invalid arguments: please provide a key or a weak string"
+        )),
     }
-    
 }
 
-
 pub fn generate_new_bip84_descriptor_with_mnemonic(network: Network) -> Result<serde_json::Value> {
     let secp = Secp256k1::new();
 
@@ -50,20 +47,15 @@ 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 master_xprv = Xpriv::new_master(network, &seed)
+    let xprv = Xpriv::new_master(network, &seed)
         .map_err(|e| anyhow!("Failed to create extended private key: {}", e))?;
 
-    // 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 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();
 
-    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 external_desc = format!("wpkh([{}{}]{}{})", origin, deriv_base, xprv_str, "/0/*");
+    let internal_desc = format!("wpkh([{}{}]{}{})", origin, deriv_base, xprv_str, "/1/*");
 
     let (desc, keymap) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, &external_desc)
         .map_err(|e| anyhow!("Failed to parse external descriptor: {}", e))?;
@@ -84,7 +76,6 @@ pub fn generate_new_bip84_descriptor_with_mnemonic(network: Network) -> Result<s
     }))
 }
 
-
 fn generate_multipath_descriptor(
     _network: &Network,
     script_type: u8,
@@ -127,28 +118,26 @@ pub fn generate_bip84_descriptor_from_key(
             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)?;
-    
+        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)?;
@@ -187,28 +176,25 @@ pub fn generate_bip86_descriptor_from_key(
             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)?;
-    
+        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)?;
-    
+        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)?;
-    
+        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))
     };
-    
-    
 
     let (external_pub, external_priv) = make_desc_key(0)?;
     let (internal_pub, internal_priv) = make_desc_key(1)?;
@@ -228,7 +214,6 @@ pub fn generate_bip86_descriptor_from_key(
     }))
 }
 
-
 pub fn generate_bip49_descriptor_from_key(
     network: &Network,
     key: &str,
@@ -248,28 +233,26 @@ pub fn generate_bip49_descriptor_from_key(
             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)?;
-    
+        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)?;
@@ -308,28 +291,26 @@ pub fn generate_bip44_descriptor_from_key(
             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)?;
-    
+        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)?;