update to latest bitcoin master

Author: sanket1729

Cargo.toml

@@ -7,7 +7,7 @@ description = "Miniscript: a subset of Bitcoin Script designed for analysis"
 license = "CC0-1.0"
 
 [features]
-fuzztarget = ["bitcoin/fuzztarget"]
+fuzztarget = []
 compiler = []
 trace = []
 unstable = []
@@ -16,7 +16,8 @@ use-serde = ["bitcoin/use-serde", "serde"]
 rand = ["bitcoin/rand"]
 
 [dependencies]
-bitcoin = "0.27"
+# bitcoin = "0.27"
+bitcoin = {git = "https://github.com/rust-bitcoin/rust-bitcoin", branch = "master"}
 
 [dependencies.serde]
 version = "1.0"

examples/verify_tx.rs

@@ -134,7 +134,9 @@ fn main() {
 
     // We can set the amount passed to `sighash_verify` to 0 because this is a legacy
     // transaction and so the amount won't actually be checked by the signature
-    let vfyfn = interpreter.sighash_verify(&secp, &transaction, 0, 0);
+    let vfyfn = interpreter
+        .sighash_verify(&secp, &transaction, 0, 0)
+        .expect("Can only fail in sighash single when corresponding output is not present");
     // Restrict to sighash_all just to demonstrate how to add additional filters
     // `&_` needed here because of https://github.com/rust-lang/rust/issues/79187
     let vfyfn = move |pk: &_, bitcoinsig: miniscript::BitcoinSig| {

src/descriptor/sh.rs

@@ -209,10 +209,18 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Sh<Pk> {
         Pk: ToPublicKey,
     {
         match self.inner {
-            ShInner::Wsh(ref wsh) => Ok(bitcoin::Address::p2sh(&wsh.script_pubkey(), network)),
-            ShInner::Wpkh(ref wpkh) => Ok(bitcoin::Address::p2sh(&wpkh.script_pubkey(), network)),
-            ShInner::SortedMulti(ref smv) => Ok(bitcoin::Address::p2sh(&smv.encode(), network)),
-            ShInner::Ms(ref ms) => Ok(bitcoin::Address::p2sh(&ms.encode(), network)),
+            ShInner::Wsh(ref wsh) => Ok(bitcoin::Address::p2sh(&wsh.script_pubkey(), network)
+                .expect("Size checked in Miniscript")),
+            ShInner::Wpkh(ref wpkh) => Ok(bitcoin::Address::p2sh(&wpkh.script_pubkey(), network)
+                .expect("Size checked in Miniscript")),
+            ShInner::SortedMulti(ref smv) => {
+                Ok(bitcoin::Address::p2sh(&smv.encode(), network)
+                    .expect("Size checked in Miniscript"))
+            }
+            ShInner::Ms(ref ms) => {
+                Ok(bitcoin::Address::p2sh(&ms.encode(), network)
+                    .expect("Size checked in Miniscript"))
+            }
         }
     }
 

src/interpreter/error.rs

@@ -71,6 +71,8 @@ pub enum Error {
     Secp(secp256k1::Error),
     /// Miniscript requires the entire top level script to be satisfied.
     ScriptSatisfactionError,
+    /// Errors in signature hash calculations
+    SighashError(bitcoin::util::sighash::Error),
     /// An uncompressed public key was encountered in a context where it is
     /// disallowed (e.g. in a Segwit script or p2wpkh output)
     UncompressedPubkey,
@@ -95,6 +97,13 @@ impl From<secp256k1::Error> for Error {
     }
 }
 
+#[doc(hidden)]
+impl From<bitcoin::util::sighash::Error> for Error {
+    fn from(e: bitcoin::util::sighash::Error) -> Error {
+        Error::SighashError(e)
+    }
+}
+
 #[doc(hidden)]
 impl From<::Error> for Error {
     fn from(e: ::Error) -> Error {
@@ -152,6 +161,7 @@ impl fmt::Display for Error {
             }
             Error::ScriptSatisfactionError => f.write_str("Top level script must be satisfied"),
             Error::Secp(ref e) => fmt::Display::fmt(e, f),
+            Error::SighashError(ref e) => fmt::Display::fmt(e, f),
             Error::UncompressedPubkey => {
                 f.write_str("uncompressed pubkey in non-legacy descriptor")
             }

src/interpreter/mod.rs

@@ -20,7 +20,7 @@
 //!
 
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
-use bitcoin::util::bip143;
+use bitcoin::util::sighash;
 use bitcoin::{self, secp256k1};
 use miniscript::context::NoChecks;
 use miniscript::ScriptContext;
@@ -170,16 +170,16 @@ impl<'txin> Interpreter<'txin> {
         input_idx: usize,
         amount: u64,
         sighash_type: bitcoin::SigHashType,
-    ) -> secp256k1::Message {
+    ) -> Result<secp256k1::Message, Error> {
+        let mut cache = sighash::SigHashCache::new(unsigned_tx);
         let hash = if self.is_legacy() {
-            unsigned_tx.signature_hash(input_idx, &self.script_code, sighash_type.as_u32())
+            cache.legacy_signature_hash(input_idx, &self.script_code, sighash_type.as_u32())?
         } else {
-            let mut sighash_cache = bip143::SigHashCache::new(unsigned_tx);
-            sighash_cache.signature_hash(input_idx, &self.script_code, amount, sighash_type)
+            cache.segwit_signature_hash(input_idx, &self.script_code, amount, sighash_type)?
         };
 
-        secp256k1::Message::from_slice(&hash[..])
-            .expect("cryptographically unreachable for this to fail")
+        Ok(secp256k1::Message::from_slice(&hash[..])
+            .expect("cryptographically unreachable for this to fail"))
     }
 
     /// Returns a closure which can be given to the `iter` method to check all signatures
@@ -189,34 +189,34 @@ impl<'txin> Interpreter<'txin> {
         unsigned_tx: &'a bitcoin::Transaction,
         input_idx: usize,
         amount: u64,
-    ) -> impl Fn(&bitcoin::PublicKey, BitcoinSig) -> bool + 'a {
+    ) -> Result<impl Fn(&bitcoin::PublicKey, BitcoinSig) -> bool + 'a, Error> {
         // Precompute all sighash types because the borrowck doesn't like us
         // pulling self into the closure
         let sighashes = [
-            self.sighash_message(unsigned_tx, input_idx, amount, bitcoin::SigHashType::All),
-            self.sighash_message(unsigned_tx, input_idx, amount, bitcoin::SigHashType::None),
-            self.sighash_message(unsigned_tx, input_idx, amount, bitcoin::SigHashType::Single),
+            self.sighash_message(unsigned_tx, input_idx, amount, bitcoin::SigHashType::All)?,
+            self.sighash_message(unsigned_tx, input_idx, amount, bitcoin::SigHashType::None)?,
+            self.sighash_message(unsigned_tx, input_idx, amount, bitcoin::SigHashType::Single)?,
             self.sighash_message(
                 unsigned_tx,
                 input_idx,
                 amount,
                 bitcoin::SigHashType::AllPlusAnyoneCanPay,
-            ),
+            )?,
             self.sighash_message(
                 unsigned_tx,
                 input_idx,
                 amount,
                 bitcoin::SigHashType::NonePlusAnyoneCanPay,
-            ),
+            )?,
             self.sighash_message(
                 unsigned_tx,
                 input_idx,
                 amount,
                 bitcoin::SigHashType::SinglePlusAnyoneCanPay,
-            ),
+            )?,
         ];
 
-        move |pk: &bitcoin::PublicKey, (sig, sighash_type)| {
+        Ok(move |pk: &bitcoin::PublicKey, (sig, sighash_type)| {
             // This is an awkward way to do this lookup, but it lets us do exhaustiveness
             // checking in case future rust-bitcoin versions add new sighash types
             let sighash = match sighash_type {
@@ -228,7 +228,7 @@ impl<'txin> Interpreter<'txin> {
                 bitcoin::SigHashType::SinglePlusAnyoneCanPay => sighashes[5],
             };
             secp.verify(&sighash, &sig, &pk.key).is_ok()
-        }
+        })
     }
 }
 

src/psbt/finalizer.rs

@@ -227,7 +227,9 @@ pub fn interpreter_check<C: secp256k1::Verification>(
             interpreter::Interpreter::from_txdata(spk, &script_sig, &witness, cltv, csv)
                 .map_err(|e| Error::InputError(InputError::Interpreter(e), index))?;
 
-        let vfyfn = interpreter.sighash_verify(&secp, &psbt.global.unsigned_tx, index, amt);
+        let vfyfn = interpreter
+            .sighash_verify(&secp, &psbt.global.unsigned_tx, index, amt)
+            .map_err(|e| Error::InputError(InputError::Interpreter(e), index))?;
         if let Some(error) = interpreter.iter(vfyfn).filter_map(Result::err).next() {
             return Err(Error::InputError(InputError::Interpreter(error), index));
         }