ElementsProject · apoelstra · Aug 10, 2023 · Aug 9, 2023 · Aug 9, 2023
diff --git a/bitcoind-tests/Cargo.toml b/bitcoind-tests/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-elements-miniscript = {path = "../"}
-elementsd = {version = "0.6.0"}
-actual-rand = { package = "rand", version = "0.8.4"}
-secp256k1 = {version = "0.27.0", features = ["rand-std"]}
+elements-miniscript = { path = "../" }
+elementsd = { version = "0.8.0" }
+actual-rand = { package = "rand", version = "0.8.4" }
+secp256k1 = { version = "0.27.0", features = ["rand-std"] }
diff --git a/bitcoind-tests/tests/setup/mod.rs b/bitcoind-tests/tests/setup/mod.rs
@@ -1,7 +1,7 @@
 pub extern crate elements_miniscript;
 
 use std::str::FromStr;
-use miniscript::elements;
+
 use elements::encode::{deserialize, serialize_hex};
 use elements::hex::FromHex;
 use elements::BlockHash;
@@ -10,6 +10,7 @@ use elementsd::bitcoincore_rpc::jsonrpc::serde_json::{json, Value};
 use elementsd::bitcoind::bitcoincore_rpc::RpcApi;
 use elementsd::bitcoind::{self, BitcoinD};
 use elementsd::ElementsD;
+use miniscript::elements;
 
 pub mod test_util;
 

diff --git a/bitcoind-tests/tests/setup/test_util.rs b/bitcoind-tests/tests/setup/test_util.rs
@@ -20,17 +20,15 @@
 use std::collections::HashMap;
 use std::str::FromStr;
 
-use miniscript::{elements, bitcoin};
-use elements::hex::{FromHex, ToHex};
 use elements::hashes::{hash160, ripemd160, sha256, Hash};
-use elements::secp256k1_zkp as secp256k1;
-use elements::{confidential, encode, AddressParams, BlockHash};
+use elements::hex::{FromHex, ToHex};
+use elements::{confidential, encode, secp256k1_zkp as secp256k1, AddressParams, BlockHash};
 use miniscript::descriptor::{SinglePub, SinglePubKey};
 use miniscript::extensions::param::ExtParamTranslator;
 use miniscript::extensions::{CovExtArgs, CsfsKey, CsfsMsg};
 use miniscript::{
-    hash256, CovenantExt, Descriptor, DescriptorPublicKey, Error, Miniscript, ScriptContext,
-    TranslateExt, TranslatePk, Translator,
+    bitcoin, elements, hash256, CovenantExt, Descriptor, DescriptorPublicKey, Error, Miniscript,
+    ScriptContext, TranslateExt, TranslatePk, Translator,
 };
 use rand::RngCore;
 use {actual_rand as rand, elements_miniscript as miniscript};
@@ -138,7 +136,7 @@ impl TestData {
             assets: HashMap::new(),
             spks: HashMap::new(),
             timestamp: 414315315u64, // Some dummy time
-            price: 50_000i64, // Some dummy price
+            price: 50_000i64,        // Some dummy price
         };
         let secretdata = SecretData {
             sks,

diff --git a/bitcoind-tests/tests/test_arith.rs b/bitcoind-tests/tests/test_arith.rs
@@ -3,17 +3,16 @@
 //! Arith expression fragment integration tests
 //!
 
-use miniscript::elements;
 use elements::pset::PartiallySignedTransaction as Psbt;
 use elements::sighash::SigHashCache;
 use elements::taproot::{LeafVersion, TapLeafHash};
 use elements::{
-    confidential, pset as psbt, secp256k1_zkp as secp256k1, sighash, OutPoint, Script,
-    Sequence, TxIn, TxOut, Txid,
+    confidential, pset as psbt, secp256k1_zkp as secp256k1, sighash, OutPoint, Script, Sequence,
+    TxIn, TxOut, Txid,
 };
 use elementsd::ElementsD;
 use miniscript::psbt::{PsbtExt, PsbtInputExt};
-use miniscript::{Descriptor, ToPublicKey};
+use miniscript::{elements, Descriptor, ToPublicKey};
 use rand::RngCore;
 mod setup;
 use setup::test_util::{self, TestData, PARAMS};
@@ -136,10 +135,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
                 let x_only_pk = secp256k1::XOnlyPublicKey::from_keypair(&keypair).0;
                 psbt.inputs_mut()[0].tap_script_sigs.insert(
                     (x_only_pk, leaf_hash),
-                    elements::SchnorrSig {
-                        sig,
-                        hash_ty,
-                    },
+                    elements::SchnorrSig { sig, hash_ty },
                 );
             }
         }

