Skip to content

Commit 0fb6a2a

Browse files
committed
Merge #844: Remove context from the API
3f5c666 Remove unneeded import (Tobin C. Harding) 38a7d9e Remove context sort_pubkeys (Tobin C. Harding) 4fe0101 ellswift: Remove context (Tobin C. Harding) 70e928c musig: Remove context (Tobin C. Harding) 58c7ba2 Remove context from signing APIs (Tobin C. Harding) 403f541 Remove context from verification functions (Tobin C. Harding) 074a4ac Remove context from Keypair functions (Tobin C. Harding) f8bf19d Remove context from tweaking functions (Tobin C. Harding) 792103b Remove context from PublicKey::from_secret_key (Tobin C. Harding) 95e2e25 Use super::* in tests (Tobin C. Harding) b2cdc98 docs: Remove one instance of context construction (Tobin C. Harding) Pull request description: Tested in rust-bitcoin/rust-bitcoin#4960 ### TODO in this PR: Remove the FIXMEs, I don't exactly understand the `rerandomize_seed` and what is ok to put in it? While trying to work this out I created #847 and #848, apoelstra can you school me on _exactly_ how random the seed needs to be please? ### Follow up PRs: - Do we want to remove the `SECP256K1`, `global-context` (and `global-context-less-secure`) features in this PR instead of deprecating stuff? - Go over the docs and fix places that mention the context ACKs for top commit: apoelstra: ACK 3f5c666; successfully ran local tests Tree-SHA512: ea0667fa950182ddb4cf90f0de96824bb244000cdc9f4a8fd243b29e6c5c8180b4f269d91d918fa035bfe58b48d1b7367cc2f7234e21ea4c6cc7f5a448e92594
2 parents 2e5f65b + 3f5c666 commit 0fb6a2a

File tree

16 files changed

+831
-970
lines changed

16 files changed

+831
-970
lines changed

examples/generate_keys.rs

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,15 @@
11
extern crate secp256k1;
22

3-
use secp256k1::{PublicKey, Secp256k1, SecretKey};
3+
use secp256k1::{PublicKey, SecretKey};
44

55
fn main() {
6-
let secp = Secp256k1::new();
76
let mut rng = rand::rng();
87
// First option:
9-
let (seckey, pubkey) = secp.generate_keypair(&mut rng);
8+
let (seckey, pubkey) = secp256k1::generate_keypair(&mut rng);
109

11-
assert_eq!(pubkey, PublicKey::from_secret_key(&secp, &seckey));
10+
assert_eq!(pubkey, PublicKey::from_secret_key(&seckey));
1211

1312
// Second option:
1413
let seckey = SecretKey::new(&mut rng);
15-
let _pubkey = PublicKey::from_secret_key(&secp, &seckey);
14+
let _pubkey = PublicKey::from_secret_key(&seckey);
1615
}

examples/musig.rs

Lines changed: 16 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -4,33 +4,32 @@ use secp256k1::musig::{
44
new_nonce_pair, AggregatedNonce, KeyAggCache, PartialSignature, PublicNonce, Session,
55
SessionSecretRand,
66
};
7-
use secp256k1::{Keypair, PublicKey, Scalar, Secp256k1, SecretKey};
7+
use secp256k1::{Keypair, PublicKey, Scalar, SecretKey};
88

