update rust-bitcoin to 0.31

Cargo.toml

@@ -19,10 +19,10 @@ rand = ["bitcoin/rand"]
 base64 = ["bitcoin/base64"]
 
 [dependencies]
-bitcoin = "0.30.0"
+bitcoin = "0.31.0"
 elements = "0.23.0"
-bitcoin-miniscript = { package = "miniscript", version = "10.0" }
-simplicity = { git = "https://github.com/BlockstreamResearch/rust-simplicity", rev = "d5c0d65320816bfdf36411feed4bdff0708b5b12" }
+bitcoin-miniscript = { package = "miniscript", version = "11.0" }
+simplicity = { git = "https://github.com/BlockstreamResearch/rust-simplicity", rev = "faec5c6b7cc1f1b72dd4d2c8f7c6ffd70783d51e" }
 
 # 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" }
 
 
@@ -62,3 +62,8 @@ required-features = ["base64"]
 
 [workspace]
 members = ["bitcoind-tests", "fuzz"]
+
+
+[patch.crates-io]
+elements = { git = "https://github.com/ElementsProject/rust-elements.git", rev = "009205c5c3f7b4a91d28d2715f0edb62f1b8fb30" }
+

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_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());

bitcoind-tests/tests/test_desc.rs

@@ -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());

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());

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

src/confidential/bare.rs

@@ -26,14 +26,12 @@ const MIDSTATE_HASH_TO_PRIVATE_HASH: [u8; 32] = [
     0xc0, 0x4b, 0xd0, 0x7f, 0x06, 0x5f, 0x1c, 0x06, 0x47, 0x89, 0x36, 0x63, 0xf3, 0x92, 0x6e, 0x65,
 ];
 
-sha256t_hash_newtype!(
-    TweakHash,
-    TweakTag,
-    MIDSTATE_HASH_TO_PRIVATE_HASH,
-    64,
-    doc = "BIP-340 Tagged hash for tweaking blinding keys",
-    forward
-);
+sha256t_hash_newtype! {
+    pub struct TapTweakTag = hash_str("CT-Blinding-Key/1.0");
+    /// Taproot-tagged hash for elements tapscript Merkle tree leafs
+    #[hash_newtype(forward)]
+    pub struct TapTweakHash(_);
+}
 
 /// Tweaks a bare key using the scriptPubKey of a descriptor
 pub fn tweak_key<'a, Pk, V>(
@@ -45,12 +43,12 @@ where
     Pk: ToPublicKey + 'a,
     V: secp256k1_zkp::Verification,
 {
-    let mut eng = TweakHash::engine();
+    let mut eng = TapTweakHash::engine();
     pk.to_public_key()
         .write_into(&mut eng)
         .expect("engines don't error");
     spk.consensus_encode(&mut eng).expect("engines don't error");
-    let hash_bytes = TweakHash::from_engine(eng).to_byte_array();
+    let hash_bytes = TapTweakHash::from_engine(eng).to_byte_array();
     let hash_scalar = secp256k1_zkp::Scalar::from_be_bytes(hash_bytes).expect("bytes from hash");
     pk.to_public_key()
         .inner
@@ -67,12 +65,12 @@ pub fn tweak_private_key<V>(
 where
     V: secp256k1_zkp::Signing,
 {
-    let mut eng = TweakHash::engine();
+    let mut eng = TapTweakHash::engine();
     bitcoin::PublicKey::new(sk.public_key(secp))
         .write_into(&mut eng)
         .expect("engines don't error");
     spk.consensus_encode(&mut eng).expect("engines don't error");
-    let hash_bytes = TweakHash::from_engine(eng).to_byte_array();
+    let hash_bytes = TapTweakHash::from_engine(eng).to_byte_array();
     let hash_scalar = secp256k1_zkp::Scalar::from_be_bytes(hash_bytes).expect("bytes from hash");
     sk.add_tweak(&hash_scalar).unwrap()
 }
@@ -100,18 +98,18 @@ mod tests {
 
         // Test empty hash
         assert_eq!(
-            TweakHash::from_engine(TweakTag::engine()).to_string(),
+            TapTweakHash::from_engine(TapTweakTag::engine()).to_string(),
             "d12a140aca856fbb917b931f263c42f064608985e2ce17ae5157daa17c55e8d9",
         );
         assert_eq!(
-            TweakHash::hash(&[]).to_string(),
+            TapTweakHash::hash(&[]).to_string(),
             "d12a140aca856fbb917b931f263c42f064608985e2ce17ae5157daa17c55e8d9",
         );
 
         // And hash of 100 bytes
         let data: Vec<u8> = (0..80).collect();
         assert_eq!(
-            TweakHash::hash(&data).to_string(),
+            TapTweakHash::hash(&data).to_string(),
             "e1e52419a2934d278c50e29608969d2f23c1bd1243a09bfc8026d4ed4b085e39",
         );
     }

src/confidential/slip77.rs

@@ -92,16 +92,20 @@ impl MasterBlindingKey {
 }
 
 impl hex::FromHex for MasterBlindingKey {
-    fn from_byte_iter<I>(iter: I) -> Result<Self, hex::Error>
+    type Err = hex::HexToArrayError;
+
+    fn from_byte_iter<I>(iter: I) -> Result<Self, Self::Err>
     where
-        I: Iterator<Item = Result<u8, hex::Error>> + ExactSizeIterator + DoubleEndedIterator,
+        I: Iterator<Item = Result<u8, hex::HexToBytesError>>
+            + ExactSizeIterator
+            + DoubleEndedIterator,
     {
         Ok(MasterBlindingKey(<[u8; 32]>::from_byte_iter(iter)?))
     }
 }
 
 impl std::str::FromStr for MasterBlindingKey {
-    type Err = hex::Error;
+    type Err = hex::HexToArrayError;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         hex::FromHex::from_hex(s)
     }
@@ -142,16 +146,20 @@ mod tests {
     #[test]
     fn slip77_from_rust_elements() {
         // taken from rust-elements
-        let mbk = MasterBlindingKey::from_seed(&unhex("731e9b42eb9774f8a6b51af35a06f6ef1cdb6cf04402163ceacf0c8bace2831a"));
+        let mbk = MasterBlindingKey::from_seed(&unhex(
+            "731e9b42eb9774f8a6b51af35a06f6ef1cdb6cf04402163ceacf0c8bace2831a",
+        ));
         assert_eq!(
             mbk.as_bytes(),
             &unhex("c2f338e32ad1a2bd9cac569e67728163bf4c326a1770ec2293ba65548a581e97")[..]
         );
 
-        let spk = elements::Script::from_str("a914afa92d77cd3541b443771649572db096cf49bf8c87").unwrap();
+        let spk =
+            elements::Script::from_str("a914afa92d77cd3541b443771649572db096cf49bf8c87").unwrap();
         let expected = secp256k1_zkp::SecretKey::from_slice(&unhex(
-            "02b067c374bb56c54c016fae29218c000ada60f81ef45b4aeebbeb24931bb8bc"
-        )).unwrap();
+            "02b067c374bb56c54c016fae29218c000ada60f81ef45b4aeebbeb24931bb8bc",
+        ))
+        .unwrap();
         assert_eq!(mbk.blinding_private_key(&spk), expected);
     }