diff --git a/bitcoind-tests/tests/test_cpp.rs b/bitcoind-tests/tests/test_cpp.rs
@@ -7,19 +7,18 @@
 use std::fs::File;
 use std::io::{self, BufRead};
 use std::path::Path;
-use miniscript::{elements, bitcoin};
 
 use bitcoin::hashes::{sha256d, Hash};
 use bitcoin::secp256k1::{self, Secp256k1};
 use elements::pset::PartiallySignedTransaction as Psbt;
 use elements::{
-    confidential, pset as psbt, secp256k1_zkp, AssetIssuance, LockTime, OutPoint, Script,
-    Sequence, TxIn, TxInWitness, TxOut, TxOutWitness, Txid,
+    confidential, pset as psbt, secp256k1_zkp, AssetIssuance, LockTime, OutPoint, Script, Sequence,
+    TxIn, TxInWitness, TxOut, TxOutWitness, Txid,
 };
 use elements_miniscript as miniscript;
 use elementsd::ElementsD;
 use miniscript::psbt::PsbtExt;
-use miniscript::{elementssig_to_rawsig, Descriptor};
+use miniscript::{bitcoin, elements, elementssig_to_rawsig, Descriptor};
 
 mod setup;
 use setup::test_util::{self, PubData, TestData, PARAMS};
@@ -90,10 +89,8 @@ pub fn test_from_cpp_ms(cl: &ElementsD, testdata: &TestData) {
     let mut psbts = vec![];
     for (desc, txid) in desc_vec.iter().zip(txids) {
         let mut psbt = Psbt::new_v2();
-        psbt.global.tx_data.fallback_locktime = Some(
-            LockTime::from_time(1_603_866_330)
-                .expect("valid timestamp"),
-        ); // 10/28/2020 @ 6:25am (UTC)
+        psbt.global.tx_data.fallback_locktime =
+            Some(LockTime::from_time(1_603_866_330).expect("valid timestamp")); // 10/28/2020 @ 6:25am (UTC)
         let (outpoint, witness_utxo) = get_vout(cl, txid, 100_000_000);
         let txin = TxIn {
             previous_output: outpoint,

diff --git a/bitcoind-tests/tests/test_csfs.rs b/bitcoind-tests/tests/test_csfs.rs
@@ -3,18 +3,17 @@
 //! CheckSigFromStack integration tests
 //!
 
-use miniscript::extensions::{sighash_msg_price_oracle_1, check_sig_price_oracle_1};
-use miniscript::{elements, bitcoin, TxEnv};
 use elements::pset::PartiallySignedTransaction as Psbt;
 use elements::sighash::SigHashCache;
 use elements::taproot::{LeafVersion, TapLeafHash};
 use elements::{
-    confidential, pset as psbt, secp256k1_zkp as secp256k1, sighash, OutPoint, Script,
-    Sequence, TxIn, TxOut, Txid,
+    confidential, pset as psbt, secp256k1_zkp as secp256k1, sighash, OutPoint, Script, Sequence,
+    TxIn, TxOut, Txid,
 };
 use elementsd::ElementsD;
+use miniscript::extensions::{check_sig_price_oracle_1, sighash_msg_price_oracle_1};
 use miniscript::psbt::{PsbtInputExt, PsbtInputSatisfier};
-use miniscript::{Descriptor, Satisfier, ToPublicKey};
+use miniscript::{bitcoin, elements, Descriptor, Satisfier, ToPublicKey, TxEnv};
 use rand::RngCore;
 mod setup;
 use setup::test_util::{self, TestData, PARAMS};
@@ -137,10 +136,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
                 let x_only_pk = secp256k1::XOnlyPublicKey::from_keypair(&keypair).0;
                 psbt.inputs_mut()[0].tap_script_sigs.insert(
                     (x_only_pk, leaf_hash),
-                    elements::SchnorrSig {
-                        sig,
-                        hash_ty,
-                    },
+                    elements::SchnorrSig { sig, hash_ty },
                 );
             }
         }
@@ -181,10 +177,10 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
         }
 
         fn lookup_price_oracle_sig(
-                &self,
-                pk: &bitcoin::key::XOnlyPublicKey,
-                time: u64,
-            ) -> Option<(secp256k1::schnorr::Signature, i64, u64)> {
+            &self,
+            pk: &bitcoin::key::XOnlyPublicKey,
+            time: u64,
+        ) -> Option<(secp256k1::schnorr::Signature, i64, u64)> {
             let xpk = pk.to_x_only_pubkey();
             let known_xpks = &self.0.pubdata.x_only_pks;
             let i = known_xpks.iter().position(|&x| x == xpk).unwrap();
@@ -199,7 +195,13 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
 
             let secp = secp256k1::Secp256k1::new();
             let sig = secp.sign_schnorr_with_aux_rand(&sighash_msg, keypair, &aux_rand);
-            assert!(check_sig_price_oracle_1(&secp, &sig, &xpk, time_signed, price));
+            assert!(check_sig_price_oracle_1(
+                &secp,
+                &sig,
+                &xpk,
+                time_signed,
+                price
+            ));
             Some((sig, self.0.pubdata.price, time_signed))
         }
     }
