Merge pull request #227 from sanket1729/psbt_hash

apoelstra · web-flow · commit 34a73ec840b8 · 2021-01-27T18:37:43.000Z
Add psbt preimage satisfaction logic
diff --git a/src/lib.rs b/src/lib.rs
@@ -127,7 +127,7 @@ pub use descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 pub use interpreter::Interpreter;
 pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0};
 pub use miniscript::decode::Terminal;
-pub use miniscript::satisfy::{BitcoinSig, Satisfier};
+pub use miniscript::satisfy::{BitcoinSig, Preimage32, Satisfier};
 pub use miniscript::Miniscript;
 
 ///Public key trait which can be converted to Hash type
diff --git a/src/miniscript/satisfy.rs b/src/miniscript/satisfy.rs
@@ -37,6 +37,8 @@ use Terminal;
 
 /// Type alias for a signature/hashtype pair
 pub type BitcoinSig = (secp256k1::Signature, bitcoin::SigHashType);
+/// Type alias for 32 byte Preimage.
+pub type Preimage32 = [u8; 32];
 
 /// Helper function to create BitcoinSig from Rawsig
 /// Useful for downstream when implementing Satisfier.
@@ -71,22 +73,22 @@ pub trait Satisfier<Pk: MiniscriptKey + ToPublicKey> {
     }
 
     /// Given a SHA256 hash, look up its preimage
