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", rev = "0e2e55971275da64ceb62e8991a0a5fa962cb8b1"}
 
 [dependencies.serde]
 version = "1.0"

examples/sign_multisig.rs

@@ -21,6 +21,7 @@ use bitcoin::secp256k1; // secp256k1 re-exported from rust-bitcoin
 use miniscript::DescriptorTrait;
 use std::collections::HashMap;
 use std::str::FromStr;
+use bitcoin::blockdata::witness::Witness;
 
 fn main() {
     // Avoid repeatedly typing a pretty-common descriptor type
@@ -34,7 +35,7 @@ fn main() {
             previous_output: Default::default(),
             script_sig: bitcoin::Script::new(),
             sequence: 0xffffffff,
-            witness: vec![],
+            witness: Witness::default(),
         }],
         output: vec![bitcoin::TxOut {
             script_pubkey: bitcoin::Script::new(),
@@ -63,15 +64,15 @@ fn main() {
     let bitcoin_sig = (
         // copied at random off the blockchain; this is not actually a valid
         // signature for this transaction; Miniscript does not verify
-        secp256k1::Signature::from_str(
+        secp256k1::ecdsa::Signature::from_str(
             "3045\
              0221\
              00f7c3648c390d87578cd79c8016940aa8e3511c4104cb78daa8fb8e429375efc1\
              0220\
              531d75c136272f127a5dc14acc0722301cbddc222262934151f140da345af177",
         )
         .unwrap(),
-        bitcoin::SigHashType::All,
+        bitcoin::EcdsaSigHashType::All,
     );
 
     let descriptor_str = format!(

examples/verify_tx.rs

@@ -83,11 +83,11 @@ fn main() {
         0xa9, 0x14, 0x92, 0x09, 0xa8, 0xf9, 0x0c, 0x58, 0x4b, 0xb5, 0x97, 0x4d, 0x58, 0x68, 0x72,
         0x49, 0xe5, 0x32, 0xde, 0x59, 0xf4, 0xbc, 0x87,
     ]);
-
+    let wit = transaction.input[0].witness.to_vec();
     let mut interpreter = miniscript::Interpreter::from_txdata(
         &spk_input_1,
         &transaction.input[0].script_sig,
-        &transaction.input[0].witness,
+        &wit,
         0,
         0,
     )
@@ -123,22 +123,25 @@ fn main() {
     // from the MiniscriptKey which can supplied by `to_pk_ctx` parameter. For example,
     // when calculating the script pubkey of a descriptor with xpubs, the secp context and
     // child information maybe required.
+    let wit = transaction.input[0].witness.to_vec();
     let mut interpreter = miniscript::Interpreter::from_txdata(
         &spk_input_1,
         &transaction.input[0].script_sig,
-        &transaction.input[0].witness,
+        &wit,
         0,
         0,
     )
     .unwrap();
 
     // 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| {
-        bitcoinsig.1 == bitcoin::SigHashType::All && vfyfn(pk, bitcoinsig)
+        bitcoinsig.1 == bitcoin::EcdsaSigHashType::All && vfyfn(pk, bitcoinsig)
     };
 
     println!("\nExample two");
@@ -155,18 +158,19 @@ fn main() {
     //    what happens given an apparently invalid script
     let secp = secp256k1::Secp256k1::new();
     let message = secp256k1::Message::from_slice(&[0x01; 32][..]).expect("32-byte hash");
-
+    let wit = transaction.input[0].witness.to_vec();
     let mut interpreter = miniscript::Interpreter::from_txdata(
         &spk_input_1,
         &transaction.input[0].script_sig,
-        &transaction.input[0].witness,
+        &wit,
         0,
         0,
     )
     .unwrap();
 
     let iter = interpreter.iter(|pk, (sig, sighashtype)| {
-        sighashtype == bitcoin::SigHashType::All && secp.verify(&message, &sig, &pk.key).is_ok()
+        sighashtype == bitcoin::EcdsaSigHashType::All
+            && secp.verify_ecdsa(&message, &sig, &pk.key).is_ok()
     });
     println!("\nExample three");
     for elem in iter {

examples/xpub_descriptors.rs

@@ -28,15 +28,15 @@ fn main() {
             "wsh(sortedmulti(1,xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB,xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH))",
         )
         .unwrap()
-        .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
+        .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx).map(bitcoin::PublicKey::new))
         .unwrap()
         .address(bitcoin::Network::Bitcoin).unwrap();
 
     let addr_two = Descriptor::<DescriptorPublicKey>::from_str(
             "wsh(sortedmulti(1,xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH,xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB))",
         )
         .unwrap()
-        .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
+        .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx).map(bitcoin::PublicKey::new))
         .unwrap()
         .address(bitcoin::Network::Bitcoin).unwrap();
     let expected = bitcoin::Address::from_str(
@@ -52,7 +52,7 @@ fn main() {
         )
         .unwrap()
         .derive(5)
-        .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
+        .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx).map(bitcoin::PublicKey::new))
         .unwrap()
         .address(bitcoin::Network::Bitcoin).unwrap();
 
@@ -61,7 +61,7 @@ fn main() {
         )
         .unwrap()
         .derive(5)
-        .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
+        .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx).map(bitcoin::PublicKey::new))
         .unwrap()
         .address(bitcoin::Network::Bitcoin).unwrap();
     let expected = bitcoin::Address::from_str("325zcVBN5o2eqqqtGwPjmtDd8dJRyYP82s").unwrap();

