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,5 +1,5 @@
 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};
@@ -69,7 +69,7 @@ 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")),
         }
     }
 
@@ -105,8 +105,7 @@ 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)))
     }
@@ -116,10 +115,32 @@ 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)?;
@@ -128,4 +149,60 @@ 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) {