Make Descriptors derivable

Signed-off-by: Antoine Poinsot <[email protected]>

Author: sgeisler

src/descriptor/mod.rs

@@ -92,6 +92,12 @@ pub struct DescriptorXPub {
 #[derive(Debug, PartialEq)]
 pub struct DescriptorKeyParseError(&'static str);
 
+impl fmt::Display for DescriptorKeyParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.0)
+    }
+}
+
 impl fmt::Display for DescriptorPublicKey {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -225,6 +231,34 @@ impl DescriptorPublicKey {
             ))
         }
     }
+
+    /// Derives a new key using the path if self is a wildcard xpub. Otehrwise returns a copy of
+    /// self.
+    ///
+    /// Panics if derivation path contains a hardened child number
+    pub fn derive(&self, path: &[bip32::ChildNumber]) -> DescriptorPublicKey {
+        assert!(path.into_iter().all(|c| c.is_normal()));
+
+        match *self {
+            DescriptorPublicKey::PukKey(ref pk) => DescriptorPublicKey::PukKey(*pk),
+            DescriptorPublicKey::XPub(ref xpub) => {
+                if xpub.is_wildcard {
+                    DescriptorPublicKey::XPub(DescriptorXPub {
+                        origin: xpub.origin.clone(),
+                        xpub: xpub.xpub.clone(),
+                        derivation_path: (&xpub.derivation_path)
+                            .into_iter()
+                            .chain(path.iter())
+                            .cloned()
+                            .collect(),
+                        is_wildcard: false,
+                    })
+                } else {
+                    self.clone()
+                }
+            }
+        }
+    }
 }
 
 impl MiniscriptKey for DescriptorPublicKey {
@@ -613,6 +647,17 @@ impl<Pk: MiniscriptKey + ToPublicKey> Descriptor<Pk> {
     }
 }
 
+impl Descriptor<DescriptorPublicKey> {
+    /// Derives all wildcard keys in the descriptor using the supplied `path`
+    pub fn derive(&self, path: &[bip32::ChildNumber]) -> Descriptor<DescriptorPublicKey> {
+        self.translate_pk(
+            |pk| Result::Ok::<DescriptorPublicKey, ()>(pk.derive(path)),
+            |pkh| Result::Ok::<hash160::Hash, ()>(*pkh),
+        )
+        .expect("Translation fn can't fail.")
+    }
+}
+
 impl<Pk> expression::FromTree for Descriptor<Pk>
 where
     Pk: MiniscriptKey,