Remove secp context

Author: tcharding

bitcoind-tests/tests/setup/test_util.rs

@@ -65,7 +65,6 @@ fn setup_keys(
     Vec<bitcoin::secp256k1::Keypair>,
     Vec<XOnlyPublicKey>,
 ) {
-    let secp_sign = secp256k1::Secp256k1::signing_only();
     let mut sk = [0; 32];
     let mut sks = vec![];
     let mut pks = vec![];
@@ -76,7 +75,7 @@ fn setup_keys(
 
         let sk = secp256k1::SecretKey::from_slice(&sk[..]).expect("secret key");
         let pk = miniscript::bitcoin::PublicKey {
-            inner: secp256k1::PublicKey::from_secret_key(&secp_sign, &sk),
+            inner: secp256k1::PublicKey::from_secret_key(&sk),
             compressed: true,
         };
         pks.push(pk);
@@ -87,7 +86,7 @@ fn setup_keys(
     let mut x_only_pks = vec![];
 
     for sk in &sks {
-        let keypair = bitcoin::secp256k1::Keypair::from_secret_key(&secp_sign, sk);
+        let keypair = bitcoin::secp256k1::Keypair::from_secret_key(sk);
         let (xpk, _parity) = XOnlyPublicKey::from_keypair(&keypair);
         x_only_keypairs.push(keypair);
         x_only_pks.push(xpk);

bitcoind-tests/tests/test_cpp.rs

@@ -68,7 +68,6 @@ fn get_vout(cl: &Client, txid: Txid, value: Amount) -> (OutPoint, TxOut) {
 }
 
 pub fn test_from_cpp_ms(cl: &Client, testdata: &TestData) {
-    let secp = secp256k1::Secp256k1::new();
     let desc_vec = parse_miniscripts(&testdata.pubdata);
     let sks = &testdata.secretdata.sks;
     let pks = &testdata.pubdata.pks;
@@ -145,7 +144,7 @@ pub fn test_from_cpp_ms(cl: &Client, testdata: &TestData) {
     // Sign the transactions with all keys
     // AKA the signer role of psbt
     for i in 0..psbts.len() {
-        let wsh_derived = desc_vec[i].derived_descriptor(&secp);
+        let wsh_derived = desc_vec[i].derived_descriptor();
         let ms = if let Descriptor::Wsh(wsh) = &wsh_derived {
             match wsh.as_inner() {
                 miniscript::descriptor::WshInner::Ms(ms) => ms,
@@ -196,11 +195,11 @@ pub fn test_from_cpp_ms(cl: &Client, testdata: &TestData) {
             .insert(testdata.pubdata.ripemd160, testdata.secretdata.ripemd160_pre.to_vec());
         // Finalize the transaction using psbt
         // Let miniscript do it's magic!
-        if let Err(e) = psbts[i].finalize_mall_mut(&secp) {
+        if let Err(e) = psbts[i].finalize_mall_mut() {
             // All miniscripts should satisfy
             panic!("Could not satisfy: error{} ms:{} at ind:{}", e[0], ms, i);
         } else {
-            let tx = psbts[i].extract(&secp).unwrap();
+            let tx = psbts[i].extract().unwrap();
 
             // Send the transactions to bitcoin node for mining.
             // Regtest mode has standardness checks

bitcoind-tests/tests/test_desc.rs

@@ -73,7 +73,6 @@ pub fn test_desc_satisfy(
     testdata: &TestData,
     descriptor: &str,
 ) -> Result<Witness, DescError> {
-    let secp = secp256k1::Secp256k1::new();
     let sks = &testdata.secretdata.sks;
     let xonly_keypairs = &testdata.secretdata.x_only_keypairs;
     let pks = &testdata.pubdata.pks;
@@ -89,7 +88,7 @@ pub fn test_desc_satisfy(
         .at_derivation_index(0)
         .unwrap();
 
-    let derived_desc = definite_desc.derived_descriptor(&secp);
+    let derived_desc = definite_desc.derived_descriptor();
     let desc_address = derived_desc.address(bitcoin::Network::Regtest);
     let desc_address = desc_address.map_err(|_x| DescError::AddressComputationError)?;
 
@@ -169,7 +168,7 @@ pub fn test_desc_satisfy(
             if let Some(internal_keypair) = internal_keypair {
                 // ---------------------- Tr key spend --------------------
                 let internal_keypair = internal_keypair
-                    .tap_tweak(&secp, tr.spend_info().merkle_root());
+                    .tap_tweak(tr.spend_info().merkle_root());
                 let sighash_msg = sighash_cache
                     .taproot_key_spend_signature_hash(0, &prevouts, sighash_type)
                     .unwrap();
@@ -278,10 +277,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).is_err() {
+    if psbt.finalize_mut().is_err() {
         return Err(DescError::PsbtFinalizeError);
     }
-    let tx = psbt.extract(&secp).expect("Extraction error");
+    let tx = psbt.extract().expect("Extraction error");
 
     // Send the transactions to bitcoin node for mining.
     // Regtest mode has standardness checks

examples/big.rs

@@ -20,7 +20,7 @@ use miniscript::{
     translate_hash_fail, DefiniteDescriptorKey, Descriptor, DescriptorPublicKey, MiniscriptKey,
     Translator,
 };
-use secp256k1::Secp256k1;
+
 fn main() {
     let empty = "".to_string();
     let mut args = std::env::args().collect::<Vec<_>>();
@@ -39,8 +39,7 @@ fn main() {
         .unwrap();
     println!("{}", a);
 
-    let secp = Secp256k1::new();
-    let (d, m) = Descriptor::parse_descriptor(&secp, &i).unwrap();
+    let (d, m) = Descriptor::parse_descriptor(&i).unwrap();
     use_descriptor(d);
     println!("{:?}", m);
 
@@ -52,7 +51,7 @@ fn main() {
     println!("{:?}", h.address(bitcoin::Network::Bitcoin));
 
     let psbt: bitcoin::Psbt = i.parse().unwrap();
-    let psbt = psbt.finalize(&secp).unwrap();
+    let psbt = psbt.finalize().unwrap();
     let mut tx = psbt.extract_tx().unwrap();
     println!("{:?}", tx);
 

examples/psbt_sign_finalize.rs

@@ -18,8 +18,6 @@ use miniscript::psbt::{PsbtExt, PsbtInputExt};
 use miniscript::Descriptor;
 
 fn main() {
-    let secp256k1 = secp256k1::Secp256k1::new();
-
     let s = "wsh(t:or_c(pk(027a3565454fe1b749bccaef22aff72843a9c3efefd7b16ac54537a0c23f0ec0de),v:thresh(1,pkh(032d672a1a91cc39d154d366cd231983661b0785c7f27bc338447565844f4a6813),a:pkh(03417129311ed34c242c012cd0a3e0b9bca0065f742d0dfb63c78083ea6a02d4d9),a:pkh(025a687659658baeabdfc415164528065be7bcaade19342241941e556557f01e28))))#7hut9ukn";
     let bridge_descriptor = Descriptor::from_str(s).unwrap();
     //let bridge_descriptor = Descriptor::<bitcoin::PublicKey>::from_str(&s).expect("parse descriptor string");
@@ -142,7 +140,7 @@ fn main() {
     println!("{:#?}", psbt);
     println!("{}", psbt);
 
-    psbt.finalize_mut(&secp256k1).unwrap();
+    psbt.finalize_mut().unwrap();
     println!("{:#?}", psbt);
 
     let tx = psbt.extract_tx().expect("failed to extract tx");

examples/taptree_of_horror/helper_fns.rs

@@ -4,7 +4,6 @@ use bitcoin::bip32::{DerivationPath, Xpriv};
 use bitcoin::hashes::{ripemd160, sha256};
 use miniscript::descriptor::DescriptorSecretKey;
 use miniscript::ToPublicKey;
-use secp256k1::Secp256k1;
 
 use crate::KEYS_PER_PERSONA;
 
@@ -28,7 +27,6 @@ pub fn produce_kelly_hash(secret: &str) -> (sha256::Hash, sha256::Hash) {
 
 pub fn produce_key_pairs(
     desc: DescriptorSecretKey,
-    secp: &Secp256k1<secp256k1::All>,
     derivation_without_index: &str,
     _alias: &str,
 ) -> (Vec<bitcoin::PublicKey>, Vec<Xpriv>) {
@@ -42,7 +40,7 @@ pub fn produce_key_pairs(
 
     for i in 0..KEYS_PER_PERSONA {
         let pk = desc
-            .to_public(secp)
+            .to_public()
             .unwrap()
             .at_derivation_index(i.try_into().unwrap())
             .unwrap()

examples/taptree_of_horror/taptree_of_horror.rs

@@ -15,8 +15,6 @@ mod helper_fns;
 pub const KEYS_PER_PERSONA: usize = 9;
 
 fn main() {
-    let secp: &secp256k1::Secp256k1<secp256k1::All> = &secp256k1::Secp256k1::new();
-
     // ====== 1. Setup Hardcoded Values for all of the Personas ======
 
     // Define derivation paths that will be used
@@ -59,7 +57,7 @@ fn main() {
     // ====== 2. Derive Keys, Preimages, Hashes, and Timelocks for Policy and Signing ======
 
     let internal_xpub: miniscript::DescriptorPublicKey =
-        internal_desc_secret.to_public(secp).unwrap();
+        internal_desc_secret.to_public().unwrap();
 
     // example of how defining the internal xpriv that can be used for signing.
     // let internal_xpriv: DescriptorXKey<bitcoin::bip32::Xpriv> = match internal_desc_secret {
@@ -68,20 +66,20 @@ fn main() {
     // }
     // .unwrap();
 
-    let (a_pks, a_prvs) = produce_key_pairs(a_descriptor_desc_secret, secp, normal_path, "alice");
-    let (b_pks, b_prvs) = produce_key_pairs(b_descriptor_desc_secret, secp, normal_path, "bob");
-    let (c_pks, c_prvs) = produce_key_pairs(c_descriptor_desc_secret, secp, normal_path, "charlie");
-    let (d_pks, d_prvs) = produce_key_pairs(d_descriptor_desc_secret, secp, weird_path, "dave");
-    let (e_pks, e_prvs) = produce_key_pairs(e_descriptor_desc_secret, secp, normal_path, "eve");
-    let (f_pks, f_prvs) = produce_key_pairs(f_descriptor_desc_secret, secp, normal_path, "frank");
-    let (h_pks, h_prvs) = produce_key_pairs(h_descriptor_desc_secret, secp, normal_path, "heather");
-    let (i_pks, i_prvs) = produce_key_pairs(i_descriptor_desc_secret, secp, unhardened_path, "ian");
-    let (j_pks, j_prvs) = produce_key_pairs(j_descriptor_desc_secret, secp, normal_path, "judy");
-    let (l_pks, l_prvs) = produce_key_pairs(l_descriptor_desc_secret, secp, normal_path, "liam");
+    let (a_pks, a_prvs) = produce_key_pairs(a_descriptor_desc_secret, normal_path, "alice");
+    let (b_pks, b_prvs) = produce_key_pairs(b_descriptor_desc_secret, normal_path, "bob");
+    let (c_pks, c_prvs) = produce_key_pairs(c_descriptor_desc_secret, normal_path, "charlie");
+    let (d_pks, d_prvs) = produce_key_pairs(d_descriptor_desc_secret, weird_path, "dave");
+    let (e_pks, e_prvs) = produce_key_pairs(e_descriptor_desc_secret, normal_path, "eve");
+    let (f_pks, f_prvs) = produce_key_pairs(f_descriptor_desc_secret, normal_path, "frank");
+    let (h_pks, h_prvs) = produce_key_pairs(h_descriptor_desc_secret, normal_path, "heather");
+    let (i_pks, i_prvs) = produce_key_pairs(i_descriptor_desc_secret, unhardened_path, "ian");
+    let (j_pks, j_prvs) = produce_key_pairs(j_descriptor_desc_secret, normal_path, "judy");
+    let (l_pks, l_prvs) = produce_key_pairs(l_descriptor_desc_secret, normal_path, "liam");
     let (s_pks, _s_prvs) =
-        produce_key_pairs(s_descriptor_desc_secret, secp, normal_path, "s_backup1");
+        produce_key_pairs(s_descriptor_desc_secret, normal_path, "s_backup1");
     let (x_pks, _x_prvs) =
-        produce_key_pairs(x_descriptor_desc_secret, secp, normal_path, "x_backup2");
+        produce_key_pairs(x_descriptor_desc_secret, normal_path, "x_backup2");
 
     // For this example we are grabbing the 9 keys for each persona
     let [a0, a1, a2, a3, a4, a5, a6, a7, a8]: [PublicKey; KEYS_PER_PERSONA] =
@@ -201,8 +199,6 @@ fn main() {
 
     // ====== 4. Construct an Unsigned Transaction from the Tapscript ======
 
-    let secp: &secp256k1::Secp256k1<secp256k1::All> = &secp256k1::Secp256k1::new();
-
     let tx_in = TxIn {
         previous_output: bitcoin::OutPoint {
             txid: "8888888899999999aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffff"
@@ -273,7 +269,7 @@ fn main() {
         .insert(grim.1, grim.0.to_byte_array().to_vec());
 
     // Finalize PSBT now that we have all the required signatures and hash preimages.
-    psbt.finalize_mut(secp).unwrap();
+    psbt.finalize_mut().unwrap();
 
     // Now extract the tx
     let signed_tx = psbt.extract_tx().unwrap();

examples/verify_tx.rs

@@ -6,7 +6,6 @@ use std::str::FromStr;
 
 use miniscript::bitcoin::consensus::Decodable;
 use miniscript::bitcoin::script::ScriptPubKeyBuf;
-use miniscript::bitcoin::secp256k1::Secp256k1;
 use miniscript::bitcoin::{absolute, sighash, Sequence};
 use miniscript::interpreter::KeySigPair;
 
@@ -64,13 +63,12 @@ fn main() {
     // as having participated in the script
 
     println!("\n\nExample two:\n");
-    let secp = Secp256k1::new();
 
     // We can set prevouts to be empty list because this is a legacy transaction
     // and this information is not required for sighash computation.
     let prevouts = sighash::Prevouts::All::<bitcoin::TxOut>(&[]);
 
-    for elem in interpreter.iter(&secp, &tx, 0, &prevouts) {
+    for elem in interpreter.iter(&tx, 0, &prevouts) {
         if let miniscript::interpreter::SatisfiedConstraint::PublicKey { key_sig } =
             elem.expect("no evaluation error")
         {

examples/xpub_descriptors.rs

@@ -4,33 +4,29 @@
 
 use std::str::FromStr;
 
-use miniscript::bitcoin::secp256k1::{Secp256k1, Verification};
 use miniscript::bitcoin::{Address, Network};
 use miniscript::{DefiniteDescriptorKey, Descriptor, DescriptorPublicKey};
 
 const XPUB_1: &str = "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB";
 const XPUB_2: &str = "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH";
 
 fn main() {
-    // For deriving from descriptors, we need to provide a secp context.
-    let secp = Secp256k1::verification_only();
-
     // P2WSH and single xpubs.
-    let _ = p2wsh(&secp);
+    let _ = p2wsh();
 
     // P2WSH-P2SH and ranged xpubs.
-    let _ = p2sh_p2wsh(&secp);
+    let _ = p2sh_p2wsh();
 }
 
 /// Parses a P2WSH descriptor, returns the associated address.
-fn p2wsh<C: Verification>(secp: &Secp256k1<C>) -> Address {
+fn p2wsh() -> Address {
     // It does not matter what order the two xpubs go in, the same address will be generated.
     let s = format!("wsh(sortedmulti(1,{},{}))", XPUB_1, XPUB_2);
     // let s = format!("wsh(sortedmulti(1,{},{}))", XPUB_2, XPUB_1);
 
     let address = Descriptor::<DefiniteDescriptorKey>::from_str(&s)
         .unwrap()
-        .derived_descriptor(secp)
+        .derived_descriptor()
         .address(Network::Bitcoin)
         .unwrap();
 
@@ -45,14 +41,14 @@ fn p2wsh<C: Verification>(secp: &Secp256k1<C>) -> Address {
 }
 
 /// Parses a P2SH-P2WSH descriptor, returns the associated address.
-fn p2sh_p2wsh<C: Verification>(secp: &Secp256k1<C>) -> Address {
+fn p2sh_p2wsh() -> Address {
     // It does not matter what order the two xpubs go in, the same address will be generated.
     let s = format!("sh(wsh(sortedmulti(1,{}/1/0/*,{}/0/0/*)))", XPUB_1, XPUB_2);
     // let s = format!("sh(wsh(sortedmulti(1,{}/1/0/*,{}/0/0/*)))", XPUB_2, XPUB_1);
 
     let address = Descriptor::<DescriptorPublicKey>::from_str(&s)
         .unwrap()
-        .derived_descriptor(secp, 5)
+        .derived_descriptor(5)
         .unwrap()
         .address(Network::Bitcoin)
         .unwrap();

fuzz/fuzz_targets/parse_descriptor_priv.rs

@@ -6,9 +6,8 @@ use miniscript::Descriptor;
 
 fn do_test(data: &[u8]) {
     let data_str = String::from_utf8_lossy(data);
-    let secp = &secp256k1::Secp256k1::signing_only();
 
-    if let Ok((desc, _)) = Descriptor::parse_descriptor(secp, &data_str) {
+    if let Ok((desc, _)) = Descriptor::parse_descriptor(&data_str) {
         let _output = desc.to_string();
         let _sanity_check = desc.sanity_check();
     }