fix: allow parsing Descriptor<DescriptorPublicKey> from pk with xprv

Refactor and fix FromStr for DescriptorPublicKey so that it can parse a
xprv/tprv by doing the conversion into the DescriptorPublicKey.

Added test that reflects what was reported in the issues:
bitcoinfuzz/bitcoinfuzz#70
#785

Author: trevarj

src/descriptor/key.rs

@@ -735,50 +735,57 @@ impl FromStr for DescriptorPublicKey {
 
         let (key_part, origin) = parse_key_origin(s)?;
 
-        if key_part.contains("pub") {
-            let (xpub, derivation_paths, wildcard) = parse_xkey_deriv(key_part)?;
-            if derivation_paths.len() > 1 {
-                Ok(DescriptorPublicKey::MultiXPub(DescriptorMultiXKey {
-                    origin,
-                    xkey: xpub,
-                    derivation_paths: DerivPaths::new(derivation_paths).expect("Not empty"),
-                    wildcard,
-                }))
-            } else {
-                Ok(DescriptorPublicKey::XPub(DescriptorXKey {
-                    origin,
-                    xkey: xpub,
-                    derivation_path: derivation_paths.into_iter().next().unwrap_or_default(),
-                    wildcard,
-                }))
+        match key_part.get(..4) {
+            Some("xprv" | "tprv") => {
+                let prv = DescriptorSecretKey::from_str(s)?;
+                prv.to_public(&Secp256k1::signing_only())
             }
-        } else {
-            let key = match key_part.len() {
-                64 => {
-                    let x_only_key = XOnlyPublicKey::from_str(key_part)
-                        .map_err(DescriptorKeyParseError::XonlyPublicKey)?;
-                    SinglePubKey::XOnly(x_only_key)
+            Some("xpub" | "tpub") => {
+                let (xpub, derivation_paths, wildcard) = parse_xkey_deriv(key_part)?;
+                if derivation_paths.len() > 1 {
+                    Ok(DescriptorPublicKey::MultiXPub(DescriptorMultiXKey {
+                        origin,
+                        xkey: xpub,
+                        derivation_paths: DerivPaths::new(derivation_paths).expect("Not empty"),
+                        wildcard,
+                    }))
+                } else {
+                    Ok(DescriptorPublicKey::XPub(DescriptorXKey {
+                        origin,
+                        xkey: xpub,
+                        derivation_path: derivation_paths.into_iter().next().unwrap_or_default(),
+                        wildcard,
+                    }))
                 }
-                66 | 130 => {
-                    if !(&key_part[0..2] == "02"
-                        || &key_part[0..2] == "03"
-                        || &key_part[0..2] == "04")
-                    {
+            }
+            _ => {
+                let key = match key_part.len() {
+                    64 => {
+                        let x_only_key = XOnlyPublicKey::from_str(key_part)
+                            .map_err(DescriptorKeyParseError::XonlyPublicKey)?;
+                        SinglePubKey::XOnly(x_only_key)
+                    }
+                    66 | 130 => {
+                        if !(&key_part[0..2] == "02"
+                            || &key_part[0..2] == "03"
+                            || &key_part[0..2] == "04")
+                        {
+                            return Err(DescriptorKeyParseError::MalformedKeyData(
+                                MalformedKeyDataKind::InvalidFullPublicKeyPrefix,
+                            ));
+                        }
+                        let key = bitcoin::PublicKey::from_str(key_part)
+                            .map_err(DescriptorKeyParseError::FullPublicKey)?;
+                        SinglePubKey::FullKey(key)
+                    }
+                    _ => {
                         return Err(DescriptorKeyParseError::MalformedKeyData(
-                            MalformedKeyDataKind::InvalidFullPublicKeyPrefix,
-                        ));
+                            MalformedKeyDataKind::InvalidPublicKeyLength,
+                        ))
                     }
-                    let key = bitcoin::PublicKey::from_str(key_part)
-                        .map_err(DescriptorKeyParseError::FullPublicKey)?;
-                    SinglePubKey::FullKey(key)
-                }
-                _ => {
-                    return Err(DescriptorKeyParseError::MalformedKeyData(
-                        MalformedKeyDataKind::InvalidPublicKeyLength,
-                    ))
-                }
-            };
-            Ok(DescriptorPublicKey::Single(SinglePub { key, origin }))
+                };
+                Ok(DescriptorPublicKey::Single(SinglePub { key, origin }))
+            }
         }
     }
 }
@@ -1952,4 +1959,13 @@ mod test {
             .unwrap();
         assert_eq!(single_key.xkey_network(), None);
     }
+
+    // https://github.com/bitcoinfuzz/bitcoinfuzz/issues/70
+    // https://github.com/rust-bitcoin/rust-miniscript/issues/785
+    #[test]
+    fn can_parse_pk_from_xprv() {
+        assert!("pk(xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U/*)".parse::<crate::Descriptor::<DescriptorPublicKey>>().is_ok());
+        // xprv containing "pub"
+        assert!("pk(xprv9s21ZrQH143K3MByafknWupz9D5c3Wz3MrAZpC5KFxUuwwbefg6BVSWFwyUbEcqxGTpubCGtQyC3m3vm8rZkmN1TNoc7n6VdZBt5NeXdxwV/*)".parse::<crate::Descriptor::<DescriptorPublicKey>>().is_ok());
+    }
 }