Define a new type for derived DescriptorPublicKeys

Author: afilini

src/descriptor/key.rs

@@ -1,11 +1,10 @@
-use std::{error, fmt, str::FromStr};
+use std::{cmp, error, fmt, hash, str::FromStr};
 
 use bitcoin::{
     self,
-    hashes::Hash,
+    hashes::{hash160, Hash},
     hashes::{hex::FromHex, HashEngine},
-    secp256k1,
-    secp256k1::{Secp256k1, Signing},
+    secp256k1::{Secp256k1, Signing, Verification},
     util::bip32,
     XOnlyPublicKey, XpubIdentifier,
 };
@@ -58,6 +57,15 @@ pub enum DescriptorSecretKey {
     XPrv(DescriptorXKey<bip32::ExtendedPrivKey>),
 }
 
+/// A derived [`DescriptorPublicKey`]
+///
+/// Derived keys are guaranteed to never contain wildcards
+pub struct DerivedDescriptorKey<'secp, C: 'secp + Verification> {
+    key: DescriptorPublicKey,
+    index: u32,
+    secp: &'secp Secp256k1<C>,
+}
+
 impl fmt::Display for DescriptorSecretKey {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -438,7 +446,11 @@ impl DescriptorPublicKey {
     /// If this public key has a wildcard, replace it by the given index
     ///
     /// Panics if given an index ≥ 2^31
-    pub fn derive(mut self, index: u32) -> DescriptorPublicKey {
+    pub fn derive<'secp, C: Verification>(
+        mut self,
+        index: u32,
+        secp: &'secp Secp256k1<C>,
+    ) -> DerivedDescriptorKey<'secp, C> {
         if let DescriptorPublicKey::XPub(mut xpub) = self {
             match xpub.wildcard {
                 Wildcard::None => {}
@@ -456,7 +468,8 @@ impl DescriptorPublicKey {
             xpub.wildcard = Wildcard::None;
             self = DescriptorPublicKey::XPub(xpub);
         }
-        self
+
+        DerivedDescriptorKey::new(self, index, secp)
     }
 
     /// Computes the public key corresponding to this descriptor key.
@@ -471,7 +484,7 @@ impl DescriptorPublicKey {
     /// to avoid hardened derivation steps, start from a `DescriptorSecretKey`
     /// and call `as_public`, or call `TranslatePk2::translate_pk2` with
     /// some function which has access to secret key data.
-    pub fn derive_public_key<C: secp256k1::Verification>(
+    pub fn derive_public_key<C: Verification>(
         &self,
         secp: &Secp256k1<C>,
     ) -> Result<bitcoin::PublicKey, ConversionError> {
@@ -717,6 +730,115 @@ impl MiniscriptKey for DescriptorPublicKey {
     }
 }
 
+impl<'secp, C: Verification> DerivedDescriptorKey<'secp, C> {
+    /// Computes the raw [`bitcoin::PublicKey`] for this descriptor key.
+    ///
+    /// Will return an error if the key has any hardened derivation steps
+    /// in its path, but unlike [`DescriptorPublicKey::derive_public_key`]
+    /// this won't error in case of wildcards, because derived keys are
+    /// guaranteed to never contain one.
+    pub fn derive_public_key(&self) -> Result<bitcoin::PublicKey, ConversionError> {
+        self.key.derive_public_key(self.secp)
+    }
+
+    /// Return the derivation index of this key
+    pub fn get_index(&self) -> u32 {
+        self.index
+    }
+
+    /// Construct an instance from a descriptor key and a derivation index
+    ///
+    /// Panics if the key contains a wildcard
+    fn new(key: DescriptorPublicKey, index: u32, secp: &'secp Secp256k1<C>) -> Self {
+        if let DescriptorPublicKey::XPub(ref xpk) = &key {
+            assert!(
+                xpk.wildcard == Wildcard::None,
+                "Derived descriptor keys cannot contain any wildcards"
+            );
+        }
+
+        DerivedDescriptorKey { key, index, secp }
+    }
+}
+
+impl<'secp, C: Verification> fmt::Display for DerivedDescriptorKey<'secp, C> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("DerivedDescriptorKey")
+            .field("key", &self.key)
+            .field("index", &self.index)
+            .finish()
+    }
+}
+impl<'secp, C: Verification> fmt::Debug for DerivedDescriptorKey<'secp, C> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.key.fmt(f)
+    }
+}
+
+impl<'secp, C: Verification> PartialEq for DerivedDescriptorKey<'secp, C> {
+    fn eq(&self, other: &Self) -> bool {
+        self.key.eq(&other.key) && self.index.eq(&other.index)
+    }
+}
+impl<'secp, C: Verification> Eq for DerivedDescriptorKey<'secp, C> {}
+
+impl<'secp, C: Verification> PartialOrd for DerivedDescriptorKey<'secp, C> {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl<'secp, C: Verification> Ord for DerivedDescriptorKey<'secp, C> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.key
+            .cmp(&other.key)
+            .then_with(|| self.index.cmp(&other.index))
+    }
+}
+
+impl<'secp, C: Verification> Clone for DerivedDescriptorKey<'secp, C> {
+    fn clone(&self) -> Self {
+        DerivedDescriptorKey {
+            key: self.key.clone(),
+            index: self.index,
+            secp: self.secp,
+        }
+    }
+}
+
+impl<'secp, C: Verification> hash::Hash for DerivedDescriptorKey<'secp, C> {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.key.hash(state);
+        self.index.hash(state);
+    }
+}
+
+impl<'secp, C: Verification> MiniscriptKey for DerivedDescriptorKey<'secp, C> {
+    // This allows us to be able to derive public keys even for PkH s
+    type Hash = Self;
+
+    fn is_uncompressed(&self) -> bool {
+        self.key.is_uncompressed()
+    }
+
+    fn is_x_only_key(&self) -> bool {
+        self.key.is_x_only_key()
+    }
+
+    fn to_pubkeyhash(&self) -> Self {
+        self.clone()
+    }
+}
+
+impl<'secp, C: Verification> ToPublicKey for DerivedDescriptorKey<'secp, C> {
+    fn to_public_key(&self) -> bitcoin::PublicKey {
+        self.key.derive_public_key(&self.secp).unwrap()
+    }
+
+    fn hash_to_hash160(hash: &Self) -> hash160::Hash {
+        hash.to_public_key().to_pubkeyhash()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::{DescriptorKeyParseError, DescriptorPublicKey, DescriptorSecretKey};

src/descriptor/mod.rs

@@ -61,8 +61,9 @@ mod checksum;
 mod key;
 
 pub use self::key::{
-    ConversionError, DescriptorKeyParseError, DescriptorPublicKey, DescriptorSecretKey,
-    DescriptorSinglePriv, DescriptorSinglePub, DescriptorXKey, InnerXKey, SinglePubKey, Wildcard,
+    ConversionError, DerivedDescriptorKey, DescriptorKeyParseError, DescriptorPublicKey,
+    DescriptorSecretKey, DescriptorSinglePriv, DescriptorSinglePub, DescriptorXKey, InnerXKey,
+    SinglePubKey, Wildcard,
 };
 
 /// Alias type for a map of public key to secret key
@@ -653,8 +654,12 @@ impl Descriptor<DescriptorPublicKey> {
     ///
     /// In most cases, you would want to use [`Self::derived_descriptor`] directly to obtain
     /// a [`Descriptor<bitcoin::PublicKey>`]
-    pub fn derive(&self, index: u32) -> Descriptor<DescriptorPublicKey> {
-        self.translate_pk2_infallible(|pk| pk.clone().derive(index))
+    pub fn derive<'secp, C: secp256k1::Verification>(
+        &self,
+        index: u32,
+        secp: &'secp secp256k1::Secp256k1<C>,
+    ) -> Descriptor<DerivedDescriptorKey<'secp, C>> {
+        self.translate_pk2_infallible(|pk| pk.clone().derive(index, secp))
     }
 
     /// Derive a [`Descriptor`] with a concrete [`bitcoin::PublicKey`] at a given index
@@ -687,8 +692,8 @@ impl Descriptor<DescriptorPublicKey> {
         index: u32,
     ) -> Result<Descriptor<bitcoin::PublicKey>, ConversionError> {
         let derived = self
-            .derive(index)
-            .translate_pk2(|xpk| xpk.derive_public_key(secp))?;
+            .derive(index, secp)
+            .translate_pk2(|xpk| xpk.derive_public_key())?;
         Ok(derived)
     }
 
@@ -842,7 +847,7 @@ mod tests {
     use std::cmp;
     use std::collections::HashMap;
     use std::str::FromStr;
-    use {Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
+    use {Descriptor, DummyKey, Error, Miniscript, Satisfier};
 
     #[cfg(feature = "compiler")]
     use policy;
@@ -1586,27 +1591,26 @@ mod tests {
             let index = 5;
 
             // Parse descriptor
-            let mut desc_one = Descriptor::<DescriptorPublicKey>::from_str(raw_desc_one).unwrap();
-            let mut desc_two = Descriptor::<DescriptorPublicKey>::from_str(raw_desc_two).unwrap();
+            let desc_one = Descriptor::<DescriptorPublicKey>::from_str(raw_desc_one).unwrap();
+            let desc_two = Descriptor::<DescriptorPublicKey>::from_str(raw_desc_two).unwrap();
 
             // Same string formatting
             assert_eq!(desc_one.to_string(), raw_desc_one);
             assert_eq!(desc_two.to_string(), raw_desc_two);
 
-            // Derive a child if the descriptor is ranged
-            if raw_desc_one.contains("*") && raw_desc_two.contains("*") {
-                desc_one = desc_one.derive(index);
-                desc_two = desc_two.derive(index);
-            }
+            // Derive a child in case the descriptor is ranged. If it's not this won't have any
+            // effect
+            let desc_one = desc_one.derive(index, &secp_ctx);
+            let desc_two = desc_two.derive(index, &secp_ctx);
 
             // Same address
             let addr_one = desc_one
-                .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
+                .translate_pk2(|xpk| xpk.derive_public_key())
                 .unwrap()
                 .address(bitcoin::Network::Bitcoin)
                 .unwrap();
             let addr_two = desc_two
-                .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
+                .translate_pk2(|xpk| xpk.derive_public_key())
                 .unwrap()
                 .address(bitcoin::Network::Bitcoin)
                 .unwrap();