Use bitcoin::SchnorrSig type from rust-bitcoin

Author: sanket1729

src/interpreter/error.rs

@@ -37,6 +37,8 @@ pub enum Error {
     IncorrectWScriptHash,
     /// MultiSig missing at least `1` witness elements out of `k + 1` required
     InsufficientSignaturesMultiSig,
+    /// Invalid Sighash type
+    InvalidSchnorrSigHashType(Vec<u8>),
     /// Signature failed to verify
     InvalidSignature(bitcoin::PublicKey),
     /// Last byte of this signature isn't a standard sighash type
@@ -138,6 +140,13 @@ impl fmt::Display for Error {
             }
             Error::IncorrectWScriptHash => f.write_str("witness script did not match scriptpubkey"),
             Error::InsufficientSignaturesMultiSig => f.write_str("Insufficient signatures for CMS"),
+            Error::InvalidSchnorrSigHashType(ref sig) => {
+                write!(
+                    f,
+                    "Invalid sighash type for schnorr signature '{}'",
+                    sig.to_hex()
+                )
+            }
             Error::InvalidSignature(pk) => write!(f, "bad signature with pk {}", pk),
             Error::NonStandardSigHash(ref sig) => {
                 write!(

src/miniscript/satisfy.rs

@@ -46,6 +46,11 @@ pub trait Satisfier<Pk: MiniscriptKey + ToPublicKey> {
         None
     }
 
+    /// Given a public key, look up an schnorr signature with that key
+    fn lookup_schnorr_sig(&self, _: &Pk) -> Option<bitcoin::SchnorrSig> {
+        None
+    }
+
     /// Given a `Pkh`, lookup corresponding `Pk`
     fn lookup_pkh_pk(&self, _: &Pk::Hash) -> Option<Pk> {
         None
@@ -62,6 +67,17 @@ pub trait Satisfier<Pk: MiniscriptKey + ToPublicKey> {
         None
     }
 
+    /// Given a keyhash, look up the schnorr signature and the associated key
+    /// Even if signatures for public key Hashes are not available, the users
+    /// can use this map to provide pkh -> pk mapping which can be useful
+    /// for dissatisfying pkh.
+    fn lookup_pkh_schnorr_sig(
+        &self,
+        _: &Pk::Hash,
+    ) -> Option<(bitcoin::PublicKey, bitcoin::SchnorrSig)> {
+        None
+    }
+
     /// Given a SHA256 hash, look up its preimage
     fn lookup_sha256(&self, _: sha256::Hash) -> Option<Preimage32> {
         None
@@ -142,6 +158,12 @@ impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for HashMap<Pk, bitcoin::Ecd
     }
 }
 
+impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for HashMap<Pk, bitcoin::SchnorrSig> {
+    fn lookup_schnorr_sig(&self, key: &Pk) -> Option<bitcoin::SchnorrSig> {
+        self.get(key).map(|x| *x)
+    }
+}
+
 impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for HashMap<Pk::Hash, (Pk, bitcoin::EcdsaSig)>
 where
     Pk: MiniscriptKey + ToPublicKey,
@@ -163,11 +185,36 @@ where
     }
 }
 
+impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for HashMap<Pk::Hash, (Pk, bitcoin::SchnorrSig)>
+where
+    Pk: MiniscriptKey + ToPublicKey,
+{
+    fn lookup_schnorr_sig(&self, key: &Pk) -> Option<bitcoin::SchnorrSig> {
+        self.get(&key.to_pubkeyhash()).map(|x| x.1)
+    }
+
+    fn lookup_pkh_pk(&self, pk_hash: &Pk::Hash) -> Option<Pk> {
+        self.get(pk_hash).map(|x| x.0.clone())
+    }
+
+    fn lookup_pkh_schnorr_sig(
+        &self,
+        pk_hash: &Pk::Hash,
+    ) -> Option<(bitcoin::PublicKey, bitcoin::SchnorrSig)> {
+        self.get(pk_hash)
+            .map(|&(ref pk, sig)| (pk.to_public_key(), sig))
+    }
+}
+
 impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'a S {
     fn lookup_ecdsa_sig(&self, p: &Pk) -> Option<bitcoin::EcdsaSig> {
         (**self).lookup_ecdsa_sig(p)
     }
 
+    fn lookup_schnorr_sig(&self, p: &Pk) -> Option<bitcoin::SchnorrSig> {
+        (**self).lookup_schnorr_sig(p)
+    }
+
     fn lookup_pkh_pk(&self, pkh: &Pk::Hash) -> Option<Pk> {
         (**self).lookup_pkh_pk(pkh)
     }
@@ -179,6 +226,13 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'
         (**self).lookup_pkh_ecdsa_sig(pkh)
     }
 
+    fn lookup_pkh_schnorr_sig(
+        &self,
+        pkh: &Pk::Hash,
+    ) -> Option<(bitcoin::PublicKey, bitcoin::SchnorrSig)> {
+        (**self).lookup_pkh_schnorr_sig(pkh)
+    }
+
     fn lookup_sha256(&self, h: sha256::Hash) -> Option<Preimage32> {
         (**self).lookup_sha256(h)
     }
@@ -209,6 +263,10 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'
         (**self).lookup_ecdsa_sig(p)
     }
 
+    fn lookup_schnorr_sig(&self, p: &Pk) -> Option<bitcoin::SchnorrSig> {
+        (**self).lookup_schnorr_sig(p)
+    }
+
     fn lookup_pkh_pk(&self, pkh: &Pk::Hash) -> Option<Pk> {
         (**self).lookup_pkh_pk(pkh)
     }
@@ -220,6 +278,13 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'
         (**self).lookup_pkh_ecdsa_sig(pkh)
     }
 
+    fn lookup_pkh_schnorr_sig(
+        &self,
+        pkh: &Pk::Hash,
+    ) -> Option<(bitcoin::PublicKey, bitcoin::SchnorrSig)> {
+        (**self).lookup_pkh_schnorr_sig(pkh)
+    }
+
     fn lookup_sha256(&self, h: sha256::Hash) -> Option<Preimage32> {
         (**self).lookup_sha256(h)
     }
@@ -263,6 +328,16 @@ macro_rules! impl_tuple_satisfier {
                 None
             }
 
+            fn lookup_schnorr_sig(&self, key: &Pk) -> Option<bitcoin::SchnorrSig> {
+                let &($(ref $ty,)*) = self;
+                $(
+                    if let Some(result) = $ty.lookup_schnorr_sig(key) {
+                        return Some(result);
+                    }
+                )*
+                None
+            }
+
             fn lookup_pkh_ecdsa_sig(
                 &self,
                 key_hash: &Pk::Hash,
@@ -276,6 +351,19 @@ macro_rules! impl_tuple_satisfier {
                 None
             }
 
+            fn lookup_pkh_schnorr_sig(
+                &self,
+                key_hash: &Pk::Hash,
+            ) -> Option<(bitcoin::PublicKey, bitcoin::SchnorrSig)> {
+                let &($(ref $ty,)*) = self;
+                $(
+                    if let Some(result) = $ty.lookup_pkh_schnorr_sig(key_hash) {
+                        return Some(result);
+                    }
+                )*
+                None
+            }
+
             fn lookup_pkh_pk(
                 &self,
                 key_hash: &Pk::Hash,