Merge pull request #219 from apoelstra/2021-01--wpk-improvements

some improvements to DescriptorPublicKey

Author: apoelstra

src/descriptor/bare.rs

@@ -26,7 +26,10 @@ use expression::{self, FromTree};
 use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};
 use util::{varint_len, witness_to_scriptsig};
-use {BareCtx, Error, Miniscript, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk};
+use {
+    BareCtx, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
+    TranslatePk,
+};
 
 use super::{
     checksum::{desc_checksum, verify_checksum},
@@ -163,6 +166,16 @@ where
     }
 }
 
+impl<Pk: MiniscriptKey> ForEachKey<Pk> for Bare<Pk> {
+    fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, pred: F) -> bool
+    where
+        Pk: 'a,
+        Pk::Hash: 'a,
+    {
+        self.ms.for_each_key(pred)
+    }
+}
+
 impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Bare<P> {
     type Output = Bare<Q>;
 
@@ -327,6 +340,16 @@ where
     }
 }
 
+impl<Pk: MiniscriptKey> ForEachKey<Pk> for Pkh<Pk> {
+    fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, mut pred: F) -> bool
+    where
+        Pk: 'a,
+        Pk::Hash: 'a,
+    {
+        pred(ForEach::Key(&self.pk))
+    }
+}
+
 impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Pkh<P> {
     type Output = Pkh<Q>;
 

src/descriptor/key.rs

@@ -3,9 +3,11 @@ use std::{error, fmt, str::FromStr};
 use bitcoin::{
     self,
     hashes::hex::FromHex,
+    hashes::Hash,
     secp256k1,
     secp256k1::{Secp256k1, Signing},
     util::bip32,
+    XpubIdentifier,
 };
 
 use MiniscriptKey;
@@ -343,6 +345,61 @@ impl fmt::Display for ConversionError {
 impl error::Error for ConversionError {}
 
 impl DescriptorPublicKey {
+    /// The fingerprint of the master key associated with this key
+    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::SinglePub(ref single) => {
+                if let Some((fingerprint, _)) = single.origin {
+                    fingerprint
+                } else {
+                    let mut engine = XpubIdentifier::engine();
+                    single.key.write_into(&mut engine);
+                    bip32::Fingerprint::from(&XpubIdentifier::from_engine(engine)[..])
+                }
+            }
+        }
+    }
+
+    /// 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)
+    pub fn full_derivation_path(&self) -> 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![])
+                };
+                origin_path.extend(&xpub.derivation_path)
+            }
+            DescriptorPublicKey::SinglePub(ref single) => {
+                if let Some((_, ref path)) = single.origin {
+                    path.clone()
+                } else {
+                    bip32::DerivationPath::from(vec![])
+                }
+            }
+        }
+    }
+
+    /// Whether or not the key has a wildcards
+    pub fn is_deriveable(&self) -> bool {
+        match *self {
+            DescriptorPublicKey::SinglePub(..) => false,
+            DescriptorPublicKey::XPub(ref xpub) => xpub.wildcard != Wildcard::None,
+        }
+    }
+
     /// If this public key has a wildcard, replace it by the given index
     ///
     /// Panics if given an index ≥ 2^31
