Merge pull request #227 from sanket1729/psbt_hash

Add psbt preimage satisfaction logic

Author: heap-coder

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

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) {

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> {