@@ -210,7 +212,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
     let mut tx = psbt.extract_tx().unwrap();
     let txouts = vec![psbt.inputs()[0].witness_utxo.clone().unwrap()];
     let extracted_tx = tx.clone(); // Possible to optimize this, but we don't care for this
-    // Env requires reference of tx, while satisfaction requires mutable access to inputs.
+                                   // Env requires reference of tx, while satisfaction requires mutable access to inputs.
     let cov_sat = TxEnv::new(&extracted_tx, &txouts, 0).unwrap();
     derived_desc
         .satisfy(&mut tx.input[0], (psbt_sat, csfs_sat, cov_sat))
@@ -220,7 +222,6 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
         println!("Witness: {} {:x?}", wit.len(), wit);
     }
 
-
     // Send the transactions to bitcoin node for mining.
     // Regtest mode has standardness checks
     // Check whether the node accepts the transactions
@@ -258,14 +259,36 @@ fn test_descs(cl: &ElementsD, testdata: &TestData) {
 
     // test price oracle 1
     let price = testdata.pubdata.price;
-    let wit = test_desc_satisfy(cl, testdata, &format!("tr(X!,and_v(v:pk(X2),num64_eq(price_oracle1(X1,123213),{})))", price));
+    let wit = test_desc_satisfy(
+        cl,
+        testdata,
+        &format!(
+            "tr(X!,and_v(v:pk(X2),num64_eq(price_oracle1(X1,123213),{})))",
+            price
+        ),
+    );
     assert_eq!(wit.len(), 4 + 2); // 4 witness elements + 1 for price oracle + 1 for time
 
     // More complex tests
-    test_desc_satisfy(cl, testdata, "tr(X!,and_v(v:pk(X1),num64_eq(price_oracle1(X2,1),price_oracle1_w(X3,2))))");
-    test_desc_satisfy(cl, testdata, &format!("tr(X!,and_v(v:pk(X1),num64_eq({},price_oracle1_w(X3,2))))", price));
+    test_desc_satisfy(
+        cl,
+        testdata,
+        "tr(X!,and_v(v:pk(X1),num64_eq(price_oracle1(X2,1),price_oracle1_w(X3,2))))",
+    );
+    test_desc_satisfy(
+        cl,
+        testdata,
+        &format!(
+            "tr(X!,and_v(v:pk(X1),num64_eq({},price_oracle1_w(X3,2))))",
+            price
+        ),
+    );
     // Different keys and different times
-    test_desc_satisfy(cl, testdata, "tr(X!,and_v(v:pk(X2),num64_eq(price_oracle1(X3,1),price_oracle1_w(X4,23))))");
+    test_desc_satisfy(
+        cl,
+        testdata,
+        "tr(X!,and_v(v:pk(X2),num64_eq(price_oracle1(X3,1),price_oracle1_w(X4,23))))",
+    );
     // Combination with other arith fragments
     test_desc_satisfy(cl, testdata, "tr(X!,and_v(v:pk(X2),num64_eq(div(add(price_oracle1(X3,1),price_oracle1_w(X4,2)),2),price_oracle1_w(X5,2))))");
 }

diff --git a/bitcoind-tests/tests/test_desc.rs b/bitcoind-tests/tests/test_desc.rs
@@ -6,18 +6,19 @@
 
 use std::{error, fmt};
 
