Public commit record
28/100 · Opaque
What the developer wrote
Authored by Tobin C. Harding
Remove the secp context
BOOM!
✓ Subject identifies a change! No meaningful explanatory body! Opaque security-relevant change
What changed, and why it matters
This commit is a large API refactoring in the rust-bitcoin library. It removes the need for callers to pass an explicit secp256k1 cryptographic context object to many functions. Instead, the library now uses a global or internally-managed context. The change touches examples, tests, and core modules for addresses, BIP32 key derivation, scripts, PSBT signing, message signing, and Taproot. There is no direct evidence in the commit that this fixes a security vulnerability; it appears to be a usability and maintainability improvement.
Recommended action
Treat this as a breaking API change rather than a security patch. Consumers of rust-bitcoin should update their code to remove explicit secp256k1 context arguments. Review the release notes for any additional guidance on the new context management behavior. No urgent security action is indicated by this commit alone.
Security signals we found
01
Large API surface change removing explicit secp256k1 context parameters
02
No new input validation, bounds checks, or cryptographic operations added
03
No mention of vulnerability, CVE, security fix, or bug in commit message
04
No changes to secret-handling, memory zeroization, or error paths
05
Examples and tests updated to match new API signatures
Evidence from the diff
The commit removes the secp: &Secp256k1<C> parameter from dozens of public APIs across the crate. Affected functions include PrivateKey::public_key, Xpriv::derive_xpriv, Xpub::from_xpriv, Address::p2tr, ScriptPubKeyBuf::new_p2tr, WitnessProgram::p2tr, TapTweak::tap_tweak, Psbt::sign, GetKey::get_key, MessageSignature::recover_pubkey, and TaprootBuilder::finalize. The diff shows only signature and call-site updates; no new validation, bounds checks, or cryptographic logic is introduced. The change is consistent with upstream rust-secp256k1 moving to context-less APIs. No security relevance is stated by the vendor, and no CVE or advisory is referenced.
Changed components
bitcoin/src/crypto/key.rsbitcoin/src/bip32.rsbitcoin/src/address/mod.rsbitcoin/src/blockdata/script/owned.rsbitcoin/src/blockdata/script/borrowed.rsbitcoin/src/blockdata/script/witness_program.rsbitcoin/src/taproot/mod.rsbitcoin/src/psbt/mod.rsbitcoin/src/sign_message.rsbitcoin/examples/*bitcoin/tests/*Inspect captured patch +263 / −401
diff --git a/bitcoin/embedded/src/main.rs b/bitcoin/embedded/src/main.rs
index 5ec9cb07..97d97118 100644
--- a/bitcoin/embedded/src/main.rs
+++ b/bitcoin/embedded/src/main.rs
@@ -7,12 +7,9 @@ extern crate alloc;
extern crate bitcoin;
use alloc::string::ToString;
-use alloc::vec;
use core::panic::PanicInfo;
use alloc_cortex_m::CortexMHeap;
-use bitcoin::secp256k1::ffi::types::AlignedType;
-use bitcoin::secp256k1::Secp256k1;
// use panic_halt as _;
use bitcoin::{Address, Network, PrivateKey};
use cortex_m_rt::entry;
@@ -30,19 +27,13 @@ fn main() -> ! {
unsafe { ALLOCATOR.init(cortex_m_rt::heap_start() as usize, HEAP_SIZE) }
- let size = Secp256k1::preallocate_size();
- hprintln!("secp buf size {}", size * 16).unwrap();
-
// Load a private key
let raw = "L1HKVVLHXiUhecWnwFYF6L3shkf1E12HUmuZTESvBXUdx3yqVP1D";
let pk = PrivateKey::from_wif(raw).unwrap();
hprintln!("Seed WIF: {}", pk).unwrap();
- let mut buf_ful = vec![AlignedType::zeroed(); size];
- let secp = Secp256k1::preallocated_new(&mut buf_ful).unwrap();
-
// Derive address
- let pubkey = pk.public_key(&secp).try_into().unwrap();
+ let pubkey = pk.public_key().try_into().unwrap();
let address = Address::p2wpkh(pubkey, Network::Bitcoin);
hprintln!("Address: {}", address).unwrap();
diff --git a/bitcoin/examples/bip32.rs b/bitcoin/examples/bip32.rs
index d8edab2f..886a0303 100644
--- a/bitcoin/examples/bip32.rs
+++ b/bitcoin/examples/bip32.rs
@@ -3,8 +3,6 @@ use std::{env, process};
use bitcoin::address::{Address, KnownHrp};
use bitcoin::bip32::{ChildNumber, DerivationPath, Xpriv, Xpub};
use bitcoin::hex::FromHex;
-use bitcoin::secp256k1::ffi::types::AlignedType;
-use bitcoin::secp256k1::Secp256k1;
use bitcoin::{CompressedPublicKey, NetworkKind};
fn main() {
@@ -27,26 +25,21 @@ fn main() {
let seed = Vec::from_hex(seed_hex).unwrap();
- // we need secp256k1 context for key derivation
- let mut buf: Vec<AlignedType> = Vec::new();
- buf.resize(Secp256k1::preallocate_size(), AlignedType::zeroed());
- let secp = Secp256k1::preallocated_new(buf.as_mut_slice()).unwrap();
-
// calculate root key from seed
let root = Xpriv::new_master(NetworkKind::Main, &seed);
println!("Root key: {root}");
// derive child xpub
let path = "84h/0h/0h".parse::<DerivationPath>().unwrap();
- let child = root.derive_xpriv(&secp, &path).expect("only deriving three steps");
+ let child = root.derive_xpriv(&path).expect("only deriving three steps");
println!("Child at {path}: {child}");
- let xpub = Xpub::from_xpriv(&secp, &child);
+ let xpub = Xpub::from_xpriv(&child);
println!("Public key at {path}: {xpub}");
// generate first receiving address at m/0/0
// manually creating indexes this time
let zero = ChildNumber::ZERO_NORMAL;
- let public_key = xpub.derive_xpub(&secp, [zero, zero]).unwrap().public_key;
+ let public_key = xpub.derive_xpub([zero, zero]).unwrap().public_key;
let address = Address::p2wpkh(CompressedPublicKey(public_key), KnownHrp::Mainnet);
println!("First receiving address: {address}");
}
diff --git a/bitcoin/examples/create-p2wpkh-address.rs b/bitcoin/examples/create-p2wpkh-address.rs
index ff2290bb..d1a32759 100644
--- a/bitcoin/examples/create-p2wpkh-address.rs
+++ b/bitcoin/examples/create-p2wpkh-address.rs
@@ -1,12 +1,9 @@
-use bitcoin::secp256k1::{rand, Secp256k1};
+use bitcoin::secp256k1::rand;
use bitcoin::{Address, CompressedPublicKey, Network, PrivateKey};
/// Generate a P2WPKH (pay-to-witness-public-key-hash) address and print it
/// along with the associated private key needed to transact.
fn main() {
- // Create new secp256k1 instance.
- let secp = Secp256k1::new();
-
// Generate secp256k1 public and private key pair.
let (secret_key, public_key) = secp256k1::generate_keypair(&mut rand::rng());
diff --git a/bitcoin/examples/ecdsa-psbt-simple.rs b/bitcoin/examples/ecdsa-psbt-simple.rs
index 8c6139d8..ab2341d0 100644
--- a/bitcoin/examples/ecdsa-psbt-simple.rs
+++ b/bitcoin/examples/ecdsa-psbt-simple.rs
@@ -29,7 +29,6 @@ use bitcoin::ext::*;
use bitcoin::key::WPubkeyHash;
use bitcoin::locktime::absolute;
use bitcoin::psbt::Input;
-use bitcoin::secp256k1::{Secp256k1, Signing};
use bitcoin::{
consensus, transaction, Address, Amount, EcdsaSighashType, Network, OutPoint, Psbt,
RedeemScriptBuf, ScriptPubKeyBuf, ScriptSigBuf, Sequence, Transaction, TxIn, TxOut, Txid,
@@ -55,35 +54,33 @@ const SPEND_AMOUNT: Amount = Amount::from_sat_u32(25_000_000);
const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(4_990_000); // 10_000 sat fee.
// Derive the external address xpriv.
-fn get_external_address_xpriv<C: Signing>(
- secp: &Secp256k1<C>,
+fn get_external_address_xpriv(
master_xpriv: Xpriv,
index: u32,
) -> Xpriv {
let derivation_path =
BIP84_DERIVATION_PATH.into_derivation_path().expect("valid derivation path");
let child_xpriv =
- master_xpriv.derive_xpriv(secp, &derivation_path).expect("only deriving three steps");
+ master_xpriv.derive_xpriv(&derivation_path).expect("only deriving three steps");
let external_index = ChildNumber::ZERO_NORMAL;
let idx = ChildNumber::from_normal_idx(index).expect("valid index number");
- child_xpriv.derive_xpriv(secp, [external_index, idx]).expect("only deriving two more steps")
+ child_xpriv.derive_xpriv([external_index, idx]).expect("only deriving two more steps")
}
// Derive the internal address xpriv.
-fn get_internal_address_xpriv<C: Signing>(
- secp: &Secp256k1<C>,
+fn get_internal_address_xpriv(
master_xpriv: Xpriv,
index: u32,
) -> Xpriv {
let derivation_path =
BIP84_DERIVATION_PATH.into_derivation_path().expect("valid derivation path");
let child_xpriv =
- master_xpriv.derive_xpriv(secp, &derivation_path).expect("only deriving three steps");
+ master_xpriv.derive_xpriv(&derivation_path).expect("only deriving three steps");
let internal_index = ChildNumber::ONE_NORMAL;
let idx = ChildNumber::from_normal_idx(index).expect("valid index number");
- child_xpriv.derive_xpriv(secp, [internal_index, idx]).expect("only deriving two more steps")
+ child_xpriv.derive_xpriv([internal_index, idx]).expect("only deriving two more steps")
}
// The address to send to.
@@ -128,19 +125,17 @@ fn dummy_unspent_transaction_outputs() -> Vec<(OutPoint, TxOut)> {
}
fn main() {
- let secp = Secp256k1::new();
-
// Get the individual xprivs we control. In a real application these would come from a stored secret.
let master_xpriv = XPRIV.parse::<Xpriv>().expect("valid xpriv");
- let xpriv_input_1 = get_external_address_xpriv(&secp, master_xpriv, 0);
- let xpriv_input_2 = get_internal_address_xpriv(&secp, master_xpriv, 0);
- let xpriv_change = get_internal_address_xpriv(&secp, master_xpriv, 1);
+ let xpriv_input_1 = get_external_address_xpriv(master_xpriv, 0);
+ let xpriv_input_2 = get_internal_address_xpriv(master_xpriv, 0);
+ let xpriv_change = get_internal_address_xpriv(master_xpriv, 1);
// Get the PKs
- let pk_input_1 = Xpub::from_xpriv(&secp, &xpriv_input_1).to_public_key();
- let pk_input_2 = Xpub::from_xpriv(&secp, &xpriv_input_2).to_public_key();
+ let pk_input_1 = Xpub::from_xpriv(&xpriv_input_1).to_public_key();
+ let pk_input_2 = Xpub::from_xpriv(&xpriv_input_2).to_public_key();
let pk_inputs = [pk_input_1, pk_input_2];
- let pk_change = Xpub::from_xpriv(&secp, &xpriv_change).to_public_key();
+ let pk_change = Xpub::from_xpriv(&xpriv_change).to_public_key();
// Get the Witness Public Key Hashes (WPKHs)
let wpkhs: Vec<WPubkeyHash> = pk_inputs.iter().map(|pk| pk.wpubkey_hash()).collect();
@@ -218,7 +213,7 @@ fn main() {
];
// Step 3: Signer role; that signs the PSBT.
- psbt.sign(&master_xpriv, &secp).expect("valid signature");
+ psbt.sign(&master_xpriv).expect("valid signature");
// Step 4: Finalizer role; that finalizes the PSBT.
println!("PSBT Inputs: {:#?}", psbt.inputs);
diff --git a/bitcoin/examples/ecdsa-psbt.rs b/bitcoin/examples/ecdsa-psbt.rs
index 10d9abe4..393c0ada 100644
--- a/bitcoin/examples/ecdsa-psbt.rs
+++ b/bitcoin/examples/ecdsa-psbt.rs
@@ -36,7 +36,6 @@ use bitcoin::consensus::encode;
use bitcoin::ext::*;
use bitcoin::locktime::absolute;
use bitcoin::psbt::{self, Input, Psbt, PsbtSighashType};
-use bitcoin::secp256k1::{Secp256k1, Signing, Verification};
use bitcoin::{
transaction, Address, Amount, CompressedPublicKey, Network, OutPoint, RedeemScriptBuf,
ScriptPubKeyBuf, ScriptSigBuf, Sequence, Transaction, TxIn, TxOut, Witness,
@@ -66,17 +65,15 @@ const CHANGE_AMOUNT_BTC: &str = "48.99999 BTC"; // 1000 sat transaction fee.
const NETWORK: Network = Network::Regtest;
fn main() -> Result<()> {
- let secp = Secp256k1::new();
-
let (offline, fingerprint, account_0_xpub, input_xpub) =
- ColdStorage::new(&secp, EXTENDED_MASTER_PRIVATE_KEY)?;
+ ColdStorage::new(EXTENDED_MASTER_PRIVATE_KEY)?;
let online = WatchOnly::new(account_0_xpub, input_xpub, fingerprint);
- let created = online.create_psbt(&secp)?;
+ let created = online.create_psbt()?;
let updated = online.update_psbt(created)?;
- let signed = offline.sign_psbt(&secp, updated)?;
+ let signed = offline.sign_psbt(updated)?;
let finalized = online.finalize_psbt(signed)?;
@@ -109,20 +106,20 @@ impl ColdStorage {
/// # Returns
///
/// The newly created signer along with the data needed to configure a watch-only wallet.
- fn new<C: Signing>(secp: &Secp256k1<C>, xpriv: &str) -> Result<ExportData> {
+ fn new(xpriv: &str) -> Result<ExportData> {
let master_xpriv = xpriv.parse::<Xpriv>()?;
- let master_xpub = Xpub::from_xpriv(secp, &master_xpriv);
+ let master_xpub = Xpub::from_xpriv(&master_xpriv);
// Hardened children require secret data to derive.
let path = "84h/0h/0h".into_derivation_path()?;
let account_0_xpriv =
- master_xpriv.derive_xpriv(secp, &path).expect("derivation path is short");
- let account_0_xpub = Xpub::from_xpriv(secp, &account_0_xpriv);
+ master_xpriv.derive_xpriv(&path).expect("derivation path is short");
+ let account_0_xpub = Xpub::from_xpriv(&account_0_xpriv);
let path = INPUT_UTXO_DERIVATION_PATH.into_derivation_path()?;
- let input_xpriv = master_xpriv.derive_xpriv(secp, &path).expect("derivation path is short");
- let input_xpub = Xpub::from_xpriv(secp, &input_xpriv);
+ let input_xpriv = master_xpriv.derive_xpriv(&path).expect("derivation path is short");
+ let input_xpub = Xpub::from_xpriv(&input_xpriv);
let wallet = Self { master_xpriv, master_xpub };
let fingerprint = wallet.master_fingerprint();
@@ -134,12 +131,11 @@ impl ColdStorage {
fn master_fingerprint(&self) -> Fingerprint { self.master_xpub.fingerprint() }
/// Signs `psbt` with this signer.
- fn sign_psbt<C: Signing + Verification>(
+ fn sign_psbt(
&self,
- secp: &Secp256k1<C>,
mut psbt: Psbt,
) -> Result<Psbt> {
- match psbt.sign(&self.master_xpriv, secp) {
+ match psbt.sign(&self.master_xpriv) {
Ok(keys) => assert_eq!(keys.len(), 1),
Err((_, e)) => {
let e = e.get(&0).expect("at least one error");
@@ -173,12 +169,12 @@ impl WatchOnly {
}
/// Creates the PSBT, in BIP-0174 parlance this is the 'Creator'.
- fn create_psbt<C: Verification>(&self, secp: &Secp256k1<C>) -> Result<Psbt> {
+ fn create_psbt(&self) -> Result<Psbt> {
let to_address =
RECEIVE_ADDRESS.parse::<Address<_>>()?.require_network(Network::Regtest)?;
let to_amount = OUTPUT_AMOUNT_BTC.parse::<Amount>()?;
- let (_, change_address, _) = self.change_address(secp)?;
+ let (_, change_address, _) = self.change_address()?;
let change_amount = CHANGE_AMOUNT_BTC.parse::<Amount>()?;
let tx = Transaction {
@@ -253,12 +249,11 @@ impl WatchOnly {
/// "m/84h/0h/0h/1/0"). A real wallet would have access to the chain so could determine if an
/// address has been used or not. We ignore this detail and just re-use the first change address
/// without loss of generality.
- fn change_address<C: Verification>(
+ fn change_address(
&self,
- secp: &Secp256k1<C>,
) -> Result<(CompressedPublicKey, Address, DerivationPath)> {
let path = [ChildNumber::ONE_NORMAL, ChildNumber::ZERO_NORMAL];
- let derived = self.account_0_xpub.derive_xpub(secp, path)?;
+ let derived = self.account_0_xpub.derive_xpub(path)?;
let pk = derived.to_public_key();
let addr = Address::p2wpkh(pk, NETWORK);
diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index 0c932560..1440cbbf 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -48,8 +48,7 @@ fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, amount: Amount) {
println!("SegWit p2wpkh sighash: {sighash:x}");
let msg = secp256k1::Message::from(sighash);
println!("Message is {msg:x}");
- let secp = secp256k1::Secp256k1::verification_only();
- pk.verify(&secp, msg, sig).unwrap()
+ pk.verify(msg, sig).unwrap()
}
/// Computes sighash for a legacy multisig transaction input that spends either a p2sh or a p2ms output.
diff --git a/bitcoin/examples/sign-tx-segwit-v0.rs b/bitcoin/examples/sign-tx-segwit-v0.rs
index 744e68e4..5f64df68 100644
--- a/bitcoin/examples/sign-tx-segwit-v0.rs
+++ b/bitcoin/examples/sign-tx-segwit-v0.rs
@@ -5,7 +5,7 @@
use bitcoin::ext::*;
use bitcoin::key::WPubkeyHash;
use bitcoin::locktime::absolute;
-use bitcoin::secp256k1::{rand, Message, Secp256k1, SecretKey, Signing};
+use bitcoin::secp256k1::{rand, Message, SecretKey};
use bitcoin::sighash::{EcdsaSighashType, SighashCache};
use bitcoin::{
transaction, Address, Amount, Network, OutPoint, ScriptPubKeyBuf, ScriptSigBuf, Sequence,
@@ -17,11 +17,9 @@ const SPEND_AMOUNT: Amount = Amount::from_sat_u32(5_000_000);
const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(14_999_000); // 1000 sat fee.
fn main() {
- let secp = Secp256k1::new();
-
// Get a secret key we control and the pubkeyhash of the associated pubkey.
// In a real application these would come from a stored secret.
- let (sk, wpkh) = senders_keys(&secp);
+ let (sk, wpkh) = senders_keys();
// Get an address to send to.
let address = receivers_address();
@@ -87,7 +85,7 @@ fn main() {
/// An example of keys controlled by the transaction sender.
///
/// In a real application these would be actual secrets.
-fn senders_keys<C: Signing>(secp: &Secp256k1<C>) -> (SecretKey, WPubkeyHash) {
+fn senders_keys() -> (SecretKey, WPubkeyHash) {
let sk = SecretKey::new(&mut rand::rng());
let pk = bitcoin::PublicKey::new(sk.public_key());
let wpkh = pk.wpubkey_hash().expect("key is compressed");
diff --git a/bitcoin/examples/sign-tx-taproot.rs b/bitcoin/examples/sign-tx-taproot.rs
index 6fd28f68..a1554966 100644
--- a/bitcoin/examples/sign-tx-taproot.rs
+++ b/bitcoin/examples/sign-tx-taproot.rs
@@ -5,7 +5,7 @@
use bitcoin::ext::*;
use bitcoin::key::{Keypair, TapTweak, TweakedKeypair, UntweakedPublicKey};
use bitcoin::locktime::absolute;
-use bitcoin::secp256k1::{rand, Secp256k1, SecretKey, Signing, Verification};
+use bitcoin::secp256k1::{rand, SecretKey};
use bitcoin::sighash::{Prevouts, SighashCache, TapSighashType};
use bitcoin::{
transaction, Address, Amount, Network, OutPoint, ScriptPubKeyBuf, ScriptSigBuf, Sequence,
@@ -17,15 +17,13 @@ const SPEND_AMOUNT: Amount = Amount::from_sat_u32(5_000_000);
const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(14_999_000); // 1000 sat fee.
fn main() {
- let secp = Secp256k1::new();
-
// Get a keypair we control. In a real application these would come from a stored secret.
- let keypair = senders_keys(&secp);
+ let keypair = senders_keys();
let (internal_key, _parity) = keypair.x_only_public_key();
// Get an unspent output that is locked to the key above that we control.
// In a real application these would come from the chain.
- let (dummy_out_point, dummy_utxo) = dummy_unspent_transaction_output(&secp, internal_key);
+ let (dummy_out_point, dummy_utxo) = dummy_unspent_transaction_output(internal_key);
// Get an address to send to.
let address = receivers_address();
@@ -44,7 +42,7 @@ fn main() {
// The change output is locked to a key controlled by us.
let change = TxOut {
amount: CHANGE_AMOUNT,
- script_pubkey: ScriptPubKeyBuf::new_p2tr(&secp, internal_key, None), // Change comes back to us.
+ script_pubkey: ScriptPubKeyBuf::new_p2tr(internal_key, None), // Change comes back to us.
};
// The transaction we want to sign and broadcast.
@@ -68,7 +66,7 @@ fn main() {
.expect("failed to construct sighash");
// Sign the sighash using the secp256k1 library (exported by rust-bitcoin).
- let tweaked: TweakedKeypair = keypair.tap_tweak(&secp, None);
+ let tweaked: TweakedKeypair = keypair.tap_tweak(None);
let signature = secp256k1::schnorr::sign(&sighash.to_byte_array(), tweaked.as_keypair());
// Update the witness stack.
@@ -85,7 +83,7 @@ fn main() {
/// An example of keys controlled by the transaction sender.
///
/// In a real application these would be actual secrets.
-fn senders_keys<C: Signing>(secp: &Secp256k1<C>) -> Keypair {
+fn senders_keys() -> Keypair {
let sk = SecretKey::new(&mut rand::rng());
Keypair::from_secret_key(&sk)
}
@@ -111,12 +109,11 @@ fn receivers_address() -> Address {
///
/// This output is locked to keys that we control, in a real application this would be a valid
/// output taken from a transaction that appears in the chain.
-fn dummy_unspent_transaction_output<C: Verification, K: Into<UntweakedPublicKey>>(
- secp: &Secp256k1<C>,
+fn dummy_unspent_transaction_output<K: Into<UntweakedPublicKey>>(
internal_key: K,
) -> (OutPoint, TxOut) {
let internal_key = internal_key.into();
- let script_pubkey = ScriptPubKeyBuf::new_p2tr(secp, internal_key, None);
+ let script_pubkey = ScriptPubKeyBuf::new_p2tr(internal_key, None);
let out_point = OutPoint {
txid: Txid::from_byte_array([0xFF; 32]), // Arbitrary invalid dummy value.
diff --git a/bitcoin/examples/taproot-psbt-simple.rs b/bitcoin/examples/taproot-psbt-simple.rs
index 64567851..9ab4bfe4 100644
--- a/bitcoin/examples/taproot-psbt-simple.rs
+++ b/bitcoin/examples/taproot-psbt-simple.rs
@@ -27,7 +27,6 @@ use bitcoin::ext::*;
use bitcoin::key::UntweakedPublicKey;
use bitcoin::locktime::absolute;
use bitcoin::psbt::Input;
-use bitcoin::secp256k1::{Secp256k1, Signing};
use bitcoin::{
consensus, transaction, Address, Amount, Network, OutPoint, Psbt, ScriptPubKeyBuf,
ScriptSigBuf, Sequence, TapLeafHash, TapSighashType, Transaction, TxIn, TxOut, Txid, Witness,
@@ -53,35 +52,33 @@ const SPEND_AMOUNT: Amount = Amount::from_sat_u32(25_000_000);
const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(4_990_000); // 10_000 sat fee.
// Derive the external address xpriv.
-fn get_external_address_xpriv<C: Signing>(
- secp: &Secp256k1<C>,
+fn get_external_address_xpriv(
master_xpriv: Xpriv,
index: u32,
) -> Xpriv {
let derivation_path =
BIP86_DERIVATION_PATH.into_derivation_path().expect("valid derivation path");
let child_xpriv =
- master_xpriv.derive_xpriv(secp, &derivation_path).expect("only deriving three steps");
+ master_xpriv.derive_xpriv(&derivation_path).expect("only deriving three steps");
let external_index = ChildNumber::ZERO_NORMAL;
let idx = ChildNumber::from_normal_idx(index).expect("valid index number");
- child_xpriv.derive_xpriv(secp, [external_index, idx]).expect("only deriving two more steps")
+ child_xpriv.derive_xpriv([external_index, idx]).expect("only deriving two more steps")
}
// Derive the internal address xpriv.
-fn get_internal_address_xpriv<C: Signing>(
- secp: &Secp256k1<C>,
+fn get_internal_address_xpriv(
master_xpriv: Xpriv,
index: u32,
) -> Xpriv {
let derivation_path =
BIP86_DERIVATION_PATH.into_derivation_path().expect("valid derivation path");
let child_xpriv =
- master_xpriv.derive_xpriv(secp, &derivation_path).expect("only deriving three steps");
+ master_xpriv.derive_xpriv(&derivation_path).expect("only deriving three steps");
let internal_index = ChildNumber::ONE_NORMAL;
let idx = ChildNumber::from_normal_idx(index).expect("valid index number");
- child_xpriv.derive_xpriv(secp, [internal_index, idx]).expect("only deriving two more steps")
+ child_xpriv.derive_xpriv([internal_index, idx]).expect("only deriving two more steps")
}
// Get the Taproot Key Origin.
@@ -138,18 +135,16 @@ fn dummy_unspent_transaction_outputs() -> Vec<(OutPoint, TxOut)> {
}
fn main() {
- let secp = Secp256k1::new();
-
// Get the individual xprivs we control. In a real application these would come from a stored secret.
let master_xpriv = XPRIV.parse::<Xpriv>().expect("valid xpriv");
- let xpriv_input_1 = get_external_address_xpriv(&secp, master_xpriv, 0);
- let xpriv_input_2 = get_internal_address_xpriv(&secp, master_xpriv, 0);
- let xpriv_change = get_internal_address_xpriv(&secp, master_xpriv, 1);
+ let xpriv_input_1 = get_external_address_xpriv(master_xpriv, 0);
+ let xpriv_input_2 = get_internal_address_xpriv(master_xpriv, 0);
+ let xpriv_change = get_internal_address_xpriv(master_xpriv, 1);
// Get the PKs
- let (pk_input_1, _) = Xpub::from_xpriv(&secp, &xpriv_input_1).public_key.x_only_public_key();
- let (pk_input_2, _) = Xpub::from_xpriv(&secp, &xpriv_input_2).public_key.x_only_public_key();
- let (pk_change, _) = Xpub::from_xpriv(&secp, &xpriv_change).public_key.x_only_public_key();
+ let (pk_input_1, _) = Xpub::from_xpriv(&xpriv_input_1).public_key.x_only_public_key();
+ let (pk_input_2, _) = Xpub::from_xpriv(&xpriv_input_2).public_key.x_only_public_key();
+ let (pk_change, _) = Xpub::from_xpriv(&xpriv_change).public_key.x_only_public_key();
// Get the Tap Key Origins
// Map of tap root X-only keys to origin info and leaf hashes contained in it.
@@ -190,7 +185,7 @@ fn main() {
// The change output is locked to a key controlled by us.
let change = TxOut {
amount: CHANGE_AMOUNT,
- script_pubkey: ScriptPubKeyBuf::new_p2tr(&secp, pk_change, None), // Change comes back to us.
+ script_pubkey: ScriptPubKeyBuf::new_p2tr(pk_change, None), // Change comes back to us.
};
// The transaction we want to sign and broadcast.
@@ -227,7 +222,7 @@ fn main() {
];
// Step 3: Signer role; that signs the PSBT.
- psbt.sign(&master_xpriv, &secp).expect("valid signature");
+ psbt.sign(&master_xpriv).expect("valid signature");
// Step 4: Finalizer role; that finalizes the PSBT.
psbt.inputs.iter_mut().for_each(|input| {
diff --git a/bitcoin/examples/taproot-psbt.rs b/bitcoin/examples/taproot-psbt.rs
index 92ea5355..f10be950 100644
--- a/bitcoin/examples/taproot-psbt.rs
+++ b/bitcoin/examples/taproot-psbt.rs
@@ -83,7 +83,6 @@ use bitcoin::ext::*;
use bitcoin::key::{TapTweak, XOnlyPublicKey};
use bitcoin::opcodes::all::{OP_CHECKSIG, OP_CLTV, OP_DROP};
use bitcoin::psbt::{self, Input, Output, Psbt, PsbtSighashType};
-use bitcoin::secp256k1::Secp256k1;
use bitcoin::sighash::{self, SighashCache, TapSighash, TapSighashType};
use bitcoin::taproot::{self, LeafVersion, TapLeafHash, TaprootBuilder, TaprootSpendInfo};
use bitcoin::{
@@ -92,8 +91,6 @@ use bitcoin::{
};
fn main() -> Result<(), Box<dyn std::error::Error>> {
- let secp = Secp256k1::new();
-
println!("\n----------------");
println!("\nSTART EXAMPLE 1 - P2TR with a BIP-0086 commitment, signed with internal key\n");
@@ -112,7 +109,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
.ok_or("fees more than input amount!")?;
let tx_hex_string = encode::serialize_hex(&generate_bip86_key_spend_tx(
- &secp,
// The master extended private key from the descriptor in step 4
BENEFACTOR_XPRIV_STR.parse::<Xpriv>()?,
// Set these fields with valid data for the UTXO from step 5 above
@@ -218,7 +214,6 @@ struct P2trUtxo<'a> {
#[allow(clippy::single_element_loop)]
fn generate_bip86_key_spend_tx(
- secp: &secp256k1::Secp256k1<secp256k1::All>,
master_xpriv: Xpriv,
input_utxo: P2trUtxo,
outputs: Vec<TxOut>,
@@ -297,7 +292,7 @@ fn generate_bip86_key_spend_tx(
.ok_or("missing Taproot key origin")?;
let secret_key =
- master_xpriv.derive_xpriv(secp, derivation_path)?.to_private_key().inner;
+ master_xpriv.derive_xpriv(derivation_path)?.to_private_key().inner;
sign_psbt_taproot(
secret_key,
input.tap_internal_key.unwrap(),
@@ -305,7 +300,6 @@ fn generate_bip86_key_spend_tx(
input,
hash,
sighash_type,
- secp,
);
Ok(())
@@ -347,7 +341,6 @@ struct BenefactorWallet {
beneficiary_xpub: Xpub,
current_spend_info: Option<TaprootSpendInfo>,
next_psbt: Option<Psbt>,
- secp: Secp256k1<secp256k1::All>,
next: ChildNumber,
}
@@ -361,7 +354,6 @@ impl BenefactorWallet {
beneficiary_xpub,
current_spend_info: None,
next_psbt: None,
- secp: Secp256k1::new(),
next: ChildNumber::ZERO_NORMAL,
})
}
@@ -396,11 +388,11 @@ impl BenefactorWallet {
let derivation_path = format!("101/1/0/0/{}", self.next).parse::<DerivationPath>()?;
let internal_keypair = self
.master_xpriv
- .derive_xpriv(&self.secp, &derivation_path)
+ .derive_xpriv(&derivation_path)
.expect("derivation path is short")
- .to_keypair(&self.secp);
+ .to_keypair();
let beneficiary_key =
- self.beneficiary_xpub.derive_xpub(&self.secp, &derivation_path)?.to_x_only_public_key();
+ self.beneficiary_xpub.derive_xpub(&derivation_path)?.to_x_only_public_key();
// Build up the leaf script and combine with internal key into a Taproot commitment
let script = Self::time_lock_script(lock_time, beneficiary_key);
@@ -408,11 +400,10 @@ impl BenefactorWallet {
let taproot_spend_info = TaprootBuilder::new()
.add_leaf(0, script.clone())?
- .finalize(&self.secp, internal_keypair.x_only_public_key().0)
+ .finalize(internal_keypair.x_only_public_key().0)
.expect("should be finalizable");
self.current_spend_info = Some(taproot_spend_info.clone());
let script_pubkey = ScriptPubKeyBuf::new_p2tr(
- &self.secp,
taproot_spend_info.internal_key(),
taproot_spend_info.merkle_root(),
);
@@ -421,7 +412,6 @@ impl BenefactorWallet {
// Spend a normal BIP-0086-like output as an input in our inheritance funding transaction
let tx = generate_bip86_key_spend_tx(
- &self.secp,
self.master_xpriv,
input_utxo,
vec![TxOut { script_pubkey: script_pubkey.clone(), amount }],
@@ -447,7 +437,7 @@ impl BenefactorWallet {
);
origins.insert(
internal_keypair.x_only_public_key().0.into(),
- (vec![], (self.master_xpriv.fingerprint(&self.secp), derivation_path)),
+ (vec![], (self.master_xpriv.fingerprint(), derivation_path)),
);
let ty = "SIGHASH_ALL".parse::<PsbtSighashType>()?;
let mut tap_scripts = BTreeMap::new();
@@ -489,12 +479,12 @@ impl BenefactorWallet {
format!("101/1/0/0/{}", self.next).parse::<DerivationPath>()?;
let new_internal_keypair = self
.master_xpriv
- .derive_xpriv(&self.secp, &new_derivation_path)
+ .derive_xpriv(&new_derivation_path)
.expect("derivation path is short")
- .to_keypair(&self.secp);
+ .to_keypair();
let beneficiary_key = self
.beneficiary_xpub
- .derive_xpub(&self.secp, &new_derivation_path)?
+ .derive_xpub(&new_derivation_path)?
.to_x_only_public_key();
// Build up the leaf script and combine with internal key into a Taproot commitment
@@ -507,12 +497,11 @@ impl BenefactorWallet {
let taproot_spend_info = TaprootBuilder::new()
.add_leaf(0, script.clone())?
- .finalize(&self.secp, new_internal_keypair.x_only_public_key().0)
+ .finalize(new_internal_keypair.x_only_public_key().0)
.expect("should be finalizable");
self.current_spend_info = Some(taproot_spend_info.clone());
let prevout_script_pubkey = input.witness_utxo.as_ref().unwrap().script_pubkey.clone();
let output_script_pubkey = ScriptPubKeyBuf::new_p2tr(
- &self.secp,
taproot_spend_info.internal_key(),
taproot_spend_info.merkle_root(),
);
@@ -542,7 +531,7 @@ impl BenefactorWallet {
.ok_or("missing Taproot key origin")?;
let secret_key = self
.master_xpriv
- .derive_xpriv(&self.secp, derivation_path)
+ .derive_xpriv(derivation_path)
.expect("derivation path is short")
.to_private_key()
.inner;
@@ -553,7 +542,6 @@ impl BenefactorWallet {
input,
hash,
sighash_type,
- &self.secp,
);
}
@@ -634,15 +622,14 @@ impl BenefactorWallet {
/// after some expiry using CLTV.
struct BeneficiaryWallet {
master_xpriv: Xpriv,
- secp: secp256k1::Secp256k1<secp256k1::All>,
}
impl BeneficiaryWallet {
fn new(master_xpriv: Xpriv) -> Result<Self, Box<dyn std::error::Error>> {
- Ok(Self { master_xpriv, secp: Secp256k1::new() })
+ Ok(Self { master_xpriv })
}
- fn master_xpub(&self) -> Xpub { Xpub::from_xpriv(&self.secp, &self.master_xpriv) }
+ fn master_xpub(&self) -> Xpub { Xpub::from_xpriv(&self.master_xpriv) }
fn spend_inheritance(
&self,
@@ -667,7 +654,7 @@ impl BeneficiaryWallet {
&psbt.inputs[0].tap_key_origins.clone()
{
let secret_key =
- self.master_xpriv.derive_xpriv(&self.secp, derivation_path)?.to_private_key().inner;
+ self.master_xpriv.derive_xpriv(derivation_path)?.to_private_key().inner;
for lh in leaf_hashes {
let sighash_type = TapSighashType::All;
let hash = SighashCache::new(&unsigned_tx).taproot_script_spend_signature_hash(
@@ -686,7 +673,6 @@ impl BeneficiaryWallet {
&mut psbt.inputs[0],
hash,
sighash_type,
- &self.secp,
);
}
}
@@ -746,11 +732,10 @@ fn sign_psbt_taproot(
psbt_input: &mut psbt::Input,
hash: TapSighash,
sighash_type: TapSighashType,
- secp: &Secp256k1<secp256k1::All>,
) {
let keypair = secp256k1::Keypair::from_seckey_byte_array(secret_key.to_secret_bytes()).unwrap();
let keypair = match leaf_hash {
- None => keypair.tap_tweak(secp, psbt_input.tap_merkle_root).to_keypair(),
+ None => keypair.tap_tweak(psbt_input.tap_merkle_root).to_keypair(),
Some(_) => keypair, // no tweak for script spend
};
diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index dff07123..1154c78c 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -10,11 +10,10 @@
//!
//! ```rust
//! #[cfg(feature = "rand-std")] {
-//! use bitcoin::secp256k1::{rand, Secp256k1};
+//! use bitcoin::secp256k1::rand;
//! use bitcoin::{Address, Network, PublicKey};
//!
//! // Generate random key pair.
-//! let secp = Secp256k1::new();
//! let (_sk, pk) = secp256k1::generate_keypair(&mut rand::rng());
//! let public_key = PublicKey::new(pk); // Or `PublicKey::from(pk)`.
//!
@@ -49,7 +48,6 @@ use bech32::primitives::gf32::Fe32;
use bech32::primitives::hrp::Hrp;
use hashes::{hash160, HashEngine};
use internals::array::ArrayExt;
-use secp256k1::{Secp256k1, Verification};
use crate::constants::{
PUBKEY_ADDRESS_PREFIX_MAIN, PUBKEY_ADDRESS_PREFIX_TEST, SCRIPT_ADDRESS_PREFIX_MAIN,
@@ -576,14 +574,13 @@ impl Address {
}
/// Constructs a new pay-to-Taproot (P2TR) [`Address`] from an untweaked key.
- pub fn p2tr<C: Verification, K: Into<UntweakedPublicKey>>(
- secp: &Secp256k1<C>,
+ pub fn p2tr<K: Into<UntweakedPublicKey>>(
internal_key: K,
merkle_root: Option<TapNodeHash>,
hrp: impl Into<KnownHrp>,
) -> Self {
let internal_key = internal_key.into();
- let program = WitnessProgram::p2tr(secp, internal_key, merkle_root);
+ let program = WitnessProgram::p2tr(internal_key, merkle_root);
Self::from_witness_program(program, hrp)
}
@@ -1352,8 +1349,7 @@ mod tests {
let internal_key = "cc8a4bc64d897bddc5fbc2f670f7a8ba0b386779106cf1223c6fc5d7cd6fc115"
.parse::<XOnlyPublicKey>()
.unwrap();
- let secp = Secp256k1::verification_only();
- let address = Address::p2tr(&secp, internal_key, None, KnownHrp::Mainnet);
+ let address = Address::p2tr(internal_key, None, KnownHrp::Mainnet);
assert_eq!(
address.to_string(),
"bc1p5cyxnuxmeuwuvkwfem96lqzszd02n6xdcjrs20cac6yqjjwudpxqkedrcr"
diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index 435c605e..c8ec0d17 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -13,7 +13,6 @@ use core::{fmt, slice};
use hashes::{hash160, hash_newtype, sha512, Hash, HashEngine, Hmac, HmacEngine};
use internals::array::ArrayExt;
use internals::write_err;
-use secp256k1::Secp256k1;
use crate::crypto::key::{CompressedPublicKey, Keypair, PrivateKey, XOnlyPublicKey};
use crate::internal_macros;
@@ -738,13 +737,13 @@ impl Xpriv {
}
/// Constructs a new extended public key from this extended private key.
- pub fn to_xpub<C: secp256k1::Signing>(self, secp: &Secp256k1<C>) -> Xpub {
- Xpub::from_xpriv(secp, &self)
+ pub fn to_xpub(self) -> Xpub {
+ Xpub::from_xpriv(&self)
}
/// Constructs a new BIP-0340 keypair for Schnorr signatures and Taproot use matching the internal
/// secret key representation.
- pub fn to_keypair<C: secp256k1::Signing>(self, secp: &Secp256k1<C>) -> Keypair {
+ pub fn to_keypair(self) -> Keypair {
Keypair::from_seckey_byte_array(self.private_key.to_secret_bytes())
.expect("BIP-0032 internal private key representation is broken")
}
@@ -753,33 +752,30 @@ impl Xpriv {
///
/// The `path` argument can be both of type `DerivationPath` or `Vec<ChildNumber>`.
#[deprecated(since = "TBD", note = "use `derive_xpriv()` instead")]
- pub fn derive_priv<C: secp256k1::Signing, P: AsRef<[ChildNumber]>>(
+ pub fn derive_priv<P: AsRef<[ChildNumber]>>(
&self,
- secp: &Secp256k1<C>,
path: P,
) -> Result<Self, DerivationError> {
- self.derive_xpriv(secp, path)
+ self.derive_xpriv(path)
}
/// Derives an extended private key from a path.
///
/// The `path` argument can be both of type `DerivationPath` or `Vec<ChildNumber>`.
- pub fn derive_xpriv<C: secp256k1::Signing, P: AsRef<[ChildNumber]>>(
+ pub fn derive_xpriv<P: AsRef<[ChildNumber]>>(
&self,
- secp: &Secp256k1<C>,
path: P,
) -> Result<Self, DerivationError> {
let mut sk: Self = *self;
for cnum in path.as_ref() {
- sk = sk.ckd_priv(secp, *cnum)?;
+ sk = sk.ckd_priv(*cnum)?;
}
Ok(sk)
}
/// Private->Private child key derivation
- fn ckd_priv<C: secp256k1::Signing>(
+ fn ckd_priv(
&self,
- secp: &Secp256k1<C>,
i: ChildNumber,
) -> Result<Self, DerivationError> {
let mut engine = HmacEngine::<sha512::HashEngine>::new(&self.chain_code[..]);
@@ -808,7 +804,7 @@ impl Xpriv {
Ok(Self {
network: self.network,
depth: self.depth.checked_add(1).ok_or(DerivationError::MaximumDepthExceeded)?,
- parent_fingerprint: self.fingerprint(secp),
+ parent_fingerprint: self.fingerprint(),
child_number: i,
private_key: tweaked,
chain_code: ChainCode::from_hmac(hmac),
@@ -858,25 +854,25 @@ impl Xpriv {
}
/// Returns the HASH160 of the public key belonging to the xpriv
- pub fn identifier<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> XKeyIdentifier {
- Xpub::from_xpriv(secp, self).identifier()
+ pub fn identifier(&self) -> XKeyIdentifier {
+ Xpub::from_xpriv(self).identifier()
}
/// Returns the first four bytes of the identifier
- pub fn fingerprint<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> Fingerprint {
- self.identifier(secp).as_byte_array().sub_array::<0, 4>().into()
+ pub fn fingerprint(&self) -> Fingerprint {
+ self.identifier().as_byte_array().sub_array::<0, 4>().into()
}
}
impl Xpub {
/// Constructs a new extended public key from an extended private key.
#[deprecated(since = "TBD", note = "use `from_xpriv()` instead")]
- pub fn from_priv<C: secp256k1::Signing>(secp: &Secp256k1<C>, sk: &Xpriv) -> Self {
- Self::from_xpriv(secp, sk)
+ pub fn from_priv(sk: &Xpriv) -> Self {
+ Self::from_xpriv(sk)
}
/// Constructs a new extended public key from an extended private key.
- pub fn from_xpriv<C: secp256k1::Signing>(secp: &Secp256k1<C>, xpriv: &Xpriv) -> Self {
+ pub fn from_xpriv(xpriv: &Xpriv) -> Self {
Self {
network: xpriv.network,
depth: xpriv.depth,
@@ -907,25 +903,23 @@ impl Xpub {
///
/// The `path` argument can be any type implementing `AsRef<ChildNumber>`, such as `DerivationPath`, for instance.
#[deprecated(since = "TBD", note = "use `derive_xpub()` instead")]
- pub fn derive_pub<C: secp256k1::Verification, P: AsRef<[ChildNumber]>>(
+ pub fn derive_pub<P: AsRef<[ChildNumber]>>(
&self,
- secp: &Secp256k1<C>,
path: P,
) -> Result<Self, DerivationError> {
- self.derive_xpub(secp, path)
+ self.derive_xpub(path)
}
/// Attempts to derive an extended public key from a path.
///
/// The `path` argument can be any type implementing `AsRef<ChildNumber>`, such as `DerivationPath`, for instance.
- pub fn derive_xpub<C: secp256k1::Verification, P: AsRef<[ChildNumber]>>(
+ pub fn derive_xpub<P: AsRef<[ChildNumber]>>(
&self,
- secp: &Secp256k1<C>,
path: P,
) -> Result<Self, DerivationError> {
let mut pk: Self = *self;
for cnum in path.as_ref() {
- pk = pk.ckd_pub(secp, *cnum)?
+ pk = pk.ckd_pub(*cnum)?
}
Ok(pk)
}
@@ -954,9 +948,8 @@ impl Xpub {
}
/// Public->Public child key derivation
- pub fn ckd_pub<C: secp256k1::Verification>(
+ pub fn ckd_pub(
&self,
- secp: &Secp256k1<C>,
i: ChildNumber,
) -> Result<Self, DerivationError> {
let (sk, chain_code) = self.ckd_pub_tweak(i)?;
@@ -1298,8 +1291,7 @@ mod tests {
assert_eq!(indexed.child(ChildNumber::from_hardened_idx(2).unwrap()), path);
}
- fn test_path<C: secp256k1::Signing + secp256k1::Verification>(
- secp: &Secp256k1<C>,
+ fn test_path(
network: NetworkKind,
seed: &[u8],
path: DerivationPath,
@@ -1307,37 +1299,37 @@ mod tests {
expected_pk: &str,
) {
let mut sk = Xpriv::new_master(network, seed);
- let mut pk = Xpub::from_xpriv(secp, &sk);
+ let mut pk = Xpub::from_xpriv(&sk);
// Check derivation convenience method for Xpriv
- assert_eq!(&sk.derive_xpriv(secp, &path).unwrap().to_string()[..], expected_sk);
+ assert_eq!(&sk.derive_xpriv(&path).unwrap().to_string()[..], expected_sk);
// Check derivation convenience method for Xpub, should error
// appropriately if any ChildNumber is hardened
if path.0.iter().any(|cnum| cnum.is_hardened()) {
assert_eq!(
- pk.derive_xpub(secp, &path),
+ pk.derive_xpub(&path),
Err(DerivationError::CannotDeriveHardenedChild)
);
} else {
- assert_eq!(&pk.derive_xpub(secp, &path).unwrap().to_string()[..], expected_pk);
+ assert_eq!(&pk.derive_xpub(&path).unwrap().to_string()[..], expected_pk);
}
// Derive keys, checking hardened and non-hardened derivation one-by-one
for &num in path.0.iter() {
- sk = sk.ckd_priv(secp, num).unwrap();
+ sk = sk.ckd_priv(num).unwrap();
match num {
Normal { .. } => {
- let pk2 = pk.ckd_pub(secp, num).unwrap();
- pk = Xpub::from_xpriv(secp, &sk);
+ let pk2 = pk.ckd_pub(num).unwrap();
+ pk = Xpub::from_xpriv(&sk);
assert_eq!(pk, pk2);
}
Hardened { .. } => {
assert_eq!(
- pk.ckd_pub(secp, num),
+ pk.ckd_pub(num),
Err(DerivationError::CannotDeriveHardenedChild)
);
- pk = Xpub::from_xpriv(secp, &sk);
+ pk = Xpub::from_xpriv(&sk);
}
}
}
@@ -1397,88 +1389,86 @@ mod tests {
#[test]
fn vector_1() {
- let secp = Secp256k1::new();
+
let seed = hex!("000102030405060708090a0b0c0d0e0f");
// m
- test_path(&secp, NetworkKind::Main, &seed, "m".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m".parse().unwrap(),
"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
"xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8");
// m/0h
- test_path(&secp, NetworkKind::Main, &seed, "m/0h".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0h".parse().unwrap(),
"xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7",
"xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw");
// m/0h/1
- test_path(&secp, NetworkKind::Main, &seed, "m/0h/1".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0h/1".parse().unwrap(),
"xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs",
"xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ");
// m/0h/1/2h
- test_path(&secp, NetworkKind::Main, &seed, "m/0h/1/2h".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0h/1/2h".parse().unwrap(),
"xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM",
"xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5");
// m/0h/1/2h/2
- test_path(&secp, NetworkKind::Main, &seed, "m/0h/1/2h/2".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0h/1/2h/2".parse().unwrap(),
"xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334",
"xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV");
// m/0h/1/2h/2/1000000000
- test_path(&secp, NetworkKind::Main, &seed, "m/0h/1/2h/2/1000000000".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0h/1/2h/2/1000000000".parse().unwrap(),
"xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76",
"xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy");
}
#[test]
fn vector_2() {
- let secp = Secp256k1::new();
let seed = hex!("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542");
// m
- test_path(&secp, NetworkKind::Main, &seed, "m".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m".parse().unwrap(),
"xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U",
"xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB");
// m/0
- test_path(&secp, NetworkKind::Main, &seed, "m/0".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0".parse().unwrap(),
"xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt",
"xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH");
// m/0/2147483647h
- test_path(&secp, NetworkKind::Main, &seed, "m/0/2147483647h".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0/2147483647h".parse().unwrap(),
"xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9",
"xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a");
// m/0/2147483647h/1
- test_path(&secp, NetworkKind::Main, &seed, "m/0/2147483647h/1".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0/2147483647h/1".parse().unwrap(),
"xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef",
"xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon");
// m/0/2147483647h/1/2147483646h
- test_path(&secp, NetworkKind::Main, &seed, "m/0/2147483647h/1/2147483646h".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0/2147483647h/1/2147483646h".parse().unwrap(),
"xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc",
"xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL");
// m/0/2147483647h/1/2147483646h/2
- test_path(&secp, NetworkKind::Main, &seed, "m/0/2147483647h/1/2147483646h/2".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0/2147483647h/1/2147483646h/2".parse().unwrap(),
"xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j",
"xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt");
}
#[test]
fn vector_3() {
- let secp = Secp256k1::new();
let seed = hex!("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be");
// m
- test_path(&secp, NetworkKind::Main, &seed, "m".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m".parse().unwrap(),
"xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6",
"xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhRoP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13");
// m/0h
- test_path(&secp, NetworkKind::Main, &seed, "m/0h".parse().unwrap(),
+ test_path(NetworkKind::Main, &seed, "m/0h".parse().unwrap(),
"xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L",
"xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y");
}
diff --git a/bitcoin/src/blockdata/script/borrowed.rs b/bitcoin/src/blockdata/script/borrowed.rs
index c6eae74a..79cbf3c4 100644
--- a/bitcoin/src/blockdata/script/borrowed.rs
+++ b/bitcoin/src/blockdata/script/borrowed.rs
@@ -5,7 +5,6 @@ use core::fmt;
use hex::DisplayHex as _;
use internals::array::ArrayExt; // For `split_first`.
use internals::ToU64 as _;
-use secp256k1::{Secp256k1, Verification};
use super::witness_version::WitnessVersion;
use super::{
@@ -280,15 +279,14 @@ crate::internal_macros::define_extension_trait! {
/// Computes P2TR output with a given internal key and a single script spending path equal to
/// the current script, assuming that the script is a Tapscript.
- fn to_p2tr<C: Verification, K: Into<UntweakedPublicKey>>(
+ fn to_p2tr<K: Into<UntweakedPublicKey>>(
&self,
- secp: &Secp256k1<C>,
internal_key: K,
) -> ScriptPubKeyBuf {
let internal_key = internal_key.into();
let leaf_hash = self.tapscript_leaf_hash();
let merkle_root = TapNodeHash::from(leaf_hash);
- ScriptPubKeyBuf::new_p2tr(secp, internal_key, Some(merkle_root))
+ ScriptPubKeyBuf::new_p2tr(internal_key, Some(merkle_root))
}
}
}
diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index 1f4a67df..9cbd0f7b 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -5,7 +5,6 @@ use core::ops::Deref;
use hex::FromHex as _;
use internals::ToU64 as _;
-use secp256k1::{Secp256k1, Verification};
use super::{
opcode_to_verify, write_scriptint, Builder, Error, Instruction, PushBytes, ScriptBuf,
@@ -216,13 +215,12 @@ crate::internal_macros::define_extension_trait! {
/// Generates P2TR for script spending path using an internal public key and some optional
/// script tree Merkle root.
- fn new_p2tr<C: Verification, K: Into<UntweakedPublicKey>>(
- secp: &Secp256k1<C>,
+ fn new_p2tr<K: Into<UntweakedPublicKey>>(
internal_key: K,
merkle_root: Option<TapNodeHash>,
) -> Self {
let internal_key = internal_key.into();
- let (output_key, _) = internal_key.tap_tweak(secp, merkle_root);
+ let (output_key, _) = internal_key.tap_tweak(merkle_root);
// output key is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv1)
script::new_witness_program_unchecked(WitnessVersion::V1, output_key.serialize())
}
diff --git a/bitcoin/src/blockdata/script/witness_program.rs b/bitcoin/src/blockdata/script/witness_program.rs
index 3af8b5c5..d6ac0319 100644
--- a/bitcoin/src/blockdata/script/witness_program.rs
+++ b/bitcoin/src/blockdata/script/witness_program.rs
@@ -11,7 +11,6 @@ use core::convert::Infallible;
use core::fmt;
use internals::array_vec::ArrayVec;
-use secp256k1::{Secp256k1, Verification};
use super::witness_version::WitnessVersion;
use super::{PushBytes, WScriptHash, WitnessScript, WitnessScriptSizeError};
@@ -95,13 +94,12 @@ impl WitnessProgram {
///
/// This function applies BIP-0341 key-tweaking to the untweaked
/// key using the merkle root, if it's present.
- pub fn p2tr<C: Verification, K: Into<UntweakedPublicKey>>(
- secp: &Secp256k1<C>,
+ pub fn p2tr<K: Into<UntweakedPublicKey>>(
internal_key: K,
merkle_root: Option<TapNodeHash>,
) -> Self {
let internal_key = internal_key.into();
- let (output_key, _parity) = internal_key.tap_tweak(secp, merkle_root);
+ let (output_key, _parity) = internal_key.tap_tweak(merkle_root);
let pubkey = output_key.as_x_only_public_key().serialize();
Self::new_p2tr(pubkey)
}
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 0a78dc69..e0ce609c 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -25,7 +25,7 @@ use crate::script::{self, WitnessScriptBuf};
use crate::taproot::{TapNodeHash, TapTweakHash};
#[rustfmt::skip] // Keep public re-exports separate.
-pub use secp256k1::{constants, Keypair, Parity, Secp256k1, Verification};
+pub use secp256k1::{constants, Keypair, Parity, Verification};
#[cfg(feature = "rand-std")]
pub use secp256k1::rand;
pub use serialized_x_only::SerializedXOnlyPublicKey;
@@ -77,9 +77,8 @@ impl XOnlyPublicKey {
/// Should be called on the original untweaked key. Takes the tweaked key and output parity from
/// [`XOnlyPublicKey::add_tweak`] as input.
#[inline]
- pub fn tweak_add_check<V: Verification>(
+ pub fn tweak_add_check(
&self,
- secp: &Secp256k1<V>,
tweaked_key: &Self,
tweaked_parity: Parity,
tweak: secp256k1::Scalar,
@@ -99,9 +98,8 @@ impl XOnlyPublicKey {
///
/// If the resulting key would be invalid.
#[inline]
- pub fn add_tweak<V: Verification>(
+ pub fn add_tweak(
&self,
- secp: &Secp256k1<V>,
tweak: &secp256k1::Scalar,
) -> Result<(Self, Parity), TweakXOnlyPublicKeyError> {
match self.0.add_tweak(tweak) {
@@ -314,14 +312,15 @@ impl PublicKey {
}
/// Computes the public key as supposed to be used with this secret.
- pub fn from_private_key<C: secp256k1::Signing>(secp: &Secp256k1<C>, sk: PrivateKey) -> Self {
- sk.public_key(secp)
+ pub fn from_private_key(
+ sk: PrivateKey,
+ ) -> Self {
+ sk.public_key()
}
/// Checks that `sig` is a valid ECDSA signature for `msg` using this public key.
- pub fn verify<C: secp256k1::Verification>(
+ pub fn verify(
&self,
- secp: &Secp256k1<C>,
msg: secp256k1::Message,
sig: ecdsa::Signature,
) -> Result<(), secp256k1::Error> {
@@ -453,17 +452,15 @@ impl CompressedPublicKey {
}
/// Computes the public key as supposed to be used with this secret.
- pub fn from_private_key<C: secp256k1::Signing>(
- secp: &Secp256k1<C>,
+ pub fn from_private_key(
sk: PrivateKey,
) -> Result<Self, UncompressedPublicKeyError> {
- sk.public_key(secp).try_into()
+ sk.public_key().try_into()
}
/// Checks that `sig` is a valid ECDSA signature for `msg` using this public key.
- pub fn verify<C: secp256k1::Verification>(
+ pub fn verify(
&self,
- secp: &Secp256k1<C>,
msg: secp256k1::Message,
sig: ecdsa::Signature,
) -> Result<(), secp256k1::Error> {
@@ -559,7 +556,7 @@ impl PrivateKey {
}
/// Constructs a new public key from this private key.
- pub fn public_key<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> PublicKey {
+ pub fn public_key(&self) -> PublicKey {
PublicKey {
compressed: self.compressed,
inner: secp256k1::PublicKey::from_secret_key(&self.inner),
@@ -871,8 +868,7 @@ pub type UntweakedKeypair = Keypair;
/// ```
/// # #[cfg(feature = "rand-std")] {
/// # use bitcoin::key::{Keypair, TweakedKeypair, TweakedPublicKey};
-/// # use bitcoin::secp256k1::{rand, Secp256k1};
-/// # let secp = Secp256k1::new();
+/// # use bitcoin::secp256k1::rand;
/// # let keypair = TweakedKeypair::dangerous_assume_tweaked(Keypair::new(&mut rand::rng()));
/// // There are various conversion methods available to get a tweaked pubkey from a tweaked keypair.
/// let (_pk, _parity) = keypair.public_parts();
@@ -905,9 +901,8 @@ pub trait TapTweak {
/// # Returns
///
/// The tweaked key and its parity.
- fn tap_tweak<C: Verification>(
+ fn tap_tweak(
self,
- secp: &Secp256k1<C>,
merkle_root: Option<TapNodeHash>,
) -> Self::TweakedAux;
@@ -935,15 +930,14 @@ impl TapTweak for UntweakedPublicKey {
/// # Returns
///
/// The tweaked key and its parity.
- fn tap_tweak<C: Verification>(
+ fn tap_tweak(
self,
- secp: &Secp256k1<C>,
merkle_root: Option<TapNodeHash>,
) -> (TweakedPublicKey, Parity) {
let tweak = TapTweakHash::from_key_and_merkle_root(self, merkle_root).to_scalar();
- let (output_key, parity) = self.add_tweak(secp, &tweak).expect("Tap tweak failed");
+ let (output_key, parity) = self.add_tweak(&tweak).expect("Tap tweak failed");
- debug_assert!(self.tweak_add_check(secp, &output_key, parity, tweak));
+ debug_assert!(self.tweak_add_check(&output_key, parity, tweak));
(TweakedPublicKey(output_key), parity)
}
@@ -964,9 +958,8 @@ impl TapTweak for UntweakedKeypair {
/// # Returns
///
/// The tweaked keypair.
- fn tap_tweak<C: Verification>(
+ fn tap_tweak(
self,
- secp: &Secp256k1<C>,
merkle_root: Option<TapNodeHash>,
) -> TweakedKeypair {
let (pubkey, _parity) = XOnlyPublicKey::from_keypair(&self);
@@ -1452,8 +1445,7 @@ mod tests {
assert!(sk.compressed);
assert_eq!(&sk.to_wif(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy");
- let secp = Secp256k1::new();
- let pk = Address::p2pkh(sk.public_key(&secp), sk.network);
+ let pk = Address::p2pkh(sk.public_key(), sk.network);
assert_eq!(&pk.to_string(), "mqwpxxvfv3QbM8PU8uBx2jaNt9btQqvQNx");
// test string conversion
@@ -1469,8 +1461,7 @@ mod tests {
assert!(!sk.compressed);
assert_eq!(&sk.to_wif(), "5JYkZjmN7PVMjJUfJWfRFwtuXTGB439XV6faajeHPAM9Z2PT2R3");
- let secp = Secp256k1::new();
- let mut pk = sk.public_key(&secp);
+ let mut pk = sk.public_key();
assert!(!pk.compressed);
assert_eq!(&pk.to_string(), "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133");
assert_eq!(pk, "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133"
@@ -1547,9 +1538,8 @@ mod tests {
0xe9, 0x71, 0xd8, 0x6b, 0x5e, 0x61, 0x87, 0x5d,
];
- let s = Secp256k1::new();
let sk = KEY_WIF.parse::<PrivateKey>().unwrap();
- let pk = PublicKey::from_private_key(&s, sk);
+ let pk = PublicKey::from_private_key(sk);
let pk_u = PublicKey { inner: pk.inner, compressed: false };
assert_tokens(&sk, &[Token::BorrowedStr(KEY_WIF)]);
@@ -1744,7 +1734,6 @@ mod tests {
fn public_key_constructors() {
use secp256k1::rand;
- let secp = Secp256k1::new();
let kp = Keypair::new(&mut rand::rng());
let _ = PublicKey::new(kp);
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index b28f147c..a966a4e7 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1974,7 +1974,6 @@ mod tests {
serde_json::from_str::<TestData>(json_str).expect("JSON was not well-formatted");
assert_eq!(data.version, 1u64);
- let secp = &secp256k1::Secp256k1::new();
let key_path = data.key_path_spending.remove(0);
let raw_unsigned_tx = key_path.given.raw_unsigned_tx;
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index b9caa8b1..faf9f35b 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -19,7 +19,7 @@ use core::{cmp, fmt};
use std::collections::{HashMap, HashSet};
use internals::write_err;
-use secp256k1::{Keypair, Message, Secp256k1, Signing, Verification};
+use secp256k1::{Keypair, Message};
use crate::bip32::{self, KeySource, Xpriv, Xpub};
use crate::crypto::key::{PrivateKey, PublicKey};
@@ -290,13 +290,11 @@ impl Psbt {
///
/// If an error is returned some signatures may already have been added to the PSBT. Since
/// `partial_sigs` is a [`BTreeMap`] it is safe to retry, previous sigs will be overwritten.
- pub fn sign<C, K>(
+ pub fn sign<K>(
&mut self,
k: &K,
- secp: &Secp256k1<C>,
) -> Result<SigningKeysMap, (SigningKeysMap, SigningErrors)>
where
- C: Signing + Verification,
K: GetKey,
{
let tx = self.unsigned_tx.clone(); // clone because we need to mutably borrow when signing.
@@ -308,7 +306,7 @@ impl Psbt {
for i in 0..self.inputs.len() {
match self.signing_algorithm(i) {
Ok(SigningAlgorithm::Ecdsa) =>
- match self.bip32_sign_ecdsa(k, i, &mut cache, secp) {
+ match self.bip32_sign_ecdsa(k, i, &mut cache) {
Ok(v) => {
used.insert(i, SigningKeys::Ecdsa(v));
}
@@ -317,7 +315,7 @@ impl Psbt {
}
},
Ok(SigningAlgorithm::Schnorr) => {
- match self.bip32_sign_schnorr(k, i, &mut cache, secp) {
+ match self.bip32_sign_schnorr(k, i, &mut cache) {
Ok(v) => {
used.insert(i, SigningKeys::Schnorr(v));
}
@@ -345,15 +343,13 @@ impl Psbt {
///
/// - Ok: A list of the public keys used in signing.
/// - Err: Error encountered trying to calculate the sighash AND we had the signing key.
- fn bip32_sign_ecdsa<C, K, T>(
+ fn bip32_sign_ecdsa<K, T>(
&mut self,
k: &K,
input_index: usize,
cache: &mut SighashCache<T>,
- secp: &Secp256k1<C>,
) -> Result<Vec<PublicKey>, SignError>
where
- C: Signing,
T: Borrow<Transaction>,
K: GetKey,
{
@@ -364,9 +360,9 @@ impl Psbt {
let mut used = vec![]; // List of pubkeys used to sign the input.
for (pk, key_source) in input.bip32_derivation.iter() {
- let sk = if let Ok(Some(sk)) = k.get_key(&KeyRequest::Bip32(key_source.clone()), secp) {
+ let sk = if let Ok(Some(sk)) = k.get_key(&KeyRequest::Bip32(key_source.clone())) {
sk
- } else if let Ok(Some(sk)) = k.get_key(&KeyRequest::Pubkey(PublicKey::new(*pk)), secp) {
+ } else if let Ok(Some(sk)) = k.get_key(&KeyRequest::Pubkey(PublicKey::new(*pk))) {
sk
} else {
continue;
@@ -383,7 +379,7 @@ impl Psbt {
sighash_type: sighash_ty,
};
- let pk = sk.public_key(secp);
+ let pk = sk.public_key();
input.partial_sigs.insert(pk, sig);
used.push(pk);
@@ -400,15 +396,13 @@ impl Psbt {
/// - Ok: A list of the xonly public keys used in signing. When signing a key path spend we
/// return the internal key.
/// - Err: Error encountered trying to calculate the sighash AND we had the signing key.
- fn bip32_sign_schnorr<C, K, T>(
+ fn bip32_sign_schnorr<K, T>(
&mut self,
k: &K,
input_index: usize,
cache: &mut SighashCache<T>,
- secp: &Secp256k1<C>,
) -> Result<Vec<XOnlyPublicKey>, SignError>
where
- C: Signing + Verification,
T: Borrow<Transaction>,
K: GetKey,
{
@@ -418,10 +412,10 @@ impl Psbt {
for (&xonly, (leaf_hashes, key_source)) in input.tap_key_origins.iter() {
let sk = if let Ok(Some(secret_key)) =
- k.get_key(&KeyRequest::Bip32(key_source.clone()), secp)
+ k.get_key(&KeyRequest::Bip32(key_source.clone()))
{
secret_key
- } else if let Ok(Some(sk)) = k.get_key(&KeyRequest::XOnlyPubkey(xonly), secp) {
+ } else if let Ok(Some(sk)) = k.get_key(&KeyRequest::XOnlyPubkey(xonly)) {
sk
} else {
continue;
@@ -441,7 +435,7 @@ impl Psbt {
if internal_key == xonly && leaf_hashes.is_empty() && input.tap_key_sig.is_none() {
let (sighash, sighash_type) = self.sighash_taproot(input_index, cache, None)?;
let key_pair = Keypair::from_secret_key(&sk.inner)
- .tap_tweak(secp, input.tap_merkle_root)
+ .tap_tweak(input.tap_merkle_root)
.to_keypair();
#[cfg(feature = "rand-std")]
@@ -482,7 +476,7 @@ impl Psbt {
input.tap_script_sigs.insert((xonly, lh), signature);
}
- used.push(sk.public_key(secp).into());
+ used.push(sk.public_key().into());
}
}
}
@@ -801,33 +795,31 @@ pub trait GetKey {
/// - `Some(key)` if the key is found.
/// - `None` if the key was not found but no error was encountered.
/// - `Err` if an error was encountered while looking for the key.
- fn get_key<C: Signing>(
+ fn get_key(
&self,
key_request: &KeyRequest,
- secp: &Secp256k1<C>,
) -> Result<Option<PrivateKey>, Self::Error>;
}
impl GetKey for Xpriv {
type Error = GetKeyError;
- fn get_key<C: Signing>(
+ fn get_key(
&self,
key_request: &KeyRequest,
- secp: &Secp256k1<C>,
) -> Result<Option<PrivateKey>, Self::Error> {
match key_request {
KeyRequest::Pubkey(_) => Err(GetKeyError::NotSupported),
KeyRequest::XOnlyPubkey(_) => Err(GetKeyError::NotSupported),
KeyRequest::Bip32((fingerprint, path)) => {
- let key = if self.fingerprint(secp) == *fingerprint {
- let k = self.derive_xpriv(secp, path).map_err(GetKeyError::Bip32)?;
+ let key = if self.fingerprint() == *fingerprint {
+ let k = self.derive_xpriv(path).map_err(GetKeyError::Bip32)?;
Some(k.to_private_key())
} else if self.parent_fingerprint == *fingerprint
&& !path.is_empty()
&& path[0] == self.child_number
{
- let k = self.derive_xpriv(secp, &path[1..]).map_err(GetKeyError::Bip32)?;
+ let k = self.derive_xpriv(&path[1..]).map_err(GetKeyError::Bip32)?;
Some(k.to_private_key())
} else {
None
@@ -863,15 +855,14 @@ macro_rules! impl_get_key_for_set {
impl GetKey for $set<Xpriv> {
type Error = GetKeyError;
- fn get_key<C: Signing>(
+ fn get_key(
&self,
key_request: &KeyRequest,
- secp: &Secp256k1<C>
) -> Result<Option<PrivateKey>, Self::Error> {
// OK to stop at the first error because Xpriv::get_key() can only fail
// if this isn't a KeyRequest::Bip32, which would fail for all Xprivs.
self.iter()
- .find_map(|xpriv| xpriv.get_key(key_request, secp).transpose())
+ .find_map(|xpriv| xpriv.get_key(key_request).transpose())
.transpose()
}
}}}
@@ -887,10 +878,9 @@ macro_rules! impl_get_key_for_pubkey_map {
impl GetKey for $map<PublicKey, PrivateKey> {
type Error = GetKeyError;
- fn get_key<C: Signing>(
+ fn get_key(
&self,
key_request: &KeyRequest,
- _: &Secp256k1<C>,
) -> Result<Option<PrivateKey>, Self::Error> {
match key_request {
KeyRequest::Pubkey(pk) => Ok(self.get(&pk).cloned()),
@@ -925,10 +915,9 @@ macro_rules! impl_get_key_for_xonly_map {
impl GetKey for $map<XOnlyPublicKey, PrivateKey> {
type Error = GetKeyError;
- fn get_key<C: Signing>(
+ fn get_key(
&self,
key_request: &KeyRequest,
- secp: &Secp256k1<C>,
) -> Result<Option<PrivateKey>, Self::Error> {
match key_request {
KeyRequest::XOnlyPubkey(xonly) => Ok(self.get(xonly).cloned()),
@@ -936,7 +925,7 @@ impl GetKey for $map<XOnlyPublicKey, PrivateKey> {
let (xonly, parity) = pk.inner.x_only_public_key();
if let Some(mut priv_key) = self.get(&XOnlyPublicKey::from(xonly)).cloned() {
- let computed_pk = priv_key.public_key(&secp);
+ let computed_pk = priv_key.public_key();
let (_, computed_parity) = computed_pk.inner.x_only_public_key();
if computed_parity != parity {
@@ -1340,7 +1329,7 @@ mod tests {
crate::script::ScriptPubKeyBufExt as _,
crate::witness_version::WitnessVersion,
crate::WitnessProgram,
- secp256k1::{All, SecretKey},
+ secp256k1::SecretKey,
};
use super::*;
@@ -1492,14 +1481,13 @@ mod tests {
#[test]
fn serialize_then_deserialize_output() {
- let secp = &Secp256k1::new();
let seed = hex!("000102030405060708090a0b0c0d0e0f");
let mut hd_keypaths: BTreeMap<secp256k1::PublicKey, KeySource> = Default::default();
let mut sk: Xpriv = Xpriv::new_master(NetworkKind::Main, &seed);
- let fprint = sk.fingerprint(secp);
+ let fprint = sk.fingerprint();
let dpath: Vec<ChildNumber> = vec![
ChildNumber::ZERO_NORMAL,
@@ -1512,9 +1500,9 @@ mod tests {
ChildNumber::from_normal_idx(31337).unwrap(),
];
- sk = sk.derive_xpriv(secp, &dpath).unwrap();
+ sk = sk.derive_xpriv(&dpath).unwrap();
- let pk = Xpub::from_xpriv(secp, &sk);
+ let pk = Xpub::from_xpriv(&sk);
hd_keypaths.insert(pk.public_key, (fprint, dpath.into()));
@@ -2368,27 +2356,25 @@ mod tests {
}
#[cfg(feature = "rand-std")]
- fn gen_keys() -> (PrivateKey, PublicKey, Secp256k1<All>) {
+ fn gen_keys() -> (PrivateKey, PublicKey) {
use secp256k1::rand;
- let secp = Secp256k1::new();
-
let sk = SecretKey::new(&mut rand::rng());
let priv_key = PrivateKey::new(sk, NetworkKind::Test);
- let pk = PublicKey::from_private_key(&secp, priv_key);
+ let pk = PublicKey::from_private_key(priv_key);
- (priv_key, pk, secp)
+ (priv_key, pk)
}
#[test]
#[cfg(feature = "rand-std")]
fn get_key_btree_map() {
- let (priv_key, pk, secp) = gen_keys();
+ let (priv_key, pk) = gen_keys();
let mut key_map = BTreeMap::new();
key_map.insert(pk, priv_key);
- let got = key_map.get_key(&KeyRequest::Pubkey(pk), &secp).expect("failed to get key");
+ let got = key_map.get_key(&KeyRequest::Pubkey(pk)).expect("failed to get key");
assert_eq!(got.unwrap(), priv_key)
}
@@ -2397,7 +2383,7 @@ mod tests {
fn pubkey_map_get_key_negates_odd_parity_keys() {
use crate::psbt::{GetKey, KeyRequest};
- let (mut priv_key, mut pk, secp) = gen_keys();
+ let (mut priv_key, mut pk) = gen_keys();
let (xonly, parity) = pk.inner.x_only_public_key();
let mut pubkey_map: HashMap<PublicKey, PrivateKey> = HashMap::new();
@@ -2408,16 +2394,16 @@ mod tests {
network: priv_key.network,
inner: priv_key.inner.negate(),
};
- pk = priv_key.public_key(&secp);
+ pk = priv_key.public_key();
}
pubkey_map.insert(pk, priv_key);
- let req_result = pubkey_map.get_key(&KeyRequest::XOnlyPubkey(xonly.into()), &secp).unwrap();
+ let req_result = pubkey_map.get_key(&KeyRequest::XOnlyPubkey(xonly.into())).unwrap();
let retrieved_key = req_result.unwrap();
- let retrieved_pub_key = retrieved_key.public_key(&secp);
+ let retrieved_pub_key = retrieved_key.public_key();
let (retrieved_xonly, retrieved_parity) = retrieved_pub_key.inner.x_only_public_key();
assert_eq!(xonly, retrieved_xonly);
@@ -2430,20 +2416,18 @@ mod tests {
#[test]
fn get_key_xpriv_bip32_parent() {
- let secp = Secp256k1::new();
-
let seed = hex!("000102030405060708090a0b0c0d0e0f");
let parent_xpriv: Xpriv = Xpriv::new_master(NetworkKind::Main, &seed);
let path: DerivationPath = "m/1/2/3".parse().unwrap();
let path_prefix: DerivationPath = "m/1".parse().unwrap();
let expected_private_key =
- parent_xpriv.derive_xpriv(&secp, &path).unwrap().to_private_key();
+ parent_xpriv.derive_xpriv(&path).unwrap().to_private_key();
- let derived_xpriv = parent_xpriv.derive_xpriv(&secp, &path_prefix).unwrap();
+ let derived_xpriv = parent_xpriv.derive_xpriv(&path_prefix).unwrap();
let derived_key = derived_xpriv
- .get_key(&KeyRequest::Bip32((parent_xpriv.fingerprint(&secp), path)), &secp)
+ .get_key(&KeyRequest::Bip32((parent_xpriv.fingerprint(), path)))
.unwrap();
assert_eq!(derived_key, Some(expected_private_key));
@@ -2554,7 +2538,7 @@ mod tests {
#[test]
#[cfg(feature = "rand-std")]
fn hashmap_can_sign_taproot() {
- let (priv_key, pk, secp) = gen_keys();
+ let (priv_key, pk) = gen_keys();
let internal_key: XOnlyPublicKey = pk.inner.into();
let tx = Transaction {
@@ -2568,7 +2552,7 @@ mod tests {
psbt.inputs[0].tap_internal_key = Some(internal_key);
psbt.inputs[0].witness_utxo = Some(transaction::TxOut {
amount: Amount::from_sat_u32(10),
- script_pubkey: ScriptPubKeyBuf::new_p2tr(&secp, internal_key, None),
+ script_pubkey: ScriptPubKeyBuf::new_p2tr(internal_key, None),
});
let mut key_map: HashMap<PublicKey, PrivateKey> = HashMap::new();
@@ -2579,7 +2563,7 @@ mod tests {
tap_key_origins.insert(internal_key, (vec![], key_source));
psbt.inputs[0].tap_key_origins = tap_key_origins;
- let signing_keys = psbt.sign(&key_map, &secp).unwrap();
+ let signing_keys = psbt.sign(&key_map).unwrap();
assert_eq!(signing_keys.len(), 1);
assert_eq!(signing_keys[&0], SigningKeys::Schnorr(vec![internal_key]));
}
@@ -2587,7 +2571,7 @@ mod tests {
#[test]
#[cfg(feature = "rand-std")]
fn xonly_hashmap_can_sign_taproot() {
- let (priv_key, pk, secp) = gen_keys();
+ let (priv_key, pk) = gen_keys();
let internal_key: XOnlyPublicKey = pk.inner.into();
let tx = Transaction {
@@ -2601,7 +2585,7 @@ mod tests {
psbt.inputs[0].tap_internal_key = Some(internal_key);
psbt.inputs[0].witness_utxo = Some(transaction::TxOut {
amount: Amount::from_sat_u32(10),
- script_pubkey: ScriptPubKeyBuf::new_p2tr(&secp, internal_key, None),
+ script_pubkey: ScriptPubKeyBuf::new_p2tr(internal_key, None),
});
let mut xonly_key_map: HashMap<XOnlyPublicKey, PrivateKey> = HashMap::new();
@@ -2612,7 +2596,7 @@ mod tests {
tap_key_origins.insert(internal_key, (vec![], key_source));
psbt.inputs[0].tap_key_origins = tap_key_origins;
- let signing_keys = psbt.sign(&xonly_key_map, &secp).unwrap();
+ let signing_keys = psbt.sign(&xonly_key_map).unwrap();
assert_eq!(signing_keys.len(), 1);
assert_eq!(signing_keys[&0], SigningKeys::Schnorr(vec![internal_key]));
}
@@ -2629,7 +2613,7 @@ mod tests {
};
let mut psbt = Psbt::from_unsigned_tx(unsigned_tx).unwrap();
- let (priv_key, pk, secp) = gen_keys();
+ let (priv_key, pk) = gen_keys();
// key_map implements `GetKey` using KeyRequest::Pubkey. A pubkey key request does not use
// keysource so we use default `KeySource` (fingerprint and derivation path) below.
@@ -2655,7 +2639,7 @@ mod tests {
};
psbt.inputs[1].witness_utxo = Some(txout_unknown_future);
- let (signing_keys, _) = psbt.sign(&key_map, &secp).unwrap_err();
+ let (signing_keys, _) = psbt.sign(&key_map).unwrap_err();
assert_eq!(signing_keys.len(), 1);
assert_eq!(signing_keys[&0], SigningKeys::Ecdsa(vec![pk]));
diff --git a/bitcoin/src/sign_message.rs b/bitcoin/src/sign_message.rs
index 660c878f..853ea565 100644
--- a/bitcoin/src/sign_message.rs
+++ b/bitcoin/src/sign_message.rs
@@ -133,9 +133,8 @@ mod message_signing {
/// Attempt to recover a public key from the signature and the signed message.
///
/// To get the message hash from a message, use [super::signed_msg_hash].
- pub fn recover_pubkey<C: secp256k1::Verification>(
+ pub fn recover_pubkey(
&self,
- secp_ctx: &secp256k1::Secp256k1<C>,
msg_hash: sha256d::Hash,
) -> Result<PublicKey, MessageSignatureError> {
let msg = secp256k1::Message::from_digest(msg_hash.to_byte_array());
@@ -146,15 +145,14 @@ mod message_signing {
/// Verifies that the signature signs the message and was signed by the given address.
///
/// To get the message hash from a message, use [super::signed_msg_hash].
- pub fn is_signed_by_address<C: secp256k1::Verification>(
+ pub fn is_signed_by_address(
&self,
- secp_ctx: &secp256k1::Secp256k1<C>,
address: &Address,
msg_hash: sha256d::Hash,
) -> Result<bool, MessageSignatureError> {
match address.address_type() {
Some(AddressType::P2pkh) => {
- let pubkey = self.recover_pubkey(secp_ctx, msg_hash)?;
+ let pubkey = self.recover_pubkey(msg_hash)?;
Ok(address.pubkey_hash() == Some(pubkey.pubkey_hash()))
}
Some(address_type) =>
@@ -217,8 +215,7 @@ pub fn signed_msg_hash(msg: impl AsRef<[u8]>) -> sha256d::Hash {
/// Sign message using Bitcoin's message signing format.
#[cfg(feature = "secp-recovery")]
-pub fn sign<C: secp256k1::Signing>(
- secp_ctx: &secp256k1::Secp256k1<C>,
+pub fn sign(
msg: impl AsRef<[u8]>,
privkey: SecretKey,
) -> MessageSignature {
@@ -249,7 +246,6 @@ mod tests {
use secp256k1::ecdsa::RecoverableSignature;
use crate::{Address, AddressType, Network, NetworkKind};
- let secp = secp256k1::Secp256k1::new();
let message = "rust-bitcoin MessageSignature test";
let msg_hash = super::signed_msg_hash(message);
let msg = secp256k1::Message::from_digest(msg_hash.to_byte_array());
@@ -257,29 +253,29 @@ mod tests {
let secp_sig = RecoverableSignature::sign_ecdsa_recoverable(msg, &privkey);
let signature = super::MessageSignature { signature: secp_sig, compressed: true };
- assert_eq!(signature.to_string(), super::sign(&secp, message, privkey).to_string());
+ assert_eq!(signature.to_string(), super::sign(message, privkey).to_string());
assert_eq!(signature.to_base64(), signature.to_string());
let signature2 = &signature.to_string().parse::<super::MessageSignature>().unwrap();
let pubkey = signature2
- .recover_pubkey(&secp, msg_hash)
+ .recover_pubkey(msg_hash)
.unwrap()
.try_into()
.expect("compressed was set to true");
let p2pkh = Address::p2pkh(pubkey, NetworkKind::Main);
- assert_eq!(signature2.is_signed_by_address(&secp, &p2pkh, msg_hash), Ok(true));
+ assert_eq!(signature2.is_signed_by_address(&p2pkh, msg_hash), Ok(true));
let p2wpkh = Address::p2wpkh(pubkey, Network::Bitcoin);
assert_eq!(
- signature2.is_signed_by_address(&secp, &p2wpkh, msg_hash),
+ signature2.is_signed_by_address(&p2wpkh, msg_hash),
Err(MessageSignatureError::UnsupportedAddressType(AddressType::P2wpkh))
);
let p2shwpkh = Address::p2shwpkh(pubkey, NetworkKind::Main);
assert_eq!(
- signature2.is_signed_by_address(&secp, &p2shwpkh, msg_hash),
+ signature2.is_signed_by_address(&p2shwpkh, msg_hash),
Err(MessageSignatureError::UnsupportedAddressType(AddressType::P2sh))
);
let p2pkh = Address::p2pkh(pubkey, Network::Bitcoin);
- assert_eq!(signature2.is_signed_by_address(&secp, &p2pkh, msg_hash), Ok(true));
+ assert_eq!(signature2.is_signed_by_address(&p2pkh, msg_hash), Ok(true));
assert_eq!(pubkey.0, secp256k1::PublicKey::from_secret_key(&privkey));
let signature_base64 = signature.to_base64();
@@ -292,12 +288,10 @@ mod tests {
#[cfg(all(feature = "secp-recovery", feature = "base64"))]
fn incorrect_message_signature() {
use base64::prelude::{Engine as _, BASE64_STANDARD};
- use secp256k1;
use crate::crypto::key::PublicKey;
use crate::{Address, NetworkKind};
- let secp = secp256k1::Secp256k1::new();
let message = "a different message from what was signed";
let msg_hash = super::signed_msg_hash(message);
@@ -313,6 +307,6 @@ mod tests {
.expect("pubkey slice");
let p2pkh = Address::p2pkh(pubkey, NetworkKind::Main);
- assert_eq!(signature.is_signed_by_address(&secp, &p2pkh, msg_hash), Ok(false));
+ assert_eq!(signature.is_signed_by_address(&p2pkh, msg_hash), Ok(false));
}
}
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 0ed4a512..24bf7fa6 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -19,7 +19,7 @@ use internals::array::ArrayExt;
use internals::slice::SliceExt;
use internals::{impl_to_hex_from_lower_hex, write_err};
use io::Write;
-use secp256k1::{Scalar, Secp256k1};
+use secp256k1::Scalar;
use crate::consensus::Encodable;
use crate::crypto::key::{
@@ -250,18 +250,16 @@ impl TaprootSpendInfo {
/// weights of satisfaction for that script.
///
/// See [`TaprootBuilder::with_huffman_tree`] for more detailed documentation.
- pub fn with_huffman_tree<C, I, K>(
- secp: &Secp256k1<C>,
+ pub fn with_huffman_tree<I, K>(
internal_key: K,
script_weights: I,
) -> Result<Self, TaprootBuilderError>
where
I: IntoIterator<Item = (u32, TapScriptBuf)>,
- C: secp256k1::Verification,
K: Into<UntweakedPublicKey>,
{
let builder = TaprootBuilder::with_huffman_tree(script_weights)?;
- Ok(builder.finalize(secp, internal_key).expect("Huffman tree is always complete"))
+ Ok(builder.finalize(internal_key).expect("Huffman tree is always complete"))
}
/// Constructs a new key spend with `internal_key` and `merkle_root`. Provide [`None`] for
@@ -275,13 +273,12 @@ impl TaprootSpendInfo {
///
/// Refer to BIP 341 footnote ('Why should the output key always have a Taproot commitment, even
/// if there is no script path?') for more details.
- pub fn new_key_spend<C: secp256k1::Verification, K: Into<UntweakedPublicKey>>(
- secp: &Secp256k1<C>,
+ pub fn new_key_spend<K: Into<UntweakedPublicKey>>(
internal_key: K,
merkle_root: Option<TapNodeHash>,
) -> Self {
let internal_key = internal_key.into();
- let (output_key, parity) = internal_key.tap_tweak(secp, merkle_root);
+ let (output_key, parity) = internal_key.tap_tweak(merkle_root);
Self {
internal_key,
merkle_root,
@@ -316,14 +313,13 @@ impl TaprootSpendInfo {
///
/// This is useful when you want to manually build a Taproot tree without using
/// [`TaprootBuilder`].
- pub fn from_node_info<C: secp256k1::Verification, K: Into<UntweakedPublicKey>>(
- secp: &Secp256k1<C>,
+ pub fn from_node_info<K: Into<UntweakedPublicKey>>(
internal_key: K,
node: NodeInfo,
) -> Self {
// Create as if it is a key spend path with the given Merkle root
let root_hash = Some(node.hash);
- let mut info = Self::new_key_spend(secp, internal_key, root_hash);
+ let mut info = Self::new_key_spend(internal_key, root_hash);
for leaves in node.leaves {
match leaves.leaf {
@@ -587,17 +583,16 @@ impl TaprootBuilder {
///
/// Returns the unmodified builder as Err if the builder is not finalizable.
/// See also [`TaprootBuilder::is_finalizable`]
- pub fn finalize<C: secp256k1::Verification, K: Into<XOnlyPublicKey>>(
+ pub fn finalize<K: Into<XOnlyPublicKey>>(
mut self,
- secp: &Secp256k1<C>,
internal_key: K,
) -> Result<TaprootSpendInfo, Self> {
let internal_key = internal_key.into();
match self.branch.len() {
- 0 => Ok(TaprootSpendInfo::new_key_spend(secp, internal_key, None)),
+ 0 => Ok(TaprootSpendInfo::new_key_spend(internal_key, None)),
1 =>
if let Some(Some(node)) = self.branch.pop() {
- Ok(TaprootSpendInfo::from_node_info(secp, internal_key, node))
+ Ok(TaprootSpendInfo::from_node_info(internal_key, node))
} else {
unreachable!("size checked above. Builder guarantees the last element is Some")
},
@@ -1293,9 +1288,8 @@ impl<Branch: AsRef<TaprootMerkleBranch> + ?Sized> ControlBlock<Branch> {
///
/// Only checks that script is contained inside the [`TapTree`] described by output key. Full
/// verification must also execute the script with witness data.
- pub fn verify_taproot_commitment<C: secp256k1::Verification>(
+ pub fn verify_taproot_commitment(
&self,
- secp: &Secp256k1<C>,
output_key: XOnlyPublicKey,
script: &TapScript,
) -> bool {
@@ -1310,7 +1304,7 @@ impl<Branch: AsRef<TaprootMerkleBranch> + ?Sized> ControlBlock<Branch> {
// compute the taptweak
let tweak =
TapTweakHash::from_key_and_merkle_root(self.internal_key, Some(curr_hash)).to_scalar();
- self.internal_key.tweak_add_check(secp, &output_key, self.output_key_parity, tweak)
+ self.internal_key.tweak_add_check(&output_key, self.output_key_parity, tweak)
}
}
@@ -1691,7 +1685,6 @@ impl std::error::Error for InvalidControlBlockSizeError {}
mod test {
use hashes::sha256;
use hex::DisplayHex;
- use secp256k1::VerifyOnly;
use super::*;
use crate::script::ScriptBufExt as _;
@@ -1783,7 +1776,6 @@ mod test {
}
fn _verify_tap_commitments(
- secp: &Secp256k1<VerifyOnly>,
out_spk_hex: &str,
script_hex: &str,
control_block_hex: &str,
@@ -1794,7 +1786,6 @@ mod test {
let control_block = ControlBlock::from_hex(control_block_hex).unwrap();
assert_eq!(control_block_hex, control_block.serialize().to_lower_hex_string());
assert!(control_block.verify_taproot_commitment(
- secp,
out_pk.to_x_only_public_key(),
&script
));
@@ -1802,59 +1793,53 @@ mod test {
#[test]
fn control_block_verify() {
- let secp = Secp256k1::verification_only();
// test vectors obtained from printing values in feature_taproot.py from Bitcoin Core
- _verify_tap_commitments(&secp, "51205dc8e62b15e0ebdf44751676be35ba32eed2e84608b290d4061bbff136cd7ba9", "6a", "c1a9d6f66cd4b25004f526bfa873e56942f98e8e492bd79ed6532b966104817c2bda584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e0641e660d1e5392fb79d64838c2b84faf04b7f5f283c9d8bf83e39e177b64372a0cd22eeab7e093873e851e247714eff762d8a30be699ba4456cfe6491b282e193a071350ae099005a5950d74f73ba13077a57bc478007fb0e4d1099ce9cf3d4");
- _verify_tap_commitments(&secp, "5120e208c869c40d8827101c5ad3238018de0f3f5183d77a0c53d18ac28ddcbcd8ad", "f4", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40090ab1f4890d51115998242ebce636efb9ede1b516d9eb8952dc1068e0335306199aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4da14e029b1e154a85bfd9139e7aa2720b6070a4ceba8264ca61d5d3ac27aceb9ef4b54cd43c2d1fd5e11b5c2e93cf29b91ea3dc5b832201f02f7473a28c63246");
+ _verify_tap_commitments("51205dc8e62b15e0ebdf44751676be35ba32eed2e84608b290d4061bbff136cd7ba9", "6a", "c1a9d6f66cd4b25004f526bfa873e56942f98e8e492bd79ed6532b966104817c2bda584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e0641e660d1e5392fb79d64838c2b84faf04b7f5f283c9d8bf83e39e177b64372a0cd22eeab7e093873e851e247714eff762d8a30be699ba4456cfe6491b282e193a071350ae099005a5950d74f73ba13077a57bc478007fb0e4d1099ce9cf3d4");
+ _verify_tap_commitments("5120e208c869c40d8827101c5ad3238018de0f3f5183d77a0c53d18ac28ddcbcd8ad", "f4", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40090ab1f4890d51115998242ebce636efb9ede1b516d9eb8952dc1068e0335306199aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4da14e029b1e154a85bfd9139e7aa2720b6070a4ceba8264ca61d5d3ac27aceb9ef4b54cd43c2d1fd5e11b5c2e93cf29b91ea3dc5b832201f02f7473a28c63246");
_verify_tap_commitments(
- &secp,
"5120567666e7df90e0450bb608e17c01ed3fbcfa5355a5f8273e34e583bfaa70ce09",
"203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ac",
"c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
);
- _verify_tap_commitments(&secp, "5120580a19e47269414a55eb86d5d0c6c9b371455d9fd2154412a57dec840df99fe1", "6a", "bca0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40042ba1bd1c63c03ccff60d4c4d53a653f87909eb3358e7fa45c9d805231fb08c933e1f4e0f9d17f591df1419df7d5b7eb5f744f404c5ef9ecdb1b89b18cafa3a816d8b5dba3205f9a9c05f866d91f40d2793a7586d502cb42f46c7a11f66ad4aa");
- _verify_tap_commitments(&secp, "5120228b94a4806254a38d6efa8a134c28ebc89546209559dfe40b2b0493bafacc5b", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009c9aed3dfd11ab0e78bf87ef3bf296269dc4b0f7712140386d6980992bab4b45");
+ _verify_tap_commitments("5120580a19e47269414a55eb86d5d0c6c9b371455d9fd2154412a57dec840df99fe1", "6a", "bca0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40042ba1bd1c63c03ccff60d4c4d53a653f87909eb3358e7fa45c9d805231fb08c933e1f4e0f9d17f591df1419df7d5b7eb5f744f404c5ef9ecdb1b89b18cafa3a816d8b5dba3205f9a9c05f866d91f40d2793a7586d502cb42f46c7a11f66ad4aa");
+ _verify_tap_commitments("5120228b94a4806254a38d6efa8a134c28ebc89546209559dfe40b2b0493bafacc5b", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009c9aed3dfd11ab0e78bf87ef3bf296269dc4b0f7712140386d6980992bab4b45");
_verify_tap_commitments(
- &secp,
"5120567666e7df90e0450bb608e17c01ed3fbcfa5355a5f8273e34e583bfaa70ce09",
"203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ac",
"c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
);
_verify_tap_commitments(
- &secp,
"5120b0a79103c31fe51eea61d2873bad8a25a310da319d7e7a85f825fa7a00ea3f85",
"203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ad51",
"c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
);
- _verify_tap_commitments(&secp, "5120f2f62e854a0012aeba78cd4ba4a0832447a5262d4c6eb4f1c95c7914b536fc6c", "6a86", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009ad3d30479f0689dbdf59a6b840d60ad485b2effbed1825a75ce19a44e460e09056f60ea686d79cfa4fb79f197b2e905ac857a983be4a5a41a4873e865aa950780c0237de279dc063e67deec46ef8e1bc351bf12c4d67a6d568001faf097e797e6ee620f53cfe0f8acaddf2063c39c3577853bb46d61ffcba5a024c3e1216837");
- _verify_tap_commitments(&secp, "51202a4772070b49bae68b44315032cdbf9c40c7c2f896781b32b931b73dbfb26d7e", "6af8", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4006f183944a14618fc7fe9ceade0f58e43a19d3c3b179ea6c43c29616413b6971c99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4c3462adec78cd04f3cc156bdadec50def99feae0dc6a23664e8a2b0d42d6ca9eb968dfdf46c23af642b2688351904e0a0630e71ffac5bcaba33b9b2c8a7495ec");
- _verify_tap_commitments(&secp, "5120a32b0b8cfafe0f0f8d5870030ba4d19a8725ad345cb3c8420f86ac4e0dff6207", "4c", "e8a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400615da7ac8d078e5fc7f4690fc2127ba40f0f97cc070ade5b3a7919783d91ef3f13734aab908ae998e57848a01268fe8217d70bc3ee8ea8ceae158ae964a4b5f3af20b50d7019bf47fde210eee5c52f1cfe71cfca78f2d3e7c1fd828c80351525");
+ _verify_tap_commitments("5120f2f62e854a0012aeba78cd4ba4a0832447a5262d4c6eb4f1c95c7914b536fc6c", "6a86", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009ad3d30479f0689dbdf59a6b840d60ad485b2effbed1825a75ce19a44e460e09056f60ea686d79cfa4fb79f197b2e905ac857a983be4a5a41a4873e865aa950780c0237de279dc063e67deec46ef8e1bc351bf12c4d67a6d568001faf097e797e6ee620f53cfe0f8acaddf2063c39c3577853bb46d61ffcba5a024c3e1216837");
+ _verify_tap_commitments("51202a4772070b49bae68b44315032cdbf9c40c7c2f896781b32b931b73dbfb26d7e", "6af8", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4006f183944a14618fc7fe9ceade0f58e43a19d3c3b179ea6c43c29616413b6971c99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4c3462adec78cd04f3cc156bdadec50def99feae0dc6a23664e8a2b0d42d6ca9eb968dfdf46c23af642b2688351904e0a0630e71ffac5bcaba33b9b2c8a7495ec");
+ _verify_tap_commitments("5120a32b0b8cfafe0f0f8d5870030ba4d19a8725ad345cb3c8420f86ac4e0dff6207", "4c", "e8a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400615da7ac8d078e5fc7f4690fc2127ba40f0f97cc070ade5b3a7919783d91ef3f13734aab908ae998e57848a01268fe8217d70bc3ee8ea8ceae158ae964a4b5f3af20b50d7019bf47fde210eee5c52f1cfe71cfca78f2d3e7c1fd828c80351525");
_verify_tap_commitments(
- &secp,
"5120b0a79103c31fe51eea61d2873bad8a25a310da319d7e7a85f825fa7a00ea3f85",
"203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ad51",
"c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
);
- _verify_tap_commitments(&secp, "51208678459f1fa0f80e9b89b8ffdcaf46a022bdf60aa45f1fed9a96145edf4ec400", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001eff29e1a89e650076b8d3c56302881d09c9df215774ed99993aaed14acd6615");
- _verify_tap_commitments(&secp, "5120017316303aed02bcdec424c851c9eacbe192b013139bd9634c4e19b3475b06e1", "61", "02a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40050462265ca552b23cbb4fe021b474313c8cb87d4a18b3f7bdbeb2b418279ba31fc6509d829cd42336f563363cb3538d78758e0876c71e13012eb2b656eb0edb051a2420a840d5c8c6c762abc7410af2c311f606b20ca2ace56a8139f84b1379a");
- _verify_tap_commitments(&secp, "5120896d4d5d2236e86c6e9320e86d1a7822e652907cbd508360e8c71aefc127c77d", "61", "14a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001ab0e9d9a4858a0e69605fe9c5a42d739fbe26fa79650e7074f462b02645f7ea1c91802b298cd91e6b5af57c6a013d93397cd2ecbd5569382cc27becf44ff4fff8960b20f846160c159c58350f6b6072cf1b3daa5185b7a42524fb72cbc252576ae46732b8e31ac24bfa7d72f4c3713e8696f99d8ac6c07e4c820a03f249f144");
- _verify_tap_commitments(&secp, "512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
- _verify_tap_commitments(&secp, "5120b28d75a7179de6feb66b8bb0bfa2b2c739d1a41cf7366a1b393804a844db8a28", "61", "c4a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400eebc95ded88fb8050094e8dfa958c3be0894eaff0fafae678206b26918d8d7ac47039d40fe34d04b4155df7f1be7f2a49253c7e87812ea9e569e683ac27459e652d6503aa32d64734d00adfee8798b2eed28858abf3bd038e8fa58eb7df4a2d9");
- _verify_tap_commitments(&secp, "512043e4aa733fc6f43c78a31c2b3c192623acf5cc8c01199ebcc4de88067baca83e", "bd4c", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003f7be6f8848b5bddf332c4d7bd83077f73701e2479f70e02b5730e841234d082b8b41ebea96ffd937715d9faeaa6895e6ef3b22919c554b75df12b3371d328023e443d1df50634ecc1cd169803a1e546f0d44304d8fc5056c408e597fed469b8437d6660eaad3cf72e35ba6e5ff7ddd5e293c1e7e813c871df4f46508e9946ec");
- _verify_tap_commitments(&secp, "5120ee9aecb28f5f35ce1f8b5ec80275ac0f81bca4a21b29b4632fb4bcbef8823e6a", "2021a5981b13be29c9d4ea179ea44a8b773ea8c02d68f6f6eefd98de20d4bd055fac", "c13359c284c196b6e80f0cf1d93b6a397cf7ee722f0427b705bd954b88ada8838bd2622fd0e104fc50aa763b43c6a792d7d117029983abd687223b4344a9402c618bba7f5fc3fa8a57491f6842acde88c1e675ca35caea3b1a69ee2c2d9b10f615");
- _verify_tap_commitments(&secp, "5120885274df2252b44764dcef53c21f21154e8488b7e79fafbc96b9ebb22ad0200d", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4000793597254158918e3369507f2d6fdbef17d18b1028bbb0719450ded0f42c58f");
- _verify_tap_commitments(&secp, "512066f6f6f91d47674d198a28388e1eb05ec24e6ddbba10f16396b1a80c08675121", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400fe92aff70a2e8e2a4f34a913b99612468a41e0f8ecaff9a729a173d11013c27e");
- _verify_tap_commitments(&secp, "5120868ed9307bd4637491ff03e3aa2c216a08fe213cac8b6cedbb9ab31dbfa6512c", "61", "a2a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400da584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e46c7eccffefd2d573ec014130e508f0c9963ccebd7830409f7b1b1301725e9fa759d4ef857ec8e0bb42d6d31609d3c7e77de3bfa28c38f93393a6ddbabe819ec560ed4f061fbe742a5fd2a648d5209469420434c8753da3fa7067cc2bb4c172a");
- _verify_tap_commitments(&secp, "5120c1a00a9baa82888fd7d30291135a7eaa9e9966a5f16db2b10460572f8b108d8d", "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5ba0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007960d7b37dd1361aee34510e77acb4d27ddca17648a17e28475032538c1eb500f5a747f2c0893f79fe153ae918ac3d696de9322aa679aae62051ff5ed83aa502b338bd907346abd4cd9cf06117cb35d55a5a8dd950843522f8de7b5c7fba1804c38b0778d3d76b383f6db6fdf9d6e770da8fffbfa5152c0b8b38129885bcdee6");
- _verify_tap_commitments(&secp, "5120bb9abeff7286b76dfc61800c548fe2621ff47506e47201a85c543b4a9a96fead", "75203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf47342796ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6eadac", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003eb5cdc419e0a6a800f34583ce750f387be34879c26f4230991bd61da743ad9d34d288e79397b709ac22ad8cc57645d593af3e15b97a876362117177ab2519c000000000000000000000000000000000000000000000000000000000000000007160c3a48c8b17bc3aeaf01db9e0a96ac47a5a9fa329e046856e7765e89c8a93ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff07feb9aa7cd72c78e66a85414cd19289f8b0ab1415013dc2a007666aa9248ec1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001fccc8bea662a9442a94f7ba0643c1d7ee7cc689f3b3506b7c8c99fd3f3b3d7772972dcdf2550cf95b65098aea67f72fef10abdcf1cef9815af8f4c4644b060e0000000000000000000000000000000000000000000000000000000000000000");
- _verify_tap_commitments(&secp, "5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "4d09024747703eb9f759ce5ecd839109fecc40974ab16f5173ea390daaa5a78f7abe898165c90990062af998c5dc7989818393158a2c62b7ece727e7f5400d2efd33db8732599f6d1dce6b5b68d2d47317f2de6c9df118f61227f98453225036618aaf058140f2415d134fa69ba041c724ad81387f8c568d12ddc49eb32a71532096181b3f85fd465b8e9a176bb19f45c070baad47a2cc4505414b88c31cb5b0a192b2d2d56c404a37070b04d42c875c4ac351224f5b254f9ad0b820f43cad292d6565f796bf083173e14723f1e543c85a61689ddd5cb6666b240c15c38ce3320bf0c3be9e0322e5ef72366c294d3a2d7e8b8e7db875e7ae814537554f10b91c72b8b413e026bd5d5e917de4b54fa8f43f38771a7f242aa32dcb7ca1b0588dbf54af7ab9455047fbb894cdfdd242166db784276430eb47d4df092a6b8cb160eb982fe7d14a44283bdb4a9861ca65c06fd8b2546cfbfe38bc77f527de1b9bfd2c95a3e283b7b1d1d2b2fa291256a90a7003aefcef47ceabf113865a494af43e96a38b0b00919855eb7722ea2363e0ddfc9c51c08631d01e2a2d56e786b4ff6f1e5d415facc9c2619c285d9ad43001878294157cb025f639fb954271fd1d6173f6bc16535672f6abdd72b0284b4ff3eaf5b7247719d7c39365622610efae6562bef6e08a0b370fba75bb04dbdb90a482d8417e057f8bd021ea6ac32d0d48b08be9f77833b11e5e739960c9837d7583", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400ff698adfda0327f188e2ee35f7aecc0f90c9138a350d450648d968c2b5dd7ef94ddd3ec418dc0d03ee4956feb708d838ed2b20e5a193465a6a1467fd3054e1ea141ea4c4c503a6271e19a090e2a69a24282e3be04c4f98720f7a0eb274d9693d13a8e3c139aa625fa2aefd09854570527f9ac545bda1b689719f5cb715612c07");
- _verify_tap_commitments(&secp, "5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "83", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007388cda01113397d4cd00bcfbd08fd68c3cfe3a42cbfe3a7651c1d5e6dacf1ad99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4b59764bec92507e4a4c3f01a06f05980163ca10f1c549bfe01f85fa4f109a1295e607f5ed9f1008048474de336f11f67a1fbf2012f58944dede0ab19a3ca81f5");
- _verify_tap_commitments(&secp, "512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
+ _verify_tap_commitments("51208678459f1fa0f80e9b89b8ffdcaf46a022bdf60aa45f1fed9a96145edf4ec400", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001eff29e1a89e650076b8d3c56302881d09c9df215774ed99993aaed14acd6615");
+ _verify_tap_commitments("5120017316303aed02bcdec424c851c9eacbe192b013139bd9634c4e19b3475b06e1", "61", "02a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40050462265ca552b23cbb4fe021b474313c8cb87d4a18b3f7bdbeb2b418279ba31fc6509d829cd42336f563363cb3538d78758e0876c71e13012eb2b656eb0edb051a2420a840d5c8c6c762abc7410af2c311f606b20ca2ace56a8139f84b1379a");
+ _verify_tap_commitments("5120896d4d5d2236e86c6e9320e86d1a7822e652907cbd508360e8c71aefc127c77d", "61", "14a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001ab0e9d9a4858a0e69605fe9c5a42d739fbe26fa79650e7074f462b02645f7ea1c91802b298cd91e6b5af57c6a013d93397cd2ecbd5569382cc27becf44ff4fff8960b20f846160c159c58350f6b6072cf1b3daa5185b7a42524fb72cbc252576ae46732b8e31ac24bfa7d72f4c3713e8696f99d8ac6c07e4c820a03f249f144");
+ _verify_tap_commitments("512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
+ _verify_tap_commitments("5120b28d75a7179de6feb66b8bb0bfa2b2c739d1a41cf7366a1b393804a844db8a28", "61", "c4a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400eebc95ded88fb8050094e8dfa958c3be0894eaff0fafae678206b26918d8d7ac47039d40fe34d04b4155df7f1be7f2a49253c7e87812ea9e569e683ac27459e652d6503aa32d64734d00adfee8798b2eed28858abf3bd038e8fa58eb7df4a2d9");
+ _verify_tap_commitments("512043e4aa733fc6f43c78a31c2b3c192623acf5cc8c01199ebcc4de88067baca83e", "bd4c", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003f7be6f8848b5bddf332c4d7bd83077f73701e2479f70e02b5730e841234d082b8b41ebea96ffd937715d9faeaa6895e6ef3b22919c554b75df12b3371d328023e443d1df50634ecc1cd169803a1e546f0d44304d8fc5056c408e597fed469b8437d6660eaad3cf72e35ba6e5ff7ddd5e293c1e7e813c871df4f46508e9946ec");
+ _verify_tap_commitments("5120ee9aecb28f5f35ce1f8b5ec80275ac0f81bca4a21b29b4632fb4bcbef8823e6a", "2021a5981b13be29c9d4ea179ea44a8b773ea8c02d68f6f6eefd98de20d4bd055fac", "c13359c284c196b6e80f0cf1d93b6a397cf7ee722f0427b705bd954b88ada8838bd2622fd0e104fc50aa763b43c6a792d7d117029983abd687223b4344a9402c618bba7f5fc3fa8a57491f6842acde88c1e675ca35caea3b1a69ee2c2d9b10f615");
+ _verify_tap_commitments("5120885274df2252b44764dcef53c21f21154e8488b7e79fafbc96b9ebb22ad0200d", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4000793597254158918e3369507f2d6fdbef17d18b1028bbb0719450ded0f42c58f");
+ _verify_tap_commitments("512066f6f6f91d47674d198a28388e1eb05ec24e6ddbba10f16396b1a80c08675121", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400fe92aff70a2e8e2a4f34a913b99612468a41e0f8ecaff9a729a173d11013c27e");
+ _verify_tap_commitments("5120868ed9307bd4637491ff03e3aa2c216a08fe213cac8b6cedbb9ab31dbfa6512c", "61", "a2a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400da584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e46c7eccffefd2d573ec014130e508f0c9963ccebd7830409f7b1b1301725e9fa759d4ef857ec8e0bb42d6d31609d3c7e77de3bfa28c38f93393a6ddbabe819ec560ed4f061fbe742a5fd2a648d5209469420434c8753da3fa7067cc2bb4c172a");
+ _verify_tap_commitments("5120c1a00a9baa82888fd7d30291135a7eaa9e9966a5f16db2b10460572f8b108d8d", "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5ba0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007960d7b37dd1361aee34510e77acb4d27ddca17648a17e28475032538c1eb500f5a747f2c0893f79fe153ae918ac3d696de9322aa679aae62051ff5ed83aa502b338bd907346abd4cd9cf06117cb35d55a5a8dd950843522f8de7b5c7fba1804c38b0778d3d76b383f6db6fdf9d6e770da8fffbfa5152c0b8b38129885bcdee6");
+ _verify_tap_commitments("5120bb9abeff7286b76dfc61800c548fe2621ff47506e47201a85c543b4a9a96fead", "75203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf47342796ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6eadac", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003eb5cdc419e0a6a800f34583ce750f387be34879c26f4230991bd61da743ad9d34d288e79397b709ac22ad8cc57645d593af3e15b97a876362117177ab2519c000000000000000000000000000000000000000000000000000000000000000007160c3a48c8b17bc3aeaf01db9e0a96ac47a5a9fa329e046856e7765e89c8a93ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff07feb9aa7cd72c78e66a85414cd19289f8b0ab1415013dc2a007666aa9248ec1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001fccc8bea662a9442a94f7ba0643c1d7ee7cc689f3b3506b7c8c99fd3f3b3d7772972dcdf2550cf95b65098aea67f72fef10abdcf1cef9815af8f4c4644b060e0000000000000000000000000000000000000000000000000000000000000000");
+ _verify_tap_commitments("5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "4d09024747703eb9f759ce5ecd839109fecc40974ab16f5173ea390daaa5a78f7abe898165c90990062af998c5dc7989818393158a2c62b7ece727e7f5400d2efd33db8732599f6d1dce6b5b68d2d47317f2de6c9df118f61227f98453225036618aaf058140f2415d134fa69ba041c724ad81387f8c568d12ddc49eb32a71532096181b3f85fd465b8e9a176bb19f45c070baad47a2cc4505414b88c31cb5b0a192b2d2d56c404a37070b04d42c875c4ac351224f5b254f9ad0b820f43cad292d6565f796bf083173e14723f1e543c85a61689ddd5cb6666b240c15c38ce3320bf0c3be9e0322e5ef72366c294d3a2d7e8b8e7db875e7ae814537554f10b91c72b8b413e026bd5d5e917de4b54fa8f43f38771a7f242aa32dcb7ca1b0588dbf54af7ab9455047fbb894cdfdd242166db784276430eb47d4df092a6b8cb160eb982fe7d14a44283bdb4a9861ca65c06fd8b2546cfbfe38bc77f527de1b9bfd2c95a3e283b7b1d1d2b2fa291256a90a7003aefcef47ceabf113865a494af43e96a38b0b00919855eb7722ea2363e0ddfc9c51c08631d01e2a2d56e786b4ff6f1e5d415facc9c2619c285d9ad43001878294157cb025f639fb954271fd1d6173f6bc16535672f6abdd72b0284b4ff3eaf5b7247719d7c39365622610efae6562bef6e08a0b370fba75bb04dbdb90a482d8417e057f8bd021ea6ac32d0d48b08be9f77833b11e5e739960c9837d7583", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400ff698adfda0327f188e2ee35f7aecc0f90c9138a350d450648d968c2b5dd7ef94ddd3ec418dc0d03ee4956feb708d838ed2b20e5a193465a6a1467fd3054e1ea141ea4c4c503a6271e19a090e2a69a24282e3be04c4f98720f7a0eb274d9693d13a8e3c139aa625fa2aefd09854570527f9ac545bda1b689719f5cb715612c07");
+ _verify_tap_commitments("5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "83", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007388cda01113397d4cd00bcfbd08fd68c3cfe3a42cbfe3a7651c1d5e6dacf1ad99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4b59764bec92507e4a4c3f01a06f05980163ca10f1c549bfe01f85fa4f109a1295e607f5ed9f1008048474de336f11f67a1fbf2012f58944dede0ab19a3ca81f5");
+ _verify_tap_commitments("512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
}
#[test]
fn build_huffman_tree() {
- let secp = Secp256k1::verification_only();
let internal_key = "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51"
.parse::<UntweakedPublicKey>()
.unwrap();
@@ -1867,7 +1852,7 @@ mod test {
(19, TapScriptBuf::from_hex_no_length_prefix("55").unwrap()),
];
let tree_info =
- TaprootSpendInfo::with_huffman_tree(&secp, internal_key, script_weights.clone())
+ TaprootSpendInfo::with_huffman_tree(internal_key, script_weights.clone())
.unwrap();
/* The resulting tree should put the scripts into a tree similar
@@ -1905,7 +1890,6 @@ mod test {
let ver_script = (script, LeafVersion::TapScript);
let ctrl_block = tree_info.control_block(&ver_script).unwrap();
assert!(ctrl_block.verify_taproot_commitment(
- &secp,
output_key.to_x_only_public_key(),
&ver_script.0
))
@@ -1914,7 +1898,6 @@ mod test {
#[test]
fn taptree_builder() {
- let secp = Secp256k1::verification_only();
let internal_key = "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51"
.parse::<UntweakedPublicKey>()
.unwrap();
@@ -1940,7 +1923,7 @@ mod test {
let builder = builder.add_leaf(3, d.clone()).unwrap();
// Trying to finalize an incomplete tree returns the Err(builder)
- let builder = builder.finalize(&secp, internal_key).unwrap_err();
+ let builder = builder.finalize(internal_key).unwrap_err();
let builder = builder.add_leaf(3, e.clone()).unwrap();
#[cfg(feature = "serde")]
@@ -1972,14 +1955,13 @@ mod test {
],);
}
- let tree_info = builder.finalize(&secp, internal_key).unwrap();
+ let tree_info = builder.finalize(internal_key).unwrap();
let output_key = tree_info.output_key();
for script in [a, b, c, d, e] {
let ver_script = (script, LeafVersion::TapScript);
let ctrl_block = tree_info.control_block(&ver_script).unwrap();
assert!(ctrl_block.verify_taproot_commitment(
- &secp,
output_key.to_x_only_public_key(),
&ver_script.0
))
@@ -2054,7 +2036,6 @@ mod test {
let data = bip_341_read_json();
// Check the version of data
assert!(data["version"] == 1);
- let secp = &secp256k1::Secp256k1::verification_only();
for arr in data["scriptPubKey"].as_array().unwrap() {
let internal_key =
@@ -2077,7 +2058,7 @@ mod test {
let mut builder = TaprootBuilder::new();
let mut leaves = vec![];
builder = process_script_trees(script_tree, builder, &mut leaves, 0);
- let spend_info = builder.finalize(secp, internal_key).unwrap();
+ let spend_info = builder.finalize(internal_key).unwrap();
for (i, script_ver) in leaves.iter().enumerate() {
let expected_leaf_hash = leaf_hashes[i].as_str().unwrap();
let expected_ctrl_blk =
@@ -2108,8 +2089,8 @@ mod test {
.assume_checked();
let tweak = TapTweakHash::from_key_and_merkle_root(internal_key, merkle_root);
- let (output_key, _parity) = internal_key.tap_tweak(secp, merkle_root);
- let addr = Address::p2tr(secp, internal_key, merkle_root, KnownHrp::Mainnet);
+ let (output_key, _parity) = internal_key.tap_tweak(merkle_root);
+ let addr = Address::p2tr(internal_key, merkle_root, KnownHrp::Mainnet);
let spk = addr.script_pubkey();
assert_eq!(expected_output_key, output_key.to_x_only_public_key());
diff --git a/bitcoin/tests/bip_174.rs b/bitcoin/tests/bip_174.rs
index 889e122a..edcee741 100644
--- a/bitcoin/tests/bip_174.rs
+++ b/bitcoin/tests/bip_174.rs
@@ -10,7 +10,6 @@ use bitcoin::hex::FromHex;
use bitcoin::opcodes::all::OP_0;
use bitcoin::psbt::{Psbt, PsbtSighashType};
use bitcoin::script::{PushBytes, ScriptBuf, ScriptBufExt as _};
-use bitcoin::secp256k1::Secp256k1;
use bitcoin::{
absolute, script, transaction, NetworkKind, OutPoint, PrivateKey, PublicKey, ScriptPubKeyBuf,
ScriptSigBuf, Sequence, Transaction, TxIn, TxOut, Witness,
@@ -29,14 +28,12 @@ fn hex_script<T>(s: &str) -> ScriptBuf<T> {
#[test]
fn bip174_psbt_workflow() {
- let secp = Secp256k1::new();
-
//
// Step 0: Create the extended private key from the test vector data.
//
let ext_priv = build_extended_private_key();
- let ext_pub = Xpub::from_xpriv(&secp, &ext_priv);
+ let ext_pub = Xpub::from_xpriv(&ext_priv);
let parent_fingerprint = ext_pub.fingerprint();
//
@@ -310,8 +307,6 @@ fn parse_and_verify_keys(
ext_priv: &Xpriv,
sk_path: &[(&str, &str)],
) -> BTreeMap<PublicKey, PrivateKey> {
- let secp = &Secp256k1::new();
-
let mut key_map = BTreeMap::new();
for (secret_key, derivation_path) in sk_path.iter() {
let wif_priv = PrivateKey::from_wif(secret_key).expect("failed to parse key");
@@ -319,9 +314,9 @@ fn parse_and_verify_keys(
let path =
derivation_path.into_derivation_path().expect("failed to convert derivation path");
let derived_priv =
- ext_priv.derive_xpriv(secp, &path).expect("derivation path too long").to_private_key();
+ ext_priv.derive_xpriv(&path).expect("derivation path too long").to_private_key();
assert_eq!(wif_priv, derived_priv);
- let derived_pub = derived_priv.public_key(secp);
+ let derived_pub = derived_priv.public_key();
key_map.insert(derived_pub, derived_priv);
}
key_map
@@ -411,8 +406,7 @@ fn combine_lexicographically() {
/// Signs `psbt` with `keys` if required.
fn sign(mut psbt: Psbt, keys: BTreeMap<bitcoin::PublicKey, PrivateKey>) -> Psbt {
- let secp = Secp256k1::new();
- psbt.sign(&keys, &secp).unwrap();
+ psbt.sign(&keys).unwrap();
psbt
}
diff --git a/bitcoin/tests/psbt-sign-taproot.rs b/bitcoin/tests/psbt-sign-taproot.rs
index ca2e84dc..edeeb161 100644
--- a/bitcoin/tests/psbt-sign-taproot.rs
+++ b/bitcoin/tests/psbt-sign-taproot.rs
@@ -13,7 +13,7 @@ use bitcoin::{
absolute, script, Address, Amount, Network, OutPoint, PrivateKey, Psbt, ScriptSigBuf, Sequence,
TapScriptBuf, Transaction, TxIn, TxOut, Witness, XOnlyPublicKey,
};
-use secp256k1::{Keypair, Secp256k1, Signing};
+use secp256k1::Keypair;
#[test]
fn psbt_sign_taproot() {
@@ -24,10 +24,9 @@ fn psbt_sign_taproot() {
impl GetKey for Keystore {
type Error = SignError;
- fn get_key<C: Signing>(
+ fn get_key(
&self,
key_request: &KeyRequest,
- _secp: &Secp256k1<C>,
) -> Result<Option<PrivateKey>, Self::Error> {
match key_request {
KeyRequest::Bip32((mfp, _)) =>
@@ -41,8 +40,6 @@ fn psbt_sign_taproot() {
}
}
- let secp = &Secp256k1::new();
-
let sk_path = [
("dff1c8c2c016a572914b4c5adb8791d62b4768ae9d0a61be8ab94cf5038d7d90", "m/86'/1'/0'/0/0"),
("1ede31b0e7e47c2afc65ffd158b1b1b9d3b752bba8fd117dc8b9e944a390e8d9", "m/86'/1'/0'/0/1"),
@@ -55,9 +52,9 @@ fn psbt_sign_taproot() {
//
// Create three basic scripts to test script path spend.
- let script1 = create_basic_single_sig_script(secp, sk_path[0].0); // m/86'/1'/0'/0/0
- let script2 = create_basic_single_sig_script(secp, sk_path[1].0); // m/86'/1'/0'/0/1
- let script3 = create_basic_single_sig_script(secp, sk_path[2].0); // m/86'/1'/0'/0/2
+ let script1 = create_basic_single_sig_script(sk_path[0].0); // m/86'/1'/0'/0/0
+ let script2 = create_basic_single_sig_script(sk_path[1].0); // m/86'/1'/0'/0/1
+ let script3 = create_basic_single_sig_script(sk_path[2].0); // m/86'/1'/0'/0/2
// Just use one of the secret keys for the key path spend.
let kp = sk_path[2].0.parse::<Keypair>().expect("failed to create keypair");
@@ -65,7 +62,7 @@ fn psbt_sign_taproot() {
let internal_key = kp.x_only_public_key().0; // Ignore the parity.
let tree =
- create_taproot_tree(secp, script1, script2.clone(), script3, internal_key);
+ create_taproot_tree(script1, script2.clone(), script3, internal_key);
let address = create_p2tr_address(tree.clone());
assert_eq!(
@@ -92,7 +89,7 @@ fn psbt_sign_taproot() {
mfp: mfp.parse::<Fingerprint>().unwrap(),
sk: PrivateKey::new(kp.secret_key(), Network::Testnet(bitcoin::TestnetVersion::V3)),
};
- let _ = psbt_key_path_spend.sign(&keystore, secp);
+ let _ = psbt_key_path_spend.sign(&keystore);
let sig = "92864dc9e56b6260ecbd54ec16b94bb597a2e6be7cca0de89d75e17921e0e1528cba32dd04217175c237e1835b5db1c8b384401718514f9443dce933c6ba9c87";
assert_eq!(sig, psbt_key_path_spend.inputs[0].tap_key_sig.unwrap().signature.to_string());
@@ -138,7 +135,7 @@ fn psbt_sign_taproot() {
//
// Step 2: sign psbt.
//
- let _ = psbt_script_path_spend.sign(&keystore, secp);
+ let _ = psbt_script_path_spend.sign(&keystore);
let sig = "9c1466e1631a58c55fcb8642ce5f7896314f4b565d92c5c80b17aa9abf56d22e0b5e5dcbcfe836bbd7d409491f58aa9e1f68a491ef8f05eef62fb50ffac85727";
assert_eq!(
@@ -166,7 +163,7 @@ fn psbt_sign_taproot() {
}
}
-fn create_basic_single_sig_script(secp: &Secp256k1<secp256k1::All>, sk: &str) -> TapScriptBuf {
+fn create_basic_single_sig_script(sk: &str) -> TapScriptBuf {
let kp = sk.parse::<Keypair>().expect("failed to create keypair");
let x_only_pubkey = kp.x_only_public_key().0;
script::Builder::new()
@@ -176,7 +173,6 @@ fn create_basic_single_sig_script(secp: &Secp256k1<secp256k1::All>, sk: &str) ->
}
fn create_taproot_tree<K: Into<XOnlyPublicKey>>(
- secp: &Secp256k1<secp256k1::All>,
script1: TapScriptBuf,
script2: TapScriptBuf,
script3: TapScriptBuf,
@@ -187,7 +183,7 @@ fn create_taproot_tree<K: Into<XOnlyPublicKey>>(
let builder = builder.add_leaf(2, script1).unwrap();
let builder = builder.add_leaf(2, script2).unwrap();
let builder = builder.add_leaf(1, script3).unwrap();
- builder.finalize(secp, internal_key).unwrap()
+ builder.finalize(internal_key).unwrap()
}
fn create_p2tr_address(tree: TaprootSpendInfo) -> Address {
Risk score
Our methodology →Why this scored 17/100
Human-validated context
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
No validated notes yet.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.