Extract specialised DescriptorPublicKey functionality into DescriptorExtendedPublicKey

Author: Scott Robinson

src/descriptor/key.rs

@@ -18,13 +18,15 @@ use crate::prelude::*;
 use crate::serde::{Deserialize, Deserializer, Serialize, Serializer};
 use crate::{hash256, MiniscriptKey, ToPublicKey};
 
+type DescriptorExtendedPublicKey = DescriptorXKey<bip32::ExtendedPubKey>;
+
 /// The descriptor pubkey, either a single pubkey or an xpub.
 #[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)]
 pub enum DescriptorPublicKey {
     /// Single public key.
     Single(SinglePub),
     /// Extended public key (xpub).
-    XPub(DescriptorXKey<bip32::ExtendedPubKey>),
+    XPub(DescriptorExtendedPublicKey),
     /// Multiple extended public keys.
     MultiXPub(DescriptorMultiXKey<bip32::ExtendedPubKey>),
 }
@@ -283,6 +285,20 @@ impl error::Error for DescriptorKeyParseError {
     }
 }
 
+impl fmt::Display for DescriptorExtendedPublicKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        maybe_fmt_master_id(f, &self.origin)?;
+        self.xkey.fmt(f)?;
+        fmt_derivation_path(f, &self.derivation_path)?;
+        match self.wildcard {
+            Wildcard::None => {}
+            Wildcard::Unhardened => write!(f, "/*")?,
+            Wildcard::Hardened => write!(f, "/*h")?,
+        }
+        Ok(())
+    }
+}
+
 impl fmt::Display for DescriptorPublicKey {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -294,17 +310,7 @@ impl fmt::Display for DescriptorPublicKey {
                 }?;
                 Ok(())
             }
-            DescriptorPublicKey::XPub(ref xpub) => {
-                maybe_fmt_master_id(f, &xpub.origin)?;
-                xpub.xkey.fmt(f)?;
-                fmt_derivation_path(f, &xpub.derivation_path)?;
-                match xpub.wildcard {
-                    Wildcard::None => {}
-                    Wildcard::Unhardened => write!(f, "/*")?,
-                    Wildcard::Hardened => write!(f, "/*h")?,
-                }
-                Ok(())
-            }
+            DescriptorPublicKey::XPub(ref xpub) => xpub.fmt(f),
             DescriptorPublicKey::MultiXPub(ref xpub) => {
                 maybe_fmt_master_id(f, &xpub.origin)?;
                 xpub.xkey.fmt(f)?;
@@ -432,6 +438,30 @@ fn fmt_derivation_paths(f: &mut fmt::Formatter, paths: &[bip32::DerivationPath])
     Ok(())
 }
 
+impl FromStr for DescriptorExtendedPublicKey {
+    type Err = DescriptorKeyParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (key_part, origin) = parse_key_origin(s)?;
+
+        let (xpub, derivation_paths, wildcard) =
+            parse_xkey_deriv::<bip32::ExtendedPubKey>(key_part)?;
+
+        if derivation_paths.len() > 1 {
+            return Err(DescriptorKeyParseError(
+                "Multiple derivation paths are not allowed for single extended keys",
+            ));
+        }
+
+        Ok(Self {
+            origin,
+            xkey: xpub,
+            derivation_path: derivation_paths.into_iter().next().unwrap_or_default(),
+            wildcard,
+        })
+    }
+}
+
 impl FromStr for DescriptorPublicKey {
     type Err = DescriptorKeyParseError;
 
@@ -456,12 +486,7 @@ impl FromStr for DescriptorPublicKey {
                     wildcard,
                 }))
             } else {
-                Ok(DescriptorPublicKey::XPub(DescriptorXKey {
-                    origin,
-                    xkey: xpub,
-                    derivation_path: derivation_paths.into_iter().next().unwrap_or_default(),
-                    wildcard,
-                }))
+                DescriptorExtendedPublicKey::from_str(s).map(Self::XPub)
             }
         } else {
             let key = match key_part.len() {
@@ -503,13 +528,16 @@ pub enum ConversionError {
     HardenedChild,
     /// Attempted to convert a key with multiple derivation paths to a bitcoin public key
     MultiKey,
+    /// Attempted to convert a key with a wildcard to a bitcoin public key
+    Wildcard,
 }
 
 impl fmt::Display for ConversionError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(match *self {
             ConversionError::HardenedChild => "hardened child step in bip32 path",
             ConversionError::MultiKey => "multiple existing keys",
+            ConversionError::Wildcard => "wildcard in bip32 path",
         })
     }
 }
