Add helpers to convert from PublicKey & XOnlyPublicKey to Descriptor Keys

Author: philipr-za

src/descriptor/key.rs

@@ -9,6 +9,7 @@ use std::error;
 use bitcoin::bip32::{self, XKeyIdentifier};
 use bitcoin::hashes::{hash160, ripemd160, sha256, Hash, HashEngine};
 use bitcoin::key::XOnlyPublicKey;
+use bitcoin::key::PublicKey;
 use bitcoin::secp256k1::{Secp256k1, Signing, Verification};
 
 use crate::prelude::*;
@@ -670,6 +671,28 @@ impl FromStr for DescriptorPublicKey {
     }
 }
 
+impl From<XOnlyPublicKey> for DescriptorPublicKey {
+    fn from(key: XOnlyPublicKey) -> Self {
+        DescriptorPublicKey::Single(
+            SinglePub{
+                origin: None,
+                key: SinglePubKey::XOnly(key)
+            }
+        )
+    }
+}
+
+impl From<PublicKey> for DescriptorPublicKey {
+    fn from(key: PublicKey) -> Self {
+        DescriptorPublicKey::Single(
+            SinglePub{
+                origin: None,
+                key: SinglePubKey::FullKey(key)
+            }
+        )
+    }
+}
+
 /// Descriptor key conversion error
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
 pub enum ConversionError {
@@ -1260,7 +1283,7 @@ impl DefiniteDescriptorKey {
     /// Construct an instance from a descriptor key and a derivation index
     ///
     /// Returns `None` if the key contains a wildcard
-    fn new(key: DescriptorPublicKey) -> Option<Self> {
+    pub(crate) fn new(key: DescriptorPublicKey) -> Option<Self> {
         if key.has_wildcard() {
             None
         } else {

src/descriptor/mod.rs

@@ -17,7 +17,7 @@ use core::str::{self, FromStr};
 
 use bitcoin::hashes::{hash160, ripemd160, sha256};
 use bitcoin::{
-    secp256k1, Address, Network, Script, ScriptBuf, TxIn, Weight, Witness, WitnessVersion,
+    secp256k1, Address, Network, PublicKey, Script, ScriptBuf, TxIn, Weight, Witness, WitnessVersion, XOnlyPublicKey
 };
 use sync::Arc;
 
@@ -1040,6 +1040,49 @@ macro_rules! write_descriptor {
 }
 pub(crate) use write_descriptor;
 
+impl From<Descriptor<PublicKey>> for Descriptor<DefiniteDescriptorKey> {
+    fn from(descriptor: Descriptor<PublicKey>) -> Descriptor<DefiniteDescriptorKey> {
+        struct TranslateFullPk;
+
+        impl Translator<bitcoin::PublicKey> for TranslateFullPk {
+            type TargetPk = DefiniteDescriptorKey;
+            type Error = core::convert::Infallible;
+
+            fn pk(&mut self, pk: &bitcoin::PublicKey) -> Result<DefiniteDescriptorKey, Self::Error> {
+                Ok(DefiniteDescriptorKey::new(DescriptorPublicKey::from(pk.clone())).expect("DescriptorPublicKey from PublicKey has no wildcards"))
+            }
+
+            translate_hash_clone!(bitcoin::PublicKey, DefiniteDescriptorKey, Self::Error);
+        }
+
+        let converted_descriptor =
+            descriptor.translate_pk(&mut TranslateFullPk).expect("infallible");
+        converted_descriptor
+    }
+}
+
+impl From<Descriptor<XOnlyPublicKey>> for Descriptor<DefiniteDescriptorKey> {
+    fn from(descriptor: Descriptor<XOnlyPublicKey>) -> Descriptor<DefiniteDescriptorKey> {
+        struct TranslateXOnlyPk;
+
+        impl Translator<XOnlyPublicKey> for TranslateXOnlyPk {
+            type TargetPk = DefiniteDescriptorKey;
+            type Error = core::convert::Infallible;
+
+            fn pk(&mut self, pk: &XOnlyPublicKey) -> Result<DefiniteDescriptorKey, Self::Error> {
+                Ok(DefiniteDescriptorKey::new(DescriptorPublicKey::from(pk.clone())).expect("DescriptorPublicKey from XOnlyPublicKey has no wildcards"))
+            }
+
+            translate_hash_clone!(XOnlyPublicKey, DefiniteDescriptorKey, Self::Error);
+        }
+
+        let converted_descriptor =
+            descriptor.translate_pk(&mut TranslateXOnlyPk).expect("infallible");
+        converted_descriptor
+    }
+}
+
+
 #[cfg(test)]
 mod tests {
     use core::convert::TryFrom;
@@ -2183,4 +2226,19 @@ pk(03f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8))";
         )
         .unwrap_err();
     }
+
+    #[test]
+    fn convert_public_key_descriptor_to_definite_key() {
+        let descriptor_str = "wsh(or_d(pk(021d4ea7132d4e1a362ee5efd8d0b59dd4d1fe8906eefa7dd812b05a46b73d829b),pk(0302c8bbbb393f32c843149ce36d56405595aaabab2d0e1f4ca5f9de67dd7419f6)))";
+        let full_pk_descriptor: Descriptor<PublicKey> = Descriptor::from_str(descriptor_str).unwrap();
+
+        let definite_descriptor: Descriptor<DefiniteDescriptorKey> = full_pk_descriptor.clone().into();
+        assert_eq!(full_pk_descriptor.to_string(), definite_descriptor.to_string());
+
+        let xonly_descriptor_str = "tr(1d4ea7132d4e1a362ee5efd8d0b59dd4d1fe8906eefa7dd812b05a46b73d829b,pk(02c8bbbb393f32c843149ce36d56405595aaabab2d0e1f4ca5f9de67dd7419f6))";
+        let xonly_pk_descriptor: Descriptor<XOnlyPublicKey> = Descriptor::from_str(xonly_descriptor_str).unwrap();
+
+        let xonly_definite_descriptor: Descriptor<DefiniteDescriptorKey> = xonly_pk_descriptor.clone().into();
+        assert_eq!(xonly_pk_descriptor.to_string(), xonly_definite_descriptor.to_string());
+    }
 }