feat(miniscript): add auto-detection of descriptor type

Add fromStringDetectType() that auto-detects whether a descriptor contains
wildcards. If it does, returns a derivable descriptor, otherwise a definite
one.

Issue: BTC-1826

Author: OttoAllmendinger

packages/wasm-miniscript/js/index.ts

@@ -20,6 +20,7 @@ declare module "./wasm/wasm_miniscript" {
 
   namespace WrapDescriptor {
     function fromString(descriptor: string, pkType: DescriptorPkType): WrapDescriptor;
+    function fromStringDetectType(descriptor: string): WrapDescriptor;
   }
 
   interface WrapMiniscript {

packages/wasm-miniscript/src/descriptor.rs

@@ -1,6 +1,6 @@
 use crate::error::WasmMiniscriptError;
 use crate::try_into_js_value::TryIntoJsValue;
-use miniscript::bitcoin::secp256k1::Secp256k1;
+use miniscript::bitcoin::secp256k1::{Context, Secp256k1, Signing};
 use miniscript::bitcoin::ScriptBuf;
 use miniscript::descriptor::KeyMap;
 use miniscript::{DefiniteDescriptorKey, Descriptor, DescriptorPublicKey};
@@ -71,7 +71,9 @@ impl WrapDescriptor {
     pub fn script_pubkey(&self) -> Result<Vec<u8>, WasmMiniscriptError> {
         match &self.0 {
             WrapDescriptorEnum::Definite(desc) => Ok(desc.script_pubkey().to_bytes()),
-            _ => Err(WasmMiniscriptError::new("Cannot derive from a non-definite descriptor")),
+            _ => Err(WasmMiniscriptError::new(
+                "Cannot encode a derivable descriptor",
+            )),
         }
     }
 
@@ -109,8 +111,10 @@ impl WrapDescriptor {
             .map_err(|_| WasmMiniscriptError::new("Weight exceeds u32"))
     }
 
-    fn from_string_derivable(descriptor: &str) -> Result<WrapDescriptor, WasmMiniscriptError> {
-        let secp = Secp256k1::new();
+    fn from_string_derivable<C: Signing>(
+        secp: &Secp256k1<C>,
+        descriptor: &str,
+    ) -> Result<WrapDescriptor, WasmMiniscriptError> {
         let (desc, keys) = Descriptor::parse_descriptor(&secp, descriptor)?;
         Ok(WrapDescriptor(WrapDescriptorEnum::Derivable(desc, keys)))
     }
@@ -120,13 +124,35 @@ impl WrapDescriptor {
         Ok(WrapDescriptor(WrapDescriptorEnum::Definite(desc)))
     }
 
+    /// Parse a descriptor string with an explicit public key type.
+    ///
+    /// Note that this function permits parsing a non-derivable descriptor with a derivable key type.
+    /// Use `from_string_detect_type` to automatically detect the key type.
+    ///
+    /// # Arguments
+    /// * `descriptor` - A string containing the descriptor to parse
+    /// * `pk_type` - The type of public key to expect:
+    ///   - "derivable": For descriptors containing derivation paths (eg. xpubs)
+    ///   - "definite": For descriptors with fully specified keys
+    ///   - "string": For descriptors with string placeholders
+    ///
+    /// # Returns
+    /// * `Result<WrapDescriptor, WasmMiniscriptError>` - The parsed descriptor or an error
+    ///
+    /// # Example
+    /// ```
+    /// let desc = WrapDescriptor::from_string(
+    ///   "pk(xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8/*)",
+    ///   "derivable"
+    /// );
+    /// ```
     #[wasm_bindgen(js_name = fromString, skip_typescript)]
     pub fn from_string(
         descriptor: &str,
         pk_type: &str,
     ) -> Result<WrapDescriptor, WasmMiniscriptError> {
         match pk_type {
-            "derivable" => WrapDescriptor::from_string_derivable(descriptor),
+            "derivable" => WrapDescriptor::from_string_derivable(&Secp256k1::new(), descriptor),
             "definite" => WrapDescriptor::from_string_definite(descriptor),
             "string" => {
                 let desc = Descriptor::<String>::from_str(descriptor)?;
@@ -135,4 +161,71 @@ impl WrapDescriptor {
             _ => Err(WasmMiniscriptError::new("Invalid descriptor type")),
         }
     }
-}
+
+    /// Parse a descriptor string, automatically detecting the appropriate public key type.
+    /// This will check if the descriptor contains wildcards to determine if it should be
+    /// parsed as derivable or definite.
+    ///
+    /// # Arguments
+    /// * `descriptor` - A string containing the descriptor to parse
+    ///
+    /// # Returns
+    /// * `Result<WrapDescriptor, WasmMiniscriptError>` - The parsed descriptor or an error
+    ///
+    /// # Example
+    /// ```
+    /// // Will be parsed as definite since it has no wildcards
+    /// let desc = WrapDescriptor::from_string_detect_type(
+    ///   "pk(02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5)"
+    /// );
+    ///
+    /// // Will be parsed as derivable since it contains a wildcard (*)
+    /// let desc = WrapDescriptor::from_string_detect_type(
+    ///   "pk(xpub.../0/*)"
+    /// );
+    /// ```
+    #[wasm_bindgen(js_name = fromStringDetectType, skip_typescript)]
+    pub fn from_string_detect_type(
+        descriptor: &str,
+    ) -> Result<WrapDescriptor, WasmMiniscriptError> {
+        let secp = Secp256k1::new();
+        let (descriptor, _key_map) = Descriptor::parse_descriptor(&secp, descriptor)
+            .map_err(|_| WasmMiniscriptError::new("Invalid descriptor"))?;
+        if descriptor.has_wildcard() {
+            WrapDescriptor::from_string_derivable(&secp, &descriptor.to_string())
+        } else {
+            WrapDescriptor::from_string_definite(&descriptor.to_string())
+        }
+    }
+}
+
+impl FromStr for WrapDescriptor {
+    type Err = WasmMiniscriptError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        WrapDescriptor::from_string_detect_type(s)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::WrapDescriptor;
+
+    #[test]
+    fn test_detect_type() {
+        let desc = WrapDescriptor::from_string_detect_type(
+            "pk(L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)",
+        )
+        .unwrap();
+
+        assert_eq!(desc.has_wildcard(), false);
+        assert_eq!(
+            match desc {
+                WrapDescriptor {
+                    0: crate::descriptor::WrapDescriptorEnum::Definite(_),
+                } => true,
+                _ => false,
+            },
+            true
+        );
+    }
+}

packages/wasm-miniscript/test/test.ts

@@ -84,6 +84,10 @@ describe("Descriptor fixtures", function () {
         // return;
       }
 
+      it("should detect descriptor type", function () {
+        Descriptor.fromStringDetectType(fixture.descriptor);
+      });
+
       it("should round-trip (pkType string)", function () {
         let descriptorString = Descriptor.fromString(fixture.descriptor, "string").toString();
         if (fixture.checksumRequired === false) {