@@ -520,7 +548,7 @@ impl error::Error for ConversionError {
         use self::ConversionError::*;
 
         match self {
-            HardenedChild | MultiKey => None,
+            HardenedChild | MultiKey | Wildcard => None,
         }
     }
 }
@@ -572,17 +600,102 @@ pub trait DescriptorKey : Clone + fmt::Debug + fmt::Display + Eq + FromStr + std
         secp: &Secp256k1<C>,
     ) -> Result<bitcoin::PublicKey, ConversionError>;
 }
+
+impl DescriptorKey for DescriptorExtendedPublicKey {
+    /// The fingerprint of the master key associated with this key, `0x00000000` if none.
+    fn master_fingerprint(&self) -> bip32::Fingerprint {
+        if let Some((fingerprint, _)) = self.origin {
+            fingerprint
+        } else {
+            self.xkey.fingerprint()
+        }
+    }
+
+    /// Full path, from the master key
+    ///
+    /// For wildcard keys this will return the path up to the wildcard, so you
+    /// can get full paths by appending one additional derivation step, according
+    /// to the wildcard type (hardened or normal).
+    ///
+    /// For multipath extended keys, this returns `None`.
+    fn full_derivation_path(&self) -> Option<bip32::DerivationPath> {
+        let origin_path = if let Some((_, ref path)) = self.origin {
+            path.clone()
+        } else {
+            bip32::DerivationPath::from(vec![])
+        };
+        Some(origin_path.extend(&self.derivation_path))
+    }
+
+    /// Whether or not the key has a wildcard
+    fn has_wildcard(&self) -> bool {
+        self.wildcard != Wildcard::None
+    }
+
+    /// Replaces any wildcard (i.e. `/*`) in the key with a particular derivation index, turning it into a
+    /// *definite* key (i.e. one where all the derivation paths are set).
+    ///
+    /// # Returns
+    ///
+    /// - If this key is not an xpub, returns `self`.
+    /// - If this key is an xpub but does not have a wildcard, returns `self`.
+    /// - Otherwise, returns the xpub at derivation `index` (removing the wildcard).
+    ///
+    /// # Errors
+    ///
+    /// - If `index` is hardened.
+    fn at_derivation_index(self, index: u32) -> Result<DefiniteDescriptorKey, ConversionError> {
+        let derivation_path = match self.wildcard {
+            Wildcard::None => self.derivation_path,
+            Wildcard::Unhardened => self.derivation_path.into_child(
+                bip32::ChildNumber::from_normal_idx(index)
+                    .ok()
+                    .ok_or(ConversionError::HardenedChild)?,
+            ),
+            Wildcard::Hardened => self.derivation_path.into_child(
+                bip32::ChildNumber::from_hardened_idx(index)
+                    .ok()
+                    .ok_or(ConversionError::HardenedChild)?,
+            ),
+        };
+        let definite = DescriptorPublicKey::XPub(DescriptorXKey {
+            origin: self.origin,
+            xkey: self.xkey,
+            derivation_path,
+            wildcard: Wildcard::None,
+        });
+
+        Ok(DefiniteDescriptorKey::new(definite)
+            .expect("The key should not contain any wildcards at this point"))
+    }
+
+    /// Whether or not this key has multiple derivation paths.
+    fn is_multipath(&self) -> bool {
+        false
+    }
+
+    fn derive_public_key<C: Verification>(
+        &self,
+        secp: &Secp256k1<C>,
+    ) -> Result<bitcoin::PublicKey, ConversionError> {
+        match self.wildcard {
+            Wildcard::Unhardened | Wildcard::Hardened => Err(ConversionError::Wildcard),
+            Wildcard::None => match self.xkey.derive_pub(secp, &self.derivation_path.as_ref()) {
+                Ok(xpub) => Ok(bitcoin::PublicKey::new(xpub.public_key)),
+                Err(bip32::Error::CannotDeriveFromHardenedKey) => {
+                    Err(ConversionError::HardenedChild)
+                }
+                Err(e) => unreachable!("cryptographically unreachable: {}", e),
+            },
+        }
+    }
+}
+
 impl DescriptorPublicKey {
     /// The fingerprint of the master key associated with this key, `0x00000000` if none.
     pub fn master_fingerprint(&self) -> bip32::Fingerprint {
         match *self {
-            DescriptorPublicKey::XPub(ref xpub) => {
-                if let Some((fingerprint, _)) = xpub.origin {
-                    fingerprint
-                } else {
-                    xpub.xkey.fingerprint()
-                }
-            }
+            DescriptorPublicKey::XPub(ref xpub) => xpub.master_fingerprint(),
             DescriptorPublicKey::MultiXPub(ref xpub) => {
                 if let Some((fingerprint, _)) = xpub.origin {
                     fingerprint
@@ -620,14 +733,7 @@ impl DescriptorPublicKey {
     /// For multipath extended keys, this returns `None`.
     pub fn full_derivation_path(&self) -> Option<bip32::DerivationPath> {
         match *self {
-            DescriptorPublicKey::XPub(ref xpub) => {
-                let origin_path = if let Some((_, ref path)) = xpub.origin {
-                    path.clone()
-                } else {
-                    bip32::DerivationPath::from(vec![])
-                };
-                Some(origin_path.extend(&xpub.derivation_path))
-            }
+            DescriptorPublicKey::XPub(ref xpub) => xpub.full_derivation_path(),
             DescriptorPublicKey::Single(ref single) => {
                 Some(if let Some((_, ref path)) = single.origin {
                     path.clone()
@@ -649,7 +755,7 @@ impl DescriptorPublicKey {
     pub fn has_wildcard(&self) -> bool {
         match *self {
             DescriptorPublicKey::Single(..) => false,
-            DescriptorPublicKey::XPub(ref xpub) => xpub.wildcard != Wildcard::None,
+            DescriptorPublicKey::XPub(ref xpub) => xpub.has_wildcard(),
             DescriptorPublicKey::MultiXPub(ref xpub) => xpub.wildcard != Wildcard::None,
         }
     }
@@ -673,40 +779,19 @@ impl DescriptorPublicKey {
     ///
     /// - If `index` is hardened.
     pub fn at_derivation_index(self, index: u32) -> Result<DefiniteDescriptorKey, ConversionError> {
-        let definite = match self {
-            DescriptorPublicKey::Single(_) => self,
-            DescriptorPublicKey::XPub(xpub) => {
-                let derivation_path = match xpub.wildcard {
-                    Wildcard::None => xpub.derivation_path,
-                    Wildcard::Unhardened => xpub.derivation_path.into_child(
-                        bip32::ChildNumber::from_normal_idx(index)
-                            .ok()
-                            .ok_or(ConversionError::HardenedChild)?,
-                    ),
-                    Wildcard::Hardened => xpub.derivation_path.into_child(
-                        bip32::ChildNumber::from_hardened_idx(index)
-                            .ok()
-                            .ok_or(ConversionError::HardenedChild)?,
-                    ),
-                };
-                DescriptorPublicKey::XPub(DescriptorXKey {
-                    origin: xpub.origin,
-                    xkey: xpub.xkey,
-                    derivation_path,
-                    wildcard: Wildcard::None,
-                })
-            }
-            DescriptorPublicKey::MultiXPub(_) => return Err(ConversionError::MultiKey),
-        };
-
-        Ok(DefiniteDescriptorKey::new(definite)
-            .expect("The key should not contain any wildcards at this point"))
+        match self {
+            DescriptorPublicKey::Single(_) => Ok(DefiniteDescriptorKey::new(self)
+                .expect("The key should not contain any wildcards at this point")),
+            DescriptorPublicKey::XPub(xpub) => xpub.at_derivation_index(index),
+            DescriptorPublicKey::MultiXPub(_) => Err(ConversionError::MultiKey),
+        }
     }
 
     /// Whether or not this key has multiple derivation paths.
     pub fn is_multipath(&self) -> bool {
-        match *self {
-            DescriptorPublicKey::Single(..) | DescriptorPublicKey::XPub(..) => false,
+        match self {
+            DescriptorPublicKey::Single(..) => false,
+            DescriptorPublicKey::XPub(xpub) => xpub.is_multipath(),
             DescriptorPublicKey::MultiXPub(_) => true,
         }
     }
@@ -1083,18 +1168,7 @@ impl DefiniteDescriptorKey {
                 SinglePubKey::FullKey(pk) => Ok(pk),
                 SinglePubKey::XOnly(xpk) => Ok(xpk.to_public_key()),
             },
-            DescriptorPublicKey::XPub(ref xpk) => match xpk.wildcard {
-                Wildcard::Unhardened | Wildcard::Hardened => {
-                    unreachable!("we've excluded this error case")
-                }
-                Wildcard::None => match xpk.xkey.derive_pub(secp, &xpk.derivation_path.as_ref()) {
-                    Ok(xpub) => Ok(bitcoin::PublicKey::new(xpub.public_key)),
-                    Err(bip32::Error::CannotDeriveFromHardenedKey) => {
-                        Err(ConversionError::HardenedChild)
-                    }
-                    Err(e) => unreachable!("cryptographically unreachable: {}", e),
-                },
-            },
+            DescriptorPublicKey::XPub(ref xpk) => xpk.derive_public_key(secp),
             DescriptorPublicKey::MultiXPub(_) => {
                 unreachable!("A definite key cannot contain a multipath key.")
             }