integration_test/Cargo.toml

@@ -7,6 +7,6 @@ authors = ["Steven Roose <[email protected]>", "Sanket K <sanket1729@gmail.
 miniscript = {path = "../"}
 
 # Until 0.26 support is released on rust-bitcoincore-rpc
-bitcoincore-rpc = "0.14.0"
-bitcoin = "0.27.1"
+bitcoincore-rpc = {git = "https://github.com/sanket1729/rust-bitcoincore-rpc",rev = "ae3ad6cac0a83454f267cb7d5191f6607bb80297"}
+bitcoin = {git = "https://github.com/rust-bitcoin/rust-bitcoin", rev = "0e2e55971275da64ceb62e8991a0a5fa962cb8b1"}
 log = "0.4"

integration_test/src/main.rs

@@ -198,7 +198,7 @@ fn main() {
         // Get the required sighash message
         let amt = btc(1).as_sat();
         let mut sighash_cache = bip143::SigHashCache::new(&psbts[i].global.unsigned_tx);
-        let sighash_ty = bitcoin::SigHashType::All;
+        let sighash_ty = bitcoin::EcdsaSigHashType::All;
         let sighash = sighash_cache.signature_hash(0, &ms.encode(), amt, sighash_ty);
 
         // requires both signing and verification because we check the tx
@@ -208,7 +208,7 @@ fn main() {
 
         // Finally construct the signature and add to psbt
         for sk in sks_reqd {
-            let sig = secp.sign(&msg, &sk);
+            let sig = secp.sign_ecdsa(&msg, &sk);
             let pk = pks[sks.iter().position(|&x| x == sk).unwrap()];
             let mut sig = sig.serialize_der().to_vec();
             sig.push(0x01u8); //sighash all flag

src/descriptor/key.rs

@@ -168,7 +168,7 @@ impl DescriptorXKey<bip32::ExtendedPrivKey> {
             .xkey
             .derive_priv(&secp, &deriv_on_hardened)
             .map_err(|_| DescriptorKeyParseError("Unable to derive the hardened steps"))?;
-        let xpub = bip32::ExtendedPubKey::from_private(&secp, &derived_xprv);
+        let xpub = bip32::ExtendedPubKey::from_priv(&secp, &derived_xprv);
 
         let origin = match &self.origin {
             &Some((fingerprint, ref origin_path)) => Some((
@@ -439,9 +439,9 @@ impl DescriptorPublicKey {
     pub fn derive_public_key<C: secp256k1::Verification>(
         &self,
         secp: &Secp256k1<C>,
-    ) -> Result<bitcoin::PublicKey, ConversionError> {
+    ) -> Result<secp256k1::PublicKey, ConversionError> {
         match *self {
-            DescriptorPublicKey::SinglePub(ref pk) => Ok(pk.key),
+            DescriptorPublicKey::SinglePub(ref pk) => Ok(pk.key.key),
             DescriptorPublicKey::XPub(ref xpk) => match xpk.wildcard {
                 Wildcard::Unhardened => Err(ConversionError::Wildcard),
                 Wildcard::Hardened => Err(ConversionError::HardenedWildcard),

src/descriptor/mod.rs

@@ -29,6 +29,7 @@ use std::{
     str::{self, FromStr},
 };
 
+use bitcoin::blockdata::witness::Witness;
 use bitcoin::secp256k1;
 use bitcoin::{self, Script};
 
@@ -140,7 +141,7 @@ pub trait DescriptorTrait<Pk: MiniscriptKey> {
     {
         // easy default implementation
         let (witness, script_sig) = self.get_satisfaction(satisfier)?;
-        txin.witness = witness;
+        txin.witness = Witness::from_vec(witness);
         txin.script_sig = script_sig;
         Ok(())
     }
@@ -647,7 +648,7 @@ serde_string_impl_pk!(Descriptor, "a script descriptor");
 #[cfg(test)]
 mod tests {
     use super::checksum::desc_checksum;
-    use super::DescriptorTrait;
+    use super::*;
     use bitcoin::blockdata::opcodes::all::{OP_CLTV, OP_CSV};
     use bitcoin::blockdata::script::Instruction;
     use bitcoin::blockdata::{opcodes, script};
@@ -939,19 +940,19 @@ mod tests {
         };
         let msg = secp256k1::Message::from_slice(&b"michael was a message, amusingly"[..])
             .expect("32 bytes");
-        let sig = secp.sign(&msg, &sk);
+        let sig = secp.sign_ecdsa(&msg, &sk);
         let mut sigser = sig.serialize_der().to_vec();
         sigser.push(0x01); // sighash_all
 
         struct SimpleSat {
-            sig: secp256k1::Signature,
+            sig: secp256k1::ecdsa::Signature,
             pk: bitcoin::PublicKey,
         }
 
         impl Satisfier<bitcoin::PublicKey> for SimpleSat {
             fn lookup_sig(&self, pk: &bitcoin::PublicKey) -> Option<BitcoinSig> {
                 if *pk == self.pk {
-                    Some((self.sig, bitcoin::SigHashType::All))
+                    Some((self.sig, bitcoin::EcdsaSigHashType::All))
                 } else {
                     None
                 }
@@ -965,7 +966,7 @@ mod tests {
             previous_output: bitcoin::OutPoint::default(),
             script_sig: bitcoin::Script::new(),
             sequence: 100,
-            witness: vec![],
+            witness: Witness::default(),
         };
         let bare = Descriptor::new_bare(ms.clone()).unwrap();
 
@@ -976,7 +977,7 @@ mod tests {
                 previous_output: bitcoin::OutPoint::default(),
                 script_sig: script::Builder::new().push_slice(&sigser[..]).into_script(),
                 sequence: 100,
-                witness: vec![],
+                witness: Witness::default(),
             }
         );
         assert_eq!(bare.unsigned_script_sig(), bitcoin::Script::new());
@@ -992,7 +993,7 @@ mod tests {
                     .push_key(&pk)
                     .into_script(),
                 sequence: 100,
-                witness: vec![],
+                witness: Witness::default(),
             }
         );
         assert_eq!(pkh.unsigned_script_sig(), bitcoin::Script::new());
@@ -1005,7 +1006,7 @@ mod tests {
                 previous_output: bitcoin::OutPoint::default(),
                 script_sig: bitcoin::Script::new(),
                 sequence: 100,
-                witness: vec![sigser.clone(), pk.to_bytes(),],
+                witness: Witness::from_vec(vec![sigser.clone(), pk.to_bytes(),]),
             }
         );
         assert_eq!(wpkh.unsigned_script_sig(), bitcoin::Script::new());
@@ -1026,7 +1027,7 @@ mod tests {
                     .push_slice(&redeem_script[..])
                     .into_script(),
                 sequence: 100,
-                witness: vec![sigser.clone(), pk.to_bytes(),],
+                witness: Witness::from_vec(vec![sigser.clone(), pk.to_bytes(),]),
             }
         );
         assert_eq!(
@@ -1048,7 +1049,7 @@ mod tests {
                     .push_slice(&ms.encode()[..])
                     .into_script(),
                 sequence: 100,
-                witness: vec![],
+                witness: Witness::default(),
             }
         );
         assert_eq!(sh.unsigned_script_sig(), bitcoin::Script::new());
@@ -1063,7 +1064,7 @@ mod tests {
                 previous_output: bitcoin::OutPoint::default(),
                 script_sig: bitcoin::Script::new(),
                 sequence: 100,
-                witness: vec![sigser.clone(), ms.encode().into_bytes(),],
+                witness: Witness::from_vec(vec![sigser.clone(), ms.encode().into_bytes(),]),
             }
         );
         assert_eq!(wsh.unsigned_script_sig(), bitcoin::Script::new());
@@ -1078,7 +1079,7 @@ mod tests {
                     .push_slice(&ms.encode().to_v0_p2wsh()[..])
                     .into_script(),
                 sequence: 100,
-                witness: vec![sigser.clone(), ms.encode().into_bytes(),],
+                witness: Witness::from_vec(vec![sigser.clone(), ms.encode().into_bytes(),]),
             }
         );
         assert_eq!(
@@ -1136,13 +1137,13 @@ mod tests {
             "02937402303919b3a2ee5edd5009f4236f069bf75667b8e6ecf8e5464e20116a0e",
         )
         .unwrap();
-        let sig_a = secp256k1::Signature::from_str("3045022100a7acc3719e9559a59d60d7b2837f9842df30e7edcd754e63227e6168cec72c5d022066c2feba4671c3d99ea75d9976b4da6c86968dbf3bab47b1061e7a1966b1778c").unwrap();
+        let sig_a = secp256k1::ecdsa::Signature::from_str("3045022100a7acc3719e9559a59d60d7b2837f9842df30e7edcd754e63227e6168cec72c5d022066c2feba4671c3d99ea75d9976b4da6c86968dbf3bab47b1061e7a1966b1778c").unwrap();
 
         let b = bitcoin::PublicKey::from_str(
             "02eb64639a17f7334bb5a1a3aad857d6fec65faef439db3de72f85c88bc2906ad3",
         )
         .unwrap();
-        let sig_b = secp256k1::Signature::from_str("3044022075b7b65a7e6cd386132c5883c9db15f9a849a0f32bc680e9986398879a57c276022056d94d12255a4424f51c700ac75122cb354895c9f2f88f0cbb47ba05c9c589ba").unwrap();
+        let sig_b = secp256k1::ecdsa::Signature::from_str("3044022075b7b65a7e6cd386132c5883c9db15f9a849a0f32bc680e9986398879a57c276022056d94d12255a4424f51c700ac75122cb354895c9f2f88f0cbb47ba05c9c589ba").unwrap();
 
         let descriptor = Descriptor::<bitcoin::PublicKey>::from_str(&format!(
             "wsh(and_v(v:pk({A}),pk({B})))",
@@ -1155,13 +1156,13 @@ mod tests {
             previous_output: bitcoin::OutPoint::default(),
             script_sig: bitcoin::Script::new(),
             sequence: 0,
-            witness: vec![],
+            witness: Witness::default(),
         };
         let satisfier = {
             let mut satisfier = HashMap::with_capacity(2);
 
-            satisfier.insert(a, (sig_a.clone(), ::bitcoin::SigHashType::All));
-            satisfier.insert(b, (sig_b.clone(), ::bitcoin::SigHashType::All));
+            satisfier.insert(a, (sig_a.clone(), ::bitcoin::EcdsaSigHashType::All));
+            satisfier.insert(b, (sig_b.clone(), ::bitcoin::EcdsaSigHashType::All));
 
             satisfier
         };
@@ -1170,11 +1171,12 @@ mod tests {
         descriptor.satisfy(&mut txin, &satisfier).unwrap();
 
         // assert
-        let witness0 = &txin.witness[0];
-        let witness1 = &txin.witness[1];
+        let wit = txin.witness.to_vec();
+        let witness0 = &wit[0];
+        let witness1 = &wit[1];
 
-        let sig0 = secp256k1::Signature::from_der(&witness0[..witness0.len() - 1]).unwrap();
-        let sig1 = secp256k1::Signature::from_der(&witness1[..witness1.len() - 1]).unwrap();
+        let sig0 = secp256k1::ecdsa::Signature::from_der(&witness0[..witness0.len() - 1]).unwrap();
+        let sig1 = secp256k1::ecdsa::Signature::from_der(&witness1[..witness1.len() - 1]).unwrap();
 
         // why are we asserting this way?
         // The witness stack is evaluated from top to bottom. Given an `and` instruction, the left arm of the and is going to evaluate first,
@@ -1351,12 +1353,18 @@ mod tests {
 
             // Same address
             let addr_one = desc_one
-                .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
+                .translate_pk2(|xpk| {
+                    xpk.derive_public_key(&secp_ctx)
+                        .map(bitcoin::PublicKey::new)
+                })
                 .unwrap()
                 .address(bitcoin::Network::Bitcoin)
                 .unwrap();
             let addr_two = desc_two
-                .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
+                .translate_pk2(|xpk| {
+                    xpk.derive_public_key(&secp_ctx)
+                        .map(bitcoin::PublicKey::new)
+                })
                 .unwrap()
                 .address(bitcoin::Network::Bitcoin)
                 .unwrap();