99
fn main() {
10-
let secp = Secp256k1::new();
1110
let mut rng = rand::rng();
1211

13-
let (seckey1, pubkey1) = secp.generate_keypair(&mut rng);
12+
let (seckey1, pubkey1) = secp256k1::generate_keypair(&mut rng);
1413

1514
let seckey2 = SecretKey::new(&mut rng);
16-
let pubkey2 = PublicKey::from_secret_key(&secp, &seckey2);
15+
let pubkey2 = PublicKey::from_secret_key(&seckey2);
1716

1817
let pubkeys = [pubkey1, pubkey2];
1918
let mut pubkeys_ref: Vec<&PublicKey> = pubkeys.iter().collect();
2019
let pubkeys_ref = pubkeys_ref.as_mut_slice();
2120

22-
secp.sort_pubkeys(pubkeys_ref);
21+
secp256k1::sort_pubkeys(pubkeys_ref);
2322

24-
let mut musig_key_agg_cache = KeyAggCache::new(&secp, pubkeys_ref);
23+
let mut musig_key_agg_cache = KeyAggCache::new(pubkeys_ref);
2524

2625
let plain_tweak: [u8; 32] = *b"this could be a BIP32 tweak....\0";
2726
let xonly_tweak: [u8; 32] = *b"this could be a Taproot tweak..\0";
2827

2928
let plain_tweak = Scalar::from_be_bytes(plain_tweak).unwrap();
30-
musig_key_agg_cache.pubkey_ec_tweak_add(&secp, &plain_tweak).unwrap();
29+
musig_key_agg_cache.pubkey_ec_tweak_add(&plain_tweak).unwrap();
3130

3231
let xonly_tweak = Scalar::from_be_bytes(xonly_tweak).unwrap();
33-
let tweaked_agg_pk = musig_key_agg_cache.pubkey_xonly_tweak_add(&secp, &xonly_tweak).unwrap();
32+
let tweaked_agg_pk = musig_key_agg_cache.pubkey_xonly_tweak_add(&xonly_tweak).unwrap();
3433

3534
let agg_pk = musig_key_agg_cache.agg_pk();
3635

@@ -41,7 +40,6 @@ fn main() {
4140
let musig_session_sec_rand1 = SessionSecretRand::from_rng(&mut rng);
4241

4342
let nonce_pair1 = new_nonce_pair(
44-
&secp,
4543
musig_session_sec_rand1,
4644
Some(&musig_key_agg_cache),
4745
Some(seckey1),
@@ -53,7 +51,6 @@ fn main() {
5351
let musig_session_sec_rand2 = SessionSecretRand::from_rng(&mut rng);
5452

5553
let nonce_pair2 = new_nonce_pair(
56-
&secp,
5754
musig_session_sec_rand2,
5855
Some(&musig_key_agg_cache),
5956
Some(seckey2),
@@ -72,22 +69,22 @@ fn main() {
7269
let nonces_ref: Vec<&PublicNonce> = nonces.iter().collect();
7370
let nonces_ref = nonces_ref.as_slice();
7471

75-
let agg_nonce = AggregatedNonce::new(&secp, nonces_ref);
72+
let agg_nonce = AggregatedNonce::new(nonces_ref);
7673

77-
let session = Session::new(&secp, &musig_key_agg_cache, agg_nonce, msg);
74+
let session = Session::new(&musig_key_agg_cache, agg_nonce, msg);
7875

79-
let keypair1 = Keypair::from_secret_key(&secp, &seckey1);
80-
let partial_sign1 = session.partial_sign(&secp, sec_nonce1, &keypair1, &musig_key_agg_cache);
76+
let keypair1 = Keypair::from_secret_key(&seckey1);
77+
let partial_sign1 = session.partial_sign(sec_nonce1, &keypair1, &musig_key_agg_cache);
8178

82-
let keypair2 = Keypair::from_secret_key(&secp, &seckey2);
83-
let partial_sign2 = session.partial_sign(&secp, sec_nonce2, &keypair2, &musig_key_agg_cache);
79+
let keypair2 = Keypair::from_secret_key(&seckey2);
80+
let partial_sign2 = session.partial_sign(sec_nonce2, &keypair2, &musig_key_agg_cache);
8481

8582
let is_partial_signature_valid =
86-
session.partial_verify(&secp, &musig_key_agg_cache, &partial_sign1, &pub_nonce1, pubkey1);
83+
session.partial_verify(&musig_key_agg_cache, &partial_sign1, &pub_nonce1, pubkey1);
8784
assert!(is_partial_signature_valid);
8885

8986
let is_partial_signature_valid =
90-
session.partial_verify(&secp, &musig_key_agg_cache, &partial_sign2, &pub_nonce2, pubkey2);
87+
session.partial_verify(&musig_key_agg_cache, &partial_sign2, &pub_nonce2, pubkey2);
9188
assert!(is_partial_signature_valid);
9289

9390
let partial_sigs = [partial_sign1, partial_sign2];
@@ -96,5 +93,5 @@ fn main() {
9693

9794
let aggregated_signature = session.partial_sig_agg(partial_sigs_ref);
9895

99-
assert!(aggregated_signature.verify(&secp, &agg_pk, msg).is_ok());
96+
assert!(aggregated_signature.verify(&agg_pk, msg).is_ok());
10097
}

examples/sign_verify.rs

Lines changed: 8 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -15,34 +15,23 @@
1515
1616
extern crate secp256k1;
1717

18-
use secp256k1::{ecdsa, Error, Message, PublicKey, Secp256k1, SecretKey, Signing, Verification};
19-
20-
fn verify<C: Verification>(
21-
secp: &Secp256k1<C>,
22-
msg_digest: [u8; 32],
23-
sig: [u8; 64],
24-
pubkey: [u8; 33],
25-
) -> Result<bool, Error> {
18+
use secp256k1::{ecdsa, Error, Message, PublicKey, SecretKey};
19+
20+
fn verify(sig: [u8; 64], msg_digest: [u8; 32], pubkey: [u8; 33]) -> Result<bool, Error> {
2621
let msg = Message::from_digest(msg_digest);
2722
let sig = ecdsa::Signature::from_compact(&sig)?;
2823
let pubkey = PublicKey::from_slice(&pubkey)?;
2924

30-
Ok(secp.verify_ecdsa(&sig, msg, &pubkey).is_ok())
25+
Ok(ecdsa::verify(&sig, msg, &pubkey).is_ok())
3126
}
3227

33-
fn sign<C: Signing>(
34-
secp: &Secp256k1<C>,
35-
msg_digest: [u8; 32],
36-
seckey: [u8; 32],
37-
) -> Result<ecdsa::Signature, Error> {
28+
fn sign(msg_digest: [u8; 32], seckey: [u8; 32]) -> Result<ecdsa::Signature, Error> {
3829
let msg = Message::from_digest(msg_digest);
3930
let seckey = SecretKey::from_secret_bytes(seckey)?;
40-
Ok(secp.sign_ecdsa(msg, &seckey))
31+
Ok(ecdsa::sign(msg, &seckey))
4132
}
4233

4334
fn main() {
44-
let secp = Secp256k1::new();
45-
4635
let seckey = [
4736
59, 148, 11, 85, 134, 130, 61, 253, 2, 174, 59, 70, 27, 180, 51, 107, 94, 203, 174, 253,
4837
102, 39, 170, 146, 46, 252, 4, 143, 236, 12, 136, 28,
@@ -53,9 +42,9 @@ fn main() {
5342
];
5443
let msg_digest = *b"this must be secure hash output.";
5544

56-
let signature = sign(&secp, msg_digest, seckey).unwrap();
45+
let signature = sign(msg_digest, seckey).unwrap();
5746

5847
let serialize_sig = signature.serialize_compact();
5948

60-
assert!(verify(&secp, msg_digest, serialize_sig, pubkey).unwrap());
49+
assert!(verify(serialize_sig, msg_digest, pubkey).unwrap());
6150
}

no_std_test/src/main.rs

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -79,14 +79,14 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
7979
let mut secp = Secp256k1::preallocated_new(&mut buf).unwrap();
8080
secp.randomize(&mut FakeRng);
8181
let secret_key = SecretKey::new(&mut FakeRng);
82-
let public_key = PublicKey::from_secret_key(&secp, &secret_key);
82+
let public_key = PublicKey::from_secret_key(&secret_key);
8383
let message = Message::from_digest_slice(&[0xab; 32]).expect("32 bytes");
8484

85-
let sig = secp.sign_ecdsa(message, &secret_key);
86-
assert!(secp.verify_ecdsa(&sig, message, &public_key).is_ok());
85+
let sig = ecdsa::sign(message, &secret_key);
86+
assert!(ecdsa::verify(&sig, message, &public_key).is_ok());
8787

8888
let rec_sig = ecdsa::RecoverableSignature::sign_ecdsa_recoverable(message, &secret_key);
89-
assert!(secp.verify_ecdsa(&rec_sig.to_standard(), message, &public_key).is_ok());
89+
assert!(ecdsa::verify(&rec_sig.to_standard(), message, &public_key).is_ok());
9090
assert_eq!(public_key, rec_sig.recover_ecdsa(message).unwrap());
9191
let (rec_id, data) = rec_sig.serialize_compact();
9292
let new_rec_sig = ecdsa::RecoverableSignature::from_compact(&data, rec_id).unwrap();
@@ -106,11 +106,11 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
106106
#[cfg(feature = "alloc")]
107107
{
108108
let secp_alloc = Secp256k1::new();
109-
let public_key = PublicKey::from_secret_key(&secp_alloc, &secret_key);
109+
let public_key = PublicKey::from_secret_key(&secret_key);
110110
let message = Message::from_digest_slice(&[0xab; 32]).expect("32 bytes");
111111

112-
let sig = secp_alloc.sign_ecdsa(message, &secret_key);
113-
assert!(secp_alloc.verify_ecdsa(&sig, message, &public_key).is_ok());
112+
let sig = ecdsa::sign(message, &secret_key);
113+
assert!(ecdsa::verify(&sig, message, &public_key).is_ok());
114114
unsafe { libc::printf("Verified alloc Successfully!\n\0".as_ptr() as _) };
115115
}
116116

src/context/mod.rs

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -38,13 +38,6 @@ pub mod global {
3838
///
3939
/// If `rand` and `std` feature is enabled, context will have been randomized using
4040
/// `rng`.
41-
///
42-
/// ```
43-
/// # #[cfg(all(feature = "global-context", feature = "rand", feature = "std"))] {
44-
/// use secp256k1::{PublicKey, SECP256K1};
45-
/// let _ = SECP256K1.generate_keypair(&mut rand::rng());
46-
/// # }
47-
/// ```
4841
pub static SECP256K1: &GlobalContext = &GlobalContext { __private: () };
4942

5043
impl Deref for GlobalContext {

src/ecdh.rs

Lines changed: 6 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -21,11 +21,9 @@ const SHARED_SECRET_SIZE: usize = constants::SECRET_KEY_SIZE;
2121
///
2222
/// ```
2323
/// # #[cfg(all(feature = "rand", feature = "std"))] {
24-
/// # use secp256k1::{rand, Secp256k1};
25-
/// # use secp256k1::ecdh::SharedSecret;
26-
/// let s = Secp256k1::new();
27-
/// let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
28-
/// let (sk2, pk2) = s.generate_keypair(&mut rand::rng());
24+
/// # use secp256k1::{rand, ecdh::SharedSecret};
25+
/// let (sk1, pk1) = secp256k1::generate_keypair(&mut rand::rng());
26+
/// let (sk2, pk2) = secp256k1::generate_keypair(&mut rand::rng());
2927
/// let sec1 = SharedSecret::new(&pk2, &sk1);
3028
/// let sec2 = SharedSecret::new(&pk1, &sk2);
3129
/// assert_eq!(sec1, sec2);
@@ -112,11 +110,10 @@ impl AsRef<[u8]> for SharedSecret {
112110
/// # Examples
113111
/// ```ignore
114112
/// use bitcoin_hashes::{Hash, sha512};
115-
/// use secp256k1::{ecdh, rand, Secp256k1, PublicKey, SecretKey};
113+
/// use secp256k1::{ecdh, rand, PublicKey, SecretKey};
116114
///
117-
/// let s = Secp256k1::new();
118-
/// let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
119-
/// let (sk2, pk2) = s.generate_keypair(&mut rand::rng());
115+
/// let (sk1, pk1) = crate::generate_keypair(&mut rand::rng());
116+
/// let (sk2, pk2) = crate::generate_keypair(&mut rand::rng());
120117
///
121118
/// let point1 = ecdh::shared_secret_point(&pk2, &sk1);
122119
/// let secret1 = sha512::Hash::hash(&point1);
@@ -189,7 +186,6 @@ mod tests {
189186
use wasm_bindgen_test::wasm_bindgen_test as test;
190187

191188
use super::SharedSecret;
192-
use crate::Secp256k1;
193189

194190
#[test]
195191
fn ecdh() {
@@ -251,11 +247,9 @@ mod benches {
251247
use test::{black_box, Bencher};
252248

253249
use super::SharedSecret;
254-
use crate::Secp256k1;
255250

256251
#[bench]
257252
pub fn bench_ecdh(bh: &mut Bencher) {
258-
let s = Secp256k1::signing_only();
259253
let (sk, pk) = s.generate_keypair(&mut rand::rng());
260254

261255
bh.iter(|| {

0 commit comments

Comments
 (0)