@@ -699,28 +756,60 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_wildcard() {
+        let public_key = DescriptorPublicKey::from_str("[abcdef00/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/2").unwrap();
+        assert_eq!(public_key.master_fingerprint().to_string(), "abcdef00");
+        assert_eq!(public_key.full_derivation_path().to_string(), "m/0'/1'/2");
+        assert_eq!(public_key.is_deriveable(), false);
+
+        let public_key = DescriptorPublicKey::from_str("[abcdef00/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/*").unwrap();
+        assert_eq!(public_key.master_fingerprint().to_string(), "abcdef00");
+        assert_eq!(public_key.full_derivation_path().to_string(), "m/0'/1'");
+        assert_eq!(public_key.is_deriveable(), true);
+
+        let public_key = DescriptorPublicKey::from_str("[abcdef00/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/*h").unwrap();
+        assert_eq!(public_key.master_fingerprint().to_string(), "abcdef00");
+        assert_eq!(public_key.full_derivation_path().to_string(), "m/0'/1'");
+        assert_eq!(public_key.is_deriveable(), true);
+    }
+
     #[test]
     fn test_deriv_on_xprv() {
         let secp = secp256k1::Secp256k1::signing_only();
 
         let secret_key = DescriptorSecretKey::from_str("tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/0'/1'/2").unwrap();
         let public_key = secret_key.as_public(&secp).unwrap();
         assert_eq!(public_key.to_string(), "[2cbe2a6d/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/2");
+        assert_eq!(public_key.master_fingerprint().to_string(), "2cbe2a6d");
+        assert_eq!(public_key.full_derivation_path().to_string(), "m/0'/1'/2");
+        assert_eq!(public_key.is_deriveable(), false);
 
         let secret_key = DescriptorSecretKey::from_str("tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/0'/1'/2'").unwrap();
         let public_key = secret_key.as_public(&secp).unwrap();
         assert_eq!(public_key.to_string(), "[2cbe2a6d/0'/1'/2']tpubDDPuH46rv4dbFtmF6FrEtJEy1CvLZonyBoVxF6xsesHdYDdTBrq2mHhm8AbsPh39sUwL2nZyxd6vo4uWNTU9v4t893CwxjqPnwMoUACLvMV");
+        assert_eq!(public_key.master_fingerprint().to_string(), "2cbe2a6d");
+        assert_eq!(public_key.full_derivation_path().to_string(), "m/0'/1'/2'");
 
         let secret_key = DescriptorSecretKey::from_str("tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/0/1/2").unwrap();
         let public_key = secret_key.as_public(&secp).unwrap();
         assert_eq!(public_key.to_string(), "tpubD6NzVbkrYhZ4WQdzxL7NmJN7b85ePo4p6RSj9QQHF7te2RR9iUeVSGgnGkoUsB9LBRosgvNbjRv9bcsJgzgBd7QKuxDm23ZewkTRzNSLEDr/0/1/2");
+        assert_eq!(public_key.master_fingerprint().to_string(), "2cbe2a6d");
+        assert_eq!(public_key.full_derivation_path().to_string(), "m/0/1/2");
 
         let secret_key = DescriptorSecretKey::from_str("[aabbccdd]tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/0/1/2").unwrap();
         let public_key = secret_key.as_public(&secp).unwrap();
         assert_eq!(public_key.to_string(), "[aabbccdd]tpubD6NzVbkrYhZ4WQdzxL7NmJN7b85ePo4p6RSj9QQHF7te2RR9iUeVSGgnGkoUsB9LBRosgvNbjRv9bcsJgzgBd7QKuxDm23ZewkTRzNSLEDr/0/1/2");
+        assert_eq!(public_key.master_fingerprint().to_string(), "aabbccdd");
+        assert_eq!(public_key.full_derivation_path().to_string(), "m/0/1/2");
 
         let secret_key = DescriptorSecretKey::from_str("[aabbccdd/90']tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/0'/1'/2").unwrap();
         let public_key = secret_key.as_public(&secp).unwrap();
         assert_eq!(public_key.to_string(), "[aabbccdd/90'/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/2");
+        assert_eq!(public_key.master_fingerprint().to_string(), "aabbccdd");
+        assert_eq!(
+            public_key.full_derivation_path().to_string(),
+            "m/90'/0'/1'/2"
+        );
     }
 }

src/descriptor/mod.rs

@@ -36,7 +36,10 @@ use self::checksum::verify_checksum;
 use expression;
 use miniscript;
 use miniscript::{Legacy, Miniscript, Segwitv0};
-use {BareCtx, Error, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk, TranslatePk2};
+use {
+    BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
+    TranslatePk2,
+};
 
 mod bare;
 mod segwitv0;
@@ -424,7 +427,28 @@ where
     }
 }
 
+impl<Pk: MiniscriptKey> ForEachKey<Pk> for Descriptor<Pk> {
+    fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, pred: F) -> bool
+    where
+        Pk: 'a,
+        Pk::Hash: 'a,
+    {
+        match *self {
+            Descriptor::Bare(ref bare) => bare.for_each_key(pred),
+            Descriptor::Pkh(ref pkh) => pkh.for_each_key(pred),
+            Descriptor::Wpkh(ref wpkh) => wpkh.for_each_key(pred),
+            Descriptor::Wsh(ref wsh) => wsh.for_each_key(pred),
+            Descriptor::Sh(ref sh) => sh.for_each_key(pred),
+        }
+    }
+}
+
 impl Descriptor<DescriptorPublicKey> {
+    /// Whether or not the descriptor has any wildcards
+    pub fn is_deriveable(&self) -> bool {
+        self.for_any_key(|key| key.as_key().is_deriveable())
+    }
+
     /// Derives all wildcard keys in the descriptor using the supplied index
     ///
     /// Panics if given an index ≥ 2^31

src/descriptor/segwitv0.rs

@@ -24,7 +24,10 @@ use expression::{self, FromTree};
 use miniscript::context::{ScriptContext, ScriptContextError};
 use policy::{semantic, Liftable};
 use util::varint_len;
-use {Error, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey, TranslatePk};
+use {
+    Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey,
+    TranslatePk,
+};
 
 use super::{
     checksum::{desc_checksum, verify_checksum},
@@ -230,6 +233,19 @@ where
     }
 }
 
+impl<Pk: MiniscriptKey> ForEachKey<Pk> for Wsh<Pk> {
+    fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, pred: F) -> bool
+    where
+        Pk: 'a,
+        Pk::Hash: 'a,
+    {
+        match self.inner {
+            WshInner::SortedMulti(ref smv) => smv.for_each_key(pred),
+            WshInner::Ms(ref ms) => ms.for_each_key(pred),
+        }
+    }
+}
+
 impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Wsh<P> {
     type Output = Wsh<Q>;
 
@@ -410,6 +426,16 @@ where
     }
 }
 
+impl<Pk: MiniscriptKey> ForEachKey<Pk> for Wpkh<Pk> {
+    fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, mut pred: F) -> bool
+    where
+        Pk: 'a,
+        Pk::Hash: 'a,
+    {
+        pred(ForEach::Key(&self.pk))
+    }
+}
+
 impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Wpkh<P> {
     type Output = Wpkh<Q>;
 

src/descriptor/sh.rs

@@ -27,7 +27,10 @@ use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};
 use push_opcode_size;
 use util::{varint_len, witness_to_scriptsig};
-use {Error, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey, TranslatePk};
+use {
+    Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
+    ToPublicKey, TranslatePk,
+};
 
 use super::{
     checksum::{desc_checksum, verify_checksum},
@@ -322,6 +325,21 @@ where
     }
 }
 
+impl<Pk: MiniscriptKey> ForEachKey<Pk> for Sh<Pk> {
+    fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, pred: F) -> bool
+    where
+        Pk: 'a,
+        Pk::Hash: 'a,
+    {
+        match self.inner {
+            ShInner::Wsh(ref wsh) => wsh.for_each_key(pred),
+            ShInner::SortedMulti(ref smv) => smv.for_each_key(pred),
+            ShInner::Wpkh(ref wpkh) => wpkh.for_each_key(pred),
+            ShInner::Ms(ref ms) => ms.for_each_key(pred),
+        }
+    }
+}
+
 impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Sh<P> {
     type Output = Sh<Q>;
 

src/descriptor/sortedmulti.rs

@@ -24,7 +24,7 @@ use expression;
 use miniscript::{self, context::ScriptContext, decode::Terminal};
 use policy;
 use script_num_size;
-use {errstr, Error, Miniscript, MiniscriptKey, Satisfier, ToPublicKey};
+use {errstr, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey};
 
 /// Contents of a "sortedmulti" descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
@@ -84,9 +84,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
 
         pks.map(|pks| SortedMultiVec::new(k as usize, pks))?
     }
-}
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
     /// This will panic if translatefpk returns an uncompressed key when
     /// converting to a Segwit descriptor. To prevent this panic, ensure
     /// translatefpk returns an error in this case instead.
@@ -106,6 +104,17 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
         })
     }
 }
+
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for SortedMultiVec<Pk, Ctx> {
+    fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, mut pred: F) -> bool
+    where
+        Pk: 'a,
+        Pk::Hash: 'a,
+    {
+        self.pks.iter().all(|key| pred(ForEach::Key(key)))
+    }
+}
+
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
     /// utility function to sanity a sorted multi vec
     pub fn sanity_check(&self) -> Result<(), Error> {

src/lib.rs

@@ -404,6 +404,44 @@ impl<
 {
 }
 
+/// Either a key or a keyhash
+pub enum ForEach<'a, Pk: MiniscriptKey + 'a> {
+    /// A key
+    Key(&'a Pk),
+    /// A keyhash
+    Hash(&'a Pk::Hash),
+}
+
+impl<'a, Pk: MiniscriptKey<Hash = Pk>> ForEach<'a, Pk> {
+    /// Convenience method to avoid distinguishing between keys and hashes when these are the same type
+    pub fn as_key(&self) -> &'a Pk {
+        match *self {
+            ForEach::Key(ref_key) => ref_key,
+            ForEach::Hash(ref_key) => ref_key,
+        }
+    }
+}
+
+/// Trait describing the ability to iterate over every key
+pub trait ForEachKey<Pk: MiniscriptKey> {
+    /// Run a predicate on every key in the descriptor, returning whether
+    /// the predicate returned true for every key
+    fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, pred: F) -> bool
+    where
+        Pk: 'a,
+        Pk::Hash: 'a;
+
+    /// Run a predicate on every key in the descriptor, returning whether
+    /// the predicate returned true for any key
+    fn for_any_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, mut pred: F) -> bool
+    where
+        Pk: 'a,
+        Pk::Hash: 'a,
+    {
+        !self.for_each_key(|key| !pred(key))
+    }
+}
+
 /// Miniscript
 
 #[derive(Debug)]