-    fn lookup_sha256(&self, _: sha256::Hash) -> Option<[u8; 32]> {
+    fn lookup_sha256(&self, _: sha256::Hash) -> Option<Preimage32> {
         None
     }
 
     /// Given a HASH256 hash, look up its preimage
-    fn lookup_hash256(&self, _: sha256d::Hash) -> Option<[u8; 32]> {
+    fn lookup_hash256(&self, _: sha256d::Hash) -> Option<Preimage32> {
         None
     }
 
     /// Given a RIPEMD160 hash, look up its preimage
-    fn lookup_ripemd160(&self, _: ripemd160::Hash) -> Option<[u8; 32]> {
+    fn lookup_ripemd160(&self, _: ripemd160::Hash) -> Option<Preimage32> {
         None
     }
 
     /// Given a HASH160 hash, look up its preimage
-    fn lookup_hash160(&self, _: hash160::Hash) -> Option<[u8; 32]> {
+    fn lookup_hash160(&self, _: hash160::Hash) -> Option<Preimage32> {
         None
     }
 
@@ -181,19 +183,19 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'
         (**self).lookup_pkh_sig(pkh)
     }
 
-    fn lookup_sha256(&self, h: sha256::Hash) -> Option<[u8; 32]> {
+    fn lookup_sha256(&self, h: sha256::Hash) -> Option<Preimage32> {
         (**self).lookup_sha256(h)
     }
 
-    fn lookup_hash256(&self, h: sha256d::Hash) -> Option<[u8; 32]> {
+    fn lookup_hash256(&self, h: sha256d::Hash) -> Option<Preimage32> {
         (**self).lookup_hash256(h)
     }
 
-    fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<[u8; 32]> {
+    fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<Preimage32> {
         (**self).lookup_ripemd160(h)
     }
 
-    fn lookup_hash160(&self, h: hash160::Hash) -> Option<[u8; 32]> {
+    fn lookup_hash160(&self, h: hash160::Hash) -> Option<Preimage32> {
         (**self).lookup_hash160(h)
     }
 
@@ -219,19 +221,19 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'
         (**self).lookup_pkh_sig(pkh)
     }
 
-    fn lookup_sha256(&self, h: sha256::Hash) -> Option<[u8; 32]> {
+    fn lookup_sha256(&self, h: sha256::Hash) -> Option<Preimage32> {
         (**self).lookup_sha256(h)
     }
 
-    fn lookup_hash256(&self, h: sha256d::Hash) -> Option<[u8; 32]> {
+    fn lookup_hash256(&self, h: sha256d::Hash) -> Option<Preimage32> {
         (**self).lookup_hash256(h)
     }
 
-    fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<[u8; 32]> {
+    fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<Preimage32> {
         (**self).lookup_ripemd160(h)
     }
 
-    fn lookup_hash160(&self, h: hash160::Hash) -> Option<[u8; 32]> {
+    fn lookup_hash160(&self, h: hash160::Hash) -> Option<Preimage32> {
         (**self).lookup_hash160(h)
     }
 
@@ -288,7 +290,7 @@ macro_rules! impl_tuple_satisfier {
                 None
             }
 
-            fn lookup_sha256(&self, h: sha256::Hash) -> Option<[u8; 32]> {
+            fn lookup_sha256(&self, h: sha256::Hash) -> Option<Preimage32> {
                 let &($(ref $ty,)*) = self;
                 $(
                     if let Some(result) = $ty.lookup_sha256(h) {
@@ -298,7 +300,7 @@ macro_rules! impl_tuple_satisfier {
                 None
             }
 
-            fn lookup_hash256(&self, h: sha256d::Hash) -> Option<[u8; 32]> {
+            fn lookup_hash256(&self, h: sha256d::Hash) -> Option<Preimage32> {
                 let &($(ref $ty,)*) = self;
                 $(
                     if let Some(result) = $ty.lookup_hash256(h) {
@@ -308,7 +310,7 @@ macro_rules! impl_tuple_satisfier {
                 None
             }
 
-            fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<[u8; 32]> {
+            fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<Preimage32> {
                 let &($(ref $ty,)*) = self;
                 $(
                     if let Some(result) = $ty.lookup_ripemd160(h) {
@@ -318,7 +320,7 @@ macro_rules! impl_tuple_satisfier {
                 None
             }
 
-            fn lookup_hash160(&self, h: hash160::Hash) -> Option<[u8; 32]> {
+            fn lookup_hash160(&self, h: hash160::Hash) -> Option<Preimage32> {
                 let &($(ref $ty,)*) = self;
                 $(
                     if let Some(result) = $ty.lookup_hash160(h) {
diff --git a/src/psbt/mod.rs b/src/psbt/mod.rs
@@ -22,15 +22,16 @@
 use std::{error, fmt};
 
 use bitcoin;
+use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
 use bitcoin::secp256k1::{self, Secp256k1};
 use bitcoin::util::psbt::PartiallySignedTransaction as Psbt;
 use bitcoin::Script;
 
 use interpreter;
 use miniscript::limits::SEQUENCE_LOCKTIME_DISABLE_FLAG;
 use miniscript::satisfy::{bitcoinsig_from_rawsig, After, Older};
-use BitcoinSig;
 use Satisfier;
+use {BitcoinSig, Preimage32};
 use {MiniscriptKey, ToPublicKey};
 
 mod finalizer;
@@ -279,6 +280,44 @@ impl<'psbt, Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for PsbtInputSatisfie
             <Satisfier<Pk>>::check_older(&Older(seq), n)
         }
     }
+
+    fn lookup_hash160(&self, h: hash160::Hash) -> Option<Preimage32> {
+        self.psbt.inputs[self.index]
+            .hash160_preimages
+            .get(&h)
+            .and_then(try_vec_as_preimage32)
+    }
+
+    fn lookup_sha256(&self, h: sha256::Hash) -> Option<Preimage32> {
+        self.psbt.inputs[self.index]
+            .sha256_preimages
+            .get(&h)
+            .and_then(try_vec_as_preimage32)
+    }
+
+    fn lookup_hash256(&self, h: sha256d::Hash) -> Option<Preimage32> {
+        self.psbt.inputs[self.index]
+            .hash256_preimages
+            .get(&h)
+            .and_then(try_vec_as_preimage32)
+    }
+
+    fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<Preimage32> {
+        self.psbt.inputs[self.index]
+            .ripemd160_preimages
+            .get(&h)
+            .and_then(try_vec_as_preimage32)
+    }
+}
+
+fn try_vec_as_preimage32(vec: &Vec<u8>) -> Option<Preimage32> {
+    if vec.len() == 32 {
+        let mut arr = [0u8; 32];
+        arr.copy_from_slice(&vec);
+        Some(arr)
+    } else {
+        None
+    }
 }
 
 fn sanity_check(psbt: &Psbt) -> Result<(), Error> {

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,8 @@ use Terminal;`
`37`	`37`
`38`	`38`	`/// Type alias for a signature/hashtype pair`
`39`	`39`	`pub type BitcoinSig = (secp256k1::Signature, bitcoin::SigHashType);`
	`40`	`+/// Type alias for 32 byte Preimage.`
	`41`	`+pub type Preimage32 = [u8; 32];`
`40`	`42`
`41`	`43`	`/// Helper function to create BitcoinSig from Rawsig`
`42`	`44`	`/// Useful for downstream when implementing Satisfier.`
`@@ -71,22 +73,22 @@ pub trait Satisfier<Pk: MiniscriptKey + ToPublicKey> {`
`71`	`73`	`}`
`72`	`74`
`73`	`75`	`/// Given a SHA256 hash, look up its preimage`
`74`		`- fn lookup_sha256(&self, _: sha256::Hash) -> Option<[u8; 32]> {`
	`76`	`+ fn lookup_sha256(&self, _: sha256::Hash) -> Option<Preimage32> {`
`75`	`77`	`None`
`76`	`78`	`}`
`77`	`79`
`78`	`80`	`/// Given a HASH256 hash, look up its preimage`
`79`		`- fn lookup_hash256(&self, _: sha256d::Hash) -> Option<[u8; 32]> {`
	`81`	`+ fn lookup_hash256(&self, _: sha256d::Hash) -> Option<Preimage32> {`
`80`	`82`	`None`
`81`	`83`	`}`
`82`	`84`
`83`	`85`	`/// Given a RIPEMD160 hash, look up its preimage`
`84`		`- fn lookup_ripemd160(&self, _: ripemd160::Hash) -> Option<[u8; 32]> {`
	`86`	`+ fn lookup_ripemd160(&self, _: ripemd160::Hash) -> Option<Preimage32> {`
`85`	`87`	`None`
`86`	`88`	`}`
`87`	`89`
`88`	`90`	`/// Given a HASH160 hash, look up its preimage`
`89`		`- fn lookup_hash160(&self, _: hash160::Hash) -> Option<[u8; 32]> {`
	`91`	`+ fn lookup_hash160(&self, _: hash160::Hash) -> Option<Preimage32> {`
`90`	`92`	`None`
`91`	`93`	`}`
`92`	`94`
`@@ -181,19 +183,19 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'`
`181`	`183`	`(**self).lookup_pkh_sig(pkh)`
`182`	`184`	`}`
`183`	`185`
`184`		`- fn lookup_sha256(&self, h: sha256::Hash) -> Option<[u8; 32]> {`
	`186`	`+ fn lookup_sha256(&self, h: sha256::Hash) -> Option<Preimage32> {`
`185`	`187`	`(**self).lookup_sha256(h)`
`186`	`188`	`}`
`187`	`189`
`188`		`- fn lookup_hash256(&self, h: sha256d::Hash) -> Option<[u8; 32]> {`
	`190`	`+ fn lookup_hash256(&self, h: sha256d::Hash) -> Option<Preimage32> {`
`189`	`191`	`(**self).lookup_hash256(h)`
`190`	`192`	`}`
`191`	`193`
`192`		`- fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<[u8; 32]> {`
	`194`	`+ fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<Preimage32> {`
`193`	`195`	`(**self).lookup_ripemd160(h)`
`194`	`196`	`}`
`195`	`197`
`196`		`- fn lookup_hash160(&self, h: hash160::Hash) -> Option<[u8; 32]> {`
	`198`	`+ fn lookup_hash160(&self, h: hash160::Hash) -> Option<Preimage32> {`
`197`	`199`	`(**self).lookup_hash160(h)`
`198`	`200`	`}`
`199`	`201`
`@@ -219,19 +221,19 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'`
`219`	`221`	`(**self).lookup_pkh_sig(pkh)`
`220`	`222`	`}`
`221`	`223`
`222`		`- fn lookup_sha256(&self, h: sha256::Hash) -> Option<[u8; 32]> {`
	`224`	`+ fn lookup_sha256(&self, h: sha256::Hash) -> Option<Preimage32> {`
`223`	`225`	`(**self).lookup_sha256(h)`
`224`	`226`	`}`
`225`	`227`
`226`		`- fn lookup_hash256(&self, h: sha256d::Hash) -> Option<[u8; 32]> {`
	`228`	`+ fn lookup_hash256(&self, h: sha256d::Hash) -> Option<Preimage32> {`
`227`	`229`	`(**self).lookup_hash256(h)`
`228`	`230`	`}`
`229`	`231`
`230`		`- fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<[u8; 32]> {`
	`232`	`+ fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<Preimage32> {`
`231`	`233`	`(**self).lookup_ripemd160(h)`
`232`	`234`	`}`
`233`	`235`
`234`		`- fn lookup_hash160(&self, h: hash160::Hash) -> Option<[u8; 32]> {`
	`236`	`+ fn lookup_hash160(&self, h: hash160::Hash) -> Option<Preimage32> {`
`235`	`237`	`(**self).lookup_hash160(h)`
`236`	`238`	`}`
`237`	`239`
`@@ -288,7 +290,7 @@ macro_rules! impl_tuple_satisfier {`
`288`	`290`	`None`
`289`	`291`	`}`
`290`	`292`
`291`		`- fn lookup_sha256(&self, h: sha256::Hash) -> Option<[u8; 32]> {`
	`293`	`+ fn lookup_sha256(&self, h: sha256::Hash) -> Option<Preimage32> {`
`292`	`294`	`let &($(ref $ty,)*) = self;`
`293`	`295`	`$(`
`294`	`296`	`if let Some(result) = $ty.lookup_sha256(h) {`
`@@ -298,7 +300,7 @@ macro_rules! impl_tuple_satisfier {`
`298`	`300`	`None`
`299`	`301`	`}`
`300`	`302`
`301`		`- fn lookup_hash256(&self, h: sha256d::Hash) -> Option<[u8; 32]> {`
	`303`	`+ fn lookup_hash256(&self, h: sha256d::Hash) -> Option<Preimage32> {`
`302`	`304`	`let &($(ref $ty,)*) = self;`
`303`	`305`	`$(`
`304`	`306`	`if let Some(result) = $ty.lookup_hash256(h) {`
`@@ -308,7 +310,7 @@ macro_rules! impl_tuple_satisfier {`
`308`	`310`	`None`
`309`	`311`	`}`
`310`	`312`
`311`		`- fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<[u8; 32]> {`
	`313`	`+ fn lookup_ripemd160(&self, h: ripemd160::Hash) -> Option<Preimage32> {`
`312`	`314`	`let &($(ref $ty,)*) = self;`
`313`	`315`	`$(`
`314`	`316`	`if let Some(result) = $ty.lookup_ripemd160(h) {`
`@@ -318,7 +320,7 @@ macro_rules! impl_tuple_satisfier {`
`318`	`320`	`None`
`319`	`321`	`}`
`320`	`322`
`321`		`- fn lookup_hash160(&self, h: hash160::Hash) -> Option<[u8; 32]> {`
	`323`	`+ fn lookup_hash160(&self, h: hash160::Hash) -> Option<Preimage32> {`
`322`	`324`	`let &($(ref $ty,)*) = self;`
`323`	`325`	`$(`
`324`	`326`	`if let Some(result) = $ty.lookup_hash160(h) {`