Merge #67: update rust-bitcoin to 0.31

e7a853e ci: remove duplicated and wrong job (Riccardo Casatta)
b8ceef7 update rust-bitcoin to 0.31 (Riccardo Casatta)

Pull request description:

  ~~Solves only hard errors for now~~

ACKs for top commit:
  jamesdorfman:
    utACK e7a853e.
  apoelstra:
    ACK e7a853e

Tree-SHA512: 560fb6d929cd15f8d2488b4583801e90833001c94806946e04b617480a306b8733d9d370a55a6d376e349e511324c02aa2ac41744e2744f0660fd929c6900363

Author: apoelstra

.github/workflows/rust.yml

@@ -83,18 +83,3 @@ jobs:
         env:
           DO_FEATURE_MATRIX: true
         run: ./contrib/test.sh
-
-  IntTests:
-    name: Integration tests
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Crate
-        uses: actions/checkout@v2
-      - name: Checkout Toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - name: Running cargo
-        run: ./contrib/test.sh

Cargo.toml

@@ -19,10 +19,10 @@ rand = ["bitcoin/rand"]
 base64 = ["bitcoin/base64"]
 
 [dependencies]
-bitcoin = "0.30.0"
-elements = "0.23.0"
-bitcoin-miniscript = { package = "miniscript", version = "10.0" }
-simplicity = { git = "https://github.com/BlockstreamResearch/rust-simplicity", rev = "d5c0d65320816bfdf36411feed4bdff0708b5b12", optional = true }
+bitcoin = "0.31.0"
+elements = "0.24.0"
+bitcoin-miniscript = { package = "miniscript", version = "11.0" }
+simplicity = { git = "https://github.com/BlockstreamResearch/rust-simplicity", rev = "39fe6d7533b06001e9954fa08df34a1052702caf", optional = true }
 
 # Do NOT use this as a feature! Use the `serde` feature instead.
 actual-serde = { package = "serde", version = "1.0", optional = true }
@@ -31,8 +31,8 @@ actual-serde = { package = "serde", version = "1.0", optional = true }
 serde_json = "1.0"
 actual-rand = { package = "rand", version = "0.8.4"}
 serde_test = "1.0.147"
-bitcoin = { version = "0.30.0", features = ["base64"] }
-secp256k1 = {version = "0.27.0", features = ["rand-std"]}
+bitcoin = { version = "0.31.0", features = ["base64"] }
+secp256k1 = {version = "0.28.0", features = ["rand-std"]}
 actual-base64 = { package = "base64", version = "0.13.0" }
 
 

bitcoind-tests/Cargo.toml

@@ -8,6 +8,6 @@ edition = "2018"
 
 [dependencies]
 elements-miniscript = { path = "../" }
-elementsd = { version = "0.8.0" }
+elementsd = { version = "0.9.0" }
 actual-rand = { package = "rand", version = "0.8.4" }
-secp256k1 = { version = "0.27.0", features = ["rand-std"] }
+secp256k1 = { version = "0.28.1", features = ["rand-std"] }

bitcoind-tests/tests/setup/test_util.rs