-use miniscript::{elements, bitcoin};
 use elements::hashes::{sha256d, Hash};
 use elements::pset::PartiallySignedTransaction as Psbt;
 use elements::sighash::SigHashCache;
 use elements::taproot::{LeafVersion, TapLeafHash};
 use elements::{
-    confidential, pset as psbt, secp256k1_zkp as secp256k1, sighash, OutPoint, SchnorrSig,
-    Script, Sequence, TxIn, TxOut, Txid,
+    confidential, pset as psbt, secp256k1_zkp as secp256k1, sighash, OutPoint, SchnorrSig, Script,
+    Sequence, TxIn, TxOut, Txid,
 };
 use elementsd::ElementsD;
 use miniscript::psbt::{PsbtExt, PsbtInputExt};
-use miniscript::{elementssig_to_rawsig, Descriptor, Miniscript, ScriptContext, ToPublicKey};
+use miniscript::{
+    bitcoin, elements, elementssig_to_rawsig, Descriptor, Miniscript, ScriptContext, ToPublicKey,
+};
 use rand::RngCore;
 mod setup;
 use ::secp256k1::Scalar;
@@ -205,10 +206,7 @@ pub fn test_desc_satisfy(
                 let (x_only_pk, _parity) = secp256k1::XOnlyPublicKey::from_keypair(&keypair);
                 psbt.inputs_mut()[0].tap_script_sigs.insert(
                     (x_only_pk, leaf_hash),
-                    elements::SchnorrSig {
-                        sig,
-                        hash_ty,
-                    },
+                    elements::SchnorrSig { sig, hash_ty },
                 );
             }
         }
@@ -286,7 +284,10 @@ pub fn test_desc_satisfy(
     println!("Testing descriptor: {}", definite_desc);
     // Finalize the transaction using psbt
     // Let miniscript do it's magic!
-    if psbt.finalize_mut(&secp, testdata.pubdata.genesis_hash).is_err() {
+    if psbt
+        .finalize_mut(&secp, testdata.pubdata.genesis_hash)
+        .is_err()
+    {
         return Err(DescError::PsbtFinalizeError);
     }
     let tx = psbt

diff --git a/bitcoind-tests/tests/test_introspect.rs b/bitcoind-tests/tests/test_introspect.rs
@@ -3,17 +3,16 @@
 //! Arith expression fragment integration tests
 //!
 
-use miniscript::elements;
 use elements::pset::PartiallySignedTransaction as Psbt;
 use elements::sighash::SigHashCache;
 use elements::taproot::{LeafVersion, TapLeafHash};
 use elements::{
-    confidential, pset as psbt, secp256k1_zkp as secp256k1, sighash, OutPoint, Script,
-    Sequence, TxIn, TxOut, Txid,
+    confidential, pset as psbt, secp256k1_zkp as secp256k1, sighash, OutPoint, Script, Sequence,
+    TxIn, TxOut, Txid,
 };
 use elementsd::ElementsD;
 use miniscript::psbt::{PsbtExt, PsbtInputExt};
-use miniscript::{Descriptor, ToPublicKey};
+use miniscript::{elements, Descriptor, ToPublicKey};
 use rand::RngCore;
 mod setup;
 use setup::test_util::{self, TestData, PARAMS};
@@ -136,10 +135,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
                 let x_only_pk = secp256k1::XOnlyPublicKey::from_keypair(&keypair).0;
                 psbt.inputs_mut()[0].tap_script_sigs.insert(
                     (x_only_pk, leaf_hash),
-                    elements::SchnorrSig {
-                        sig,
-                        hash_ty,
-                    },
+                    elements::SchnorrSig { sig, hash_ty },
                 );
             }
         }

diff --git a/contrib/test.sh b/contrib/test.sh
@@ -9,14 +9,11 @@ rustc --version
 
 # Pin dependencies required to build with Rust 1.48
 if cargo --version | grep "1\.48"; then
+    cargo update -p quote --precise 1.0.28
+    cargo update -p proc-macro2 --precise 1.0.63
     cargo update -p serde_json --precise 1.0.99
-    cargo update -p serde --precise 1.0.156
-    cargo update -p once_cell --precise 1.13.1
-    cargo update -p regex --precise 1.7.0
-    # These two needed for serde_derive with 1.48.0, *in addition*
-    # to pinning serde itself above.
-    cargo update -p quote --precise 1.0.30
-    cargo update -p proc-macro2 --precise 1.0.65
+    cargo update -p serde --precise 1.0.152
+    cargo update -p serde_test --precise 1.0.152
 fi
 
 # Format if told to