update

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,
@@ -132,23 +131,22 @@ pub enum CliSubCommand {
 }
 #[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,
+    #[clap(long)]
+    pub network: Network,
+
+    #[clap(long, value_parser = clap::value_parser!(u8).range(44..=86))]
+    pub r#type: u8, // 44, 49, 84, 86
 
-    /// 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,
+    pub weak: Option<String>, // If present, user supplied a weak string
 
-    /// Specify the network: bitcoin, testnet, regtest, signet
-    #[clap(long, default_value = "testnet")]
-    pub network: Network,
+    pub key: Option<String>, // Positional argument (tprv/tpub/xprv/xpub)
 }
 
+
 #[derive(Debug, Clone, PartialEq, ValueEnum)]
 pub enum ScriptType {
     Bip44,

src/descriptor_handler.rs

@@ -1,37 +1,41 @@
-use crate::commands::{GenerateDescriptorArgs, ScriptType};
+use serde_json::Value;
+use serde_json::json;
+use crate::commands::GenerateDescriptorArgs;
 use anyhow::{anyhow, Result};
 use bdk_wallet::bitcoin::bip32::Xpriv;
 use bdk_wallet::bitcoin::secp256k1::Secp256k1;
-use bdk_wallet::bitcoin::Network as BdkNetwork;
 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};
 
-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)
+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)
         }
-        _ => Err(anyhow!("Script type not supported yet")),
+        (None, true, Some(key)) => {
+            generate_multipath_descriptor(&args.network, args.r#type, key)
+        }
+        (None, false, Some(key)) => {
+            generate_standard_descriptor(&args.network, args.r#type, key)
+        }
+        (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)
+            } else {
+                Err(anyhow!("Only script type 84 is supported for mnemonic-based generation"))
+            }
+        }
+        _ => Err(anyhow!("Invalid arguments: please provide a key or a weak string")),
     }
+    
 }
 
-pub fn generate_bip84_descriptor(network: Network) -> Result<serde_json::Value> {
+
+pub fn generate_new_bip84_descriptor_with_mnemonic(network: Network) -> Result<serde_json::Value> {
     let secp = Secp256k1::new();
 
     let mnemonic: GeneratedKey<Mnemonic, Segwitv0> =
@@ -67,3 +71,98 @@ pub fn generate_bip84_descriptor(network: Network) -> Result<serde_json::Value>
         }
     }))
 }
+
+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,
+    script_type: u8,
+    key: &str,
+) -> Result<Value, anyhow::Error> {
+    // TODO: Implement multipath logic
+    Ok(json!({ "multipath": true, "key": key, "type": script_type }))
+}
+
+fn generate_standard_descriptor(
+    network: &Network,
+    script_type: u8,
+    key: &str,
+) -> Result<Value, anyhow::Error> {
+    match script_type {
+        84 => generate_bip84_descriptor_from_key(network, key),
+        86 => generate_bip86_descriptor_from_key(network, key),
+        49 => generate_bip49_descriptor_from_key(network, key),
+        44 => generate_bip44_descriptor_from_key(network, key),
+        _ => Err(anyhow!("Unsupported script type")),
+    }
+}
+
+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");
+
+    Ok(json!({
+        "type": "bip84",
+        "external": external,
+        "internal": internal,
+        "network": network.to_string()
+    }))
+}
+
+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);
+
+    Ok(json!({
+        "type": "bip86",
+        "external": external,
+        "internal": internal,
+        "network": network.to_string()
+    }))
+}
+
+
+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);
+
+    Ok(json!({
+        "type": "bip49",
+        "external": external,
+        "internal": internal,
+        "network": network.to_string()
+    }))
+}
+
+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);
+
+    Ok(json!({
+        "type": "bip44",
+        "external": external,
+        "internal": internal,
+        "network": network.to_string()
+    }))
+}