Extract specialised DescriptorPublicKey functionality into DescriptorSinglePublicKey

Author: Scott Robinson

src/descriptor/key.rs

@@ -18,6 +18,7 @@ use crate::prelude::*;
 use crate::serde::{Deserialize, Deserializer, Serialize, Serializer};
 use crate::{hash256, MiniscriptKey, ToPublicKey};
 
+type DescriptorSinglePublicKey = SinglePub;
 type DescriptorExtendedPublicKey = DescriptorXKey<bip32::ExtendedPubKey>;
 
 /// The descriptor pubkey, either a single pubkey or an xpub.
@@ -285,6 +286,16 @@ impl error::Error for DescriptorKeyParseError {
     }
 }
 
+impl fmt::Display for DescriptorSinglePublicKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        maybe_fmt_master_id(f, &self.origin)?;
+        match self.key {
+            SinglePubKey::FullKey(full_key) => full_key.fmt(f),
+            SinglePubKey::XOnly(x_only_key) => x_only_key.fmt(f),
+        }
+    }
+}
+
 impl fmt::Display for DescriptorExtendedPublicKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         maybe_fmt_master_id(f, &self.origin)?;
@@ -302,14 +313,7 @@ impl fmt::Display for DescriptorExtendedPublicKey {
 impl fmt::Display for DescriptorPublicKey {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            DescriptorPublicKey::Single(ref pk) => {
-                maybe_fmt_master_id(f, &pk.origin)?;
-                match pk.key {
-                    SinglePubKey::FullKey(full_key) => full_key.fmt(f),
-                    SinglePubKey::XOnly(x_only_key) => x_only_key.fmt(f),
-                }?;
-                Ok(())
-            }
+            DescriptorPublicKey::Single(ref pk) => pk.fmt(f),
             DescriptorPublicKey::XPub(ref xpub) => xpub.fmt(f),
             DescriptorPublicKey::MultiXPub(ref xpub) => {
                 maybe_fmt_master_id(f, &xpub.origin)?;
@@ -582,6 +586,60 @@ pub trait DescriptorInnerKey {
     ) -> Result<bitcoin::PublicKey, ConversionError>;
 }
 
+impl DescriptorInnerKey for DescriptorSinglePublicKey {
+    fn master_fingerprint(&self) -> bip32::Fingerprint {
+        if let Some((fingerprint, _)) = self.origin {
+            fingerprint
+        } else {
+            let mut engine = XpubIdentifier::engine();
+            match self.key {
+                SinglePubKey::FullKey(pk) => {
+                    pk.write_into(&mut engine).expect("engines don't error")
+                }
+                SinglePubKey::XOnly(x_only_pk) => engine.input(&x_only_pk.serialize()),
+            };
+            bip32::Fingerprint::from(
+                &XpubIdentifier::from_engine(engine)[..4]
+                    .try_into()
+                    .expect("4 byte slice"),
+            )
+        }
+    }
+
+    fn full_derivation_path(&self) -> Option<bip32::DerivationPath> {
+        Some(if let Some((_, ref path)) = self.origin {
+            path.clone()
+        } else {
+            bip32::DerivationPath::from(vec![])
+        })
+    }
+
+    fn has_wildcard(&self) -> bool {
+        false
+    }
+
+    fn at_derivation_index(self, _index: u32) -> Result<DefiniteDescriptorKey, ConversionError> {
+        Ok(
+            DefiniteDescriptorKey::new(DescriptorPublicKey::Single(self))
+                .expect("The key should not contain any wildcards at this point"),
+        )
+    }
+
+    fn is_multipath(&self) -> bool {
+        false
+    }
+
+    fn derive_public_key<C: Verification>(
+        &self,
+        _secp: &Secp256k1<C>,
+    ) -> Result<bitcoin::PublicKey, ConversionError> {
+        match self.key {
+            SinglePubKey::FullKey(pk) => Ok(pk),
+            SinglePubKey::XOnly(xpk) => Ok(xpk.to_public_key()),
+        }
+    }
+}
+
 impl DescriptorInnerKey for DescriptorExtendedPublicKey {
     /// The fingerprint of the master key associated with this key, `0x00000000` if none.
     fn master_fingerprint(&self) -> bip32::Fingerprint {
@@ -684,24 +742,7 @@ impl DescriptorPublicKey {
                     xpub.xkey.fingerprint()
                 }
             }
-            DescriptorPublicKey::Single(ref single) => {
-                if let Some((fingerprint, _)) = single.origin {
-                    fingerprint
-                } else {
-                    let mut engine = XpubIdentifier::engine();
-                    match single.key {
-                        SinglePubKey::FullKey(pk) => {
-                            pk.write_into(&mut engine).expect("engines don't error")
-                        }
-                        SinglePubKey::XOnly(x_only_pk) => engine.input(&x_only_pk.serialize()),
-                    };
-                    bip32::Fingerprint::from(
-                        &XpubIdentifier::from_engine(engine)[..4]
-                            .try_into()
-                            .expect("4 byte slice"),
-                    )
-                }
-            }
+            DescriptorPublicKey::Single(ref single) => single.master_fingerprint(),
         }
     }
 
@@ -715,13 +756,7 @@ impl DescriptorPublicKey {
     pub fn full_derivation_path(&self) -> Option<bip32::DerivationPath> {
         match *self {
             DescriptorPublicKey::XPub(ref xpub) => xpub.full_derivation_path(),
-            DescriptorPublicKey::Single(ref single) => {
-                Some(if let Some((_, ref path)) = single.origin {
-                    path.clone()
-                } else {
-                    bip32::DerivationPath::from(vec![])
-                })
-            }
+            DescriptorPublicKey::Single(ref single) => single.full_derivation_path(),
             DescriptorPublicKey::MultiXPub(_) => None,
         }
     }
@@ -735,7 +770,7 @@ impl DescriptorPublicKey {
     /// Whether or not the key has a wildcard
     pub fn has_wildcard(&self) -> bool {
         match *self {
-            DescriptorPublicKey::Single(..) => false,
+            DescriptorPublicKey::Single(ref single) => single.has_wildcard(),
             DescriptorPublicKey::XPub(ref xpub) => xpub.has_wildcard(),
             DescriptorPublicKey::MultiXPub(ref xpub) => xpub.wildcard != Wildcard::None,
         }
@@ -761,8 +796,7 @@ impl DescriptorPublicKey {
     /// - If `index` is hardened.
     pub fn at_derivation_index(self, index: u32) -> Result<DefiniteDescriptorKey, ConversionError> {
         match self {
-            DescriptorPublicKey::Single(_) => Ok(DefiniteDescriptorKey::new(self)
-                .expect("The key should not contain any wildcards at this point")),
+            DescriptorPublicKey::Single(single) => single.at_derivation_index(index),
             DescriptorPublicKey::XPub(xpub) => xpub.at_derivation_index(index),
             DescriptorPublicKey::MultiXPub(_) => Err(ConversionError::MultiKey),
         }
@@ -771,7 +805,7 @@ impl DescriptorPublicKey {
     /// Whether or not this key has multiple derivation paths.
     pub fn is_multipath(&self) -> bool {
         match self {
-            DescriptorPublicKey::Single(..) => false,
+            DescriptorPublicKey::Single(single) => single.is_multipath(),
             DescriptorPublicKey::XPub(xpub) => xpub.is_multipath(),
             DescriptorPublicKey::MultiXPub(_) => true,
         }
@@ -1145,10 +1179,7 @@ impl DefiniteDescriptorKey {
         secp: &Secp256k1<C>,
     ) -> Result<bitcoin::PublicKey, ConversionError> {
         match self.0 {
-            DescriptorPublicKey::Single(ref pk) => match pk.key {
-                SinglePubKey::FullKey(pk) => Ok(pk),
-                SinglePubKey::XOnly(xpk) => Ok(xpk.to_public_key()),
-            },
+            DescriptorPublicKey::Single(ref pk) => pk.derive_public_key(secp),
             DescriptorPublicKey::XPub(ref xpk) => xpk.derive_public_key(secp),
             DescriptorPublicKey::MultiXPub(_) => {
                 unreachable!("A definite key cannot contain a multipath key.")