Remove secp context

Author: tcharding

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