@@ -57,7 +57,7 @@ pub struct PubData {
 #[derive(Debug, Clone)]
 pub struct SecretData {
     pub sks: Vec<bitcoin::secp256k1::SecretKey>,
-    pub x_only_keypairs: Vec<bitcoin::key::KeyPair>,
+    pub x_only_keypairs: Vec<bitcoin::key::Keypair>,
     pub sha256_pre: [u8; 32],
     pub hash256_pre: [u8; 32],
     pub ripemd160_pre: [u8; 32],
@@ -75,7 +75,7 @@ fn setup_keys(
 ) -> (
     Vec<bitcoin::secp256k1::SecretKey>,
     Vec<miniscript::bitcoin::PublicKey>,
-    Vec<bitcoin::key::KeyPair>,
+    Vec<bitcoin::key::Keypair>,
     Vec<bitcoin::key::XOnlyPublicKey>,
 ) {
     let secp_sign = secp256k1::Secp256k1::signing_only();
@@ -100,7 +100,7 @@ fn setup_keys(
     let mut x_only_pks = vec![];
 
     for sk in &sks {
-        let keypair = bitcoin::key::KeyPair::from_secret_key(&secp_sign, sk);
+        let keypair = bitcoin::key::Keypair::from_secret_key(&secp_sign, sk);
         let (xpk, _parity) = bitcoin::key::XOnlyPublicKey::from_keypair(&keypair);
         x_only_keypairs.push(keypair);
         x_only_pks.push(xpk);

bitcoind-tests/tests/test_arith.rs

@@ -105,7 +105,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
             let prevouts = [witness_utxo];
             let prevouts = sighash::Prevouts::All(&prevouts);
             // ------------------ script spend -------------
-            let x_only_keypairs_reqd: Vec<(secp256k1::KeyPair, TapLeafHash)> = tr
+            let x_only_keypairs_reqd: Vec<(secp256k1::Keypair, TapLeafHash)> = tr
                 .iter_scripts()
                 .flat_map(|(_depth, script)| {
                     let leaf_hash = TapLeafHash::from_script(&script.encode(), script.version());

bitcoind-tests/tests/test_cpp.rs

@@ -148,7 +148,7 @@ pub fn test_from_cpp_ms(cl: &ElementsD, testdata: &TestData) {
 
         // requires both signing and verification because we check the tx
         // after we psbt extract it
-        let msg = secp256k1_zkp::Message::from_slice(&sighash[..]).unwrap();
+        let msg = secp256k1_zkp::Message::from_digest_slice(&sighash[..]).unwrap();
 
         // Finally construct the signature and add to psbt
         for sk in sks_reqd {

bitcoind-tests/tests/test_csfs.rs

@@ -106,7 +106,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
             let prevouts = [witness_utxo];
             let prevouts = sighash::Prevouts::All(&prevouts);
             // ------------------ script spend -------------
-            let x_only_keypairs_reqd: Vec<(secp256k1::KeyPair, TapLeafHash)> = tr
+            let x_only_keypairs_reqd: Vec<(secp256k1::Keypair, TapLeafHash)> = tr
                 .iter_scripts()
                 .flat_map(|(_depth, script)| {
                     let leaf_hash = TapLeafHash::from_script(&script.encode(), script.version());
@@ -126,7 +126,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
                         testdata.pubdata.genesis_hash,
                     )
                     .unwrap();
-                let msg = secp256k1::Message::from_slice(&sighash_msg[..]).unwrap();
+                let msg = secp256k1::Message::from_digest_slice(&sighash_msg[..]).unwrap();
                 let mut aux_rand = [0u8; 32];
                 rand::thread_rng().fill_bytes(&mut aux_rand);
                 let sig = secp.sign_schnorr_with_aux_rand(&msg, &keypair, &aux_rand);
@@ -167,7 +167,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
 
             // Create a signature
             let keypair = &self.0.secretdata.x_only_keypairs[i];
-            let msg = secp256k1::Message::from_slice(msg.as_inner()).unwrap();
+            let msg = secp256k1::Message::from_digest_slice(msg.as_inner()).unwrap();
             let mut aux_rand = [0u8; 32];
             rand::thread_rng().fill_bytes(&mut aux_rand);
 

bitcoind-tests/tests/test_desc.rs

@@ -163,7 +163,7 @@ pub fn test_desc_satisfy(
                         testdata.pubdata.genesis_hash,
                     )
                     .unwrap();
-                let msg = secp256k1::Message::from_slice(&sighash_msg[..]).unwrap();
+                let msg = secp256k1::Message::from_digest_slice(&sighash_msg[..]).unwrap();
                 let mut aux_rand = [0u8; 32];
                 rand::thread_rng().fill_bytes(&mut aux_rand);
                 let schnorr_sig =
@@ -176,7 +176,7 @@ pub fn test_desc_satisfy(
                 // No internal key
             }
             // ------------------ script spend -------------
-            let x_only_keypairs_reqd: Vec<(secp256k1::KeyPair, TapLeafHash)> = tr
+            let x_only_keypairs_reqd: Vec<(secp256k1::Keypair, TapLeafHash)> = tr
                 .iter_scripts()
                 .flat_map(|(_depth, script)| {
                     let leaf_hash = TapLeafHash::from_script(&script.encode(), script.version());
@@ -196,7 +196,7 @@ pub fn test_desc_satisfy(
                         testdata.pubdata.genesis_hash,
                     )
                     .unwrap();
-                let msg = secp256k1::Message::from_slice(&sighash_msg[..]).unwrap();
+                let msg = secp256k1::Message::from_digest_slice(&sighash_msg[..]).unwrap();
                 let mut aux_rand = [0u8; 32];
                 rand::thread_rng().fill_bytes(&mut aux_rand);
                 let sig = secp.sign_schnorr_with_aux_rand(&msg, &keypair, &aux_rand);

bitcoind-tests/tests/test_introspect.rs

@@ -105,7 +105,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
             let prevouts = [witness_utxo];
             let prevouts = sighash::Prevouts::All(&prevouts);
             // ------------------ script spend -------------
-            let x_only_keypairs_reqd: Vec<(secp256k1::KeyPair, TapLeafHash)> = tr
+            let x_only_keypairs_reqd: Vec<(secp256k1::Keypair, TapLeafHash)> = tr
                 .iter_scripts()
                 .flat_map(|(_depth, script)| {
                     let leaf_hash = TapLeafHash::from_script(&script.encode(), script.version());
@@ -125,7 +125,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
                         testdata.pubdata.genesis_hash,
                     )
                     .unwrap();
-                let msg = secp256k1::Message::from_slice(&sighash_msg[..]).unwrap();
+                let msg = secp256k1::Message::from_digest_slice(&sighash_msg[..]).unwrap();
                 let mut aux_rand = [0u8; 32];
                 rand::thread_rng().fill_bytes(&mut aux_rand);
                 let sig = secp.sign_schnorr_with_aux_rand(&msg, &keypair, &aux_rand);

examples/taproot.rs

@@ -3,14 +3,14 @@ extern crate elements_miniscript as miniscript;
 use std::collections::HashMap;
 use std::str::FromStr;
 
-use bitcoin::address::WitnessVersion;
+use bitcoin::WitnessVersion;
 use miniscript::descriptor::DescriptorType;
+use miniscript::descriptor::TapLeafScript;
 use miniscript::policy::Concrete;
 use miniscript::{
     translate_hash_fail, Descriptor, Miniscript, NoExt, Tap, TranslatePk, Translator,
 };
-use miniscript::descriptor::TapLeafScript;
-use secp256k1::{rand, KeyPair};
+use secp256k1::{rand, Keypair};
 
 // Refer to https://github.com/sanket1729/adv_btc_workshop/blob/master/workshop.md#creating-a-taproot-descriptor
 // for a detailed explanation of the policy and it's compilation
@@ -71,14 +71,19 @@ fn main() {
             iter.next().unwrap(),
             (
                 1,
-                TapLeafScript::Miniscript(&Miniscript::<String, Tap, NoExt>::from_str("and_v(vc:pk_k(In),older(9))").unwrap())
+                TapLeafScript::Miniscript(
+                    &Miniscript::<String, Tap, NoExt>::from_str("and_v(vc:pk_k(In),older(9))")
+                        .unwrap()
+                )
             )
         );
         assert_eq!(
             iter.next().unwrap(),
             (
                 1,
-                TapLeafScript::Miniscript(&Miniscript::<String, Tap, NoExt>::from_str("multi_a(2,hA,S)").unwrap())
+                TapLeafScript::Miniscript(
+                    &Miniscript::<String, Tap, NoExt>::from_str("multi_a(2,hA,S)").unwrap()
+                )
             )
         );
         assert_eq!(iter.next(), None);
@@ -88,7 +93,7 @@ fn main() {
 
     // We require secp for generating a random XOnlyPublicKey
     let secp = secp256k1::Secp256k1::new();
-    let key_pair = KeyPair::new(&secp, &mut rand::thread_rng());
+    let key_pair = Keypair::new(&secp, &mut rand::thread_rng());
     // Random unspendable XOnlyPublicKey provided for compilation to Taproot Descriptor
     let (unspendable_pubkey, _parity) = bitcoin::key::XOnlyPublicKey::from_keypair(&key_pair);