Remove context from Keypair functions

As we did for `PublicKey` get rid of the context.

Author: tcharding

examples/generate_keys.rs

@@ -1,12 +1,11 @@
 extern crate secp256k1;
 
-use secp256k1::{PublicKey, Secp256k1, SecretKey};
+use secp256k1::{PublicKey, SecretKey};
 
 fn main() {
-    let secp = Secp256k1::new();
     let mut rng = rand::rng();
     // First option:
-    let (seckey, pubkey) = secp.generate_keypair(&mut rng);
+    let (seckey, pubkey) = secp256k1::generate_keypair(&mut rng);
 
     assert_eq!(pubkey, PublicKey::from_secret_key(&seckey));
 

examples/musig.rs

@@ -10,7 +10,7 @@ fn main() {
     let secp = Secp256k1::new();
     let mut rng = rand::rng();
 
-    let (seckey1, pubkey1) = secp.generate_keypair(&mut rng);
+    let (seckey1, pubkey1) = secp256k1::generate_keypair(&mut rng);
 
     let seckey2 = SecretKey::new(&mut rng);
     let pubkey2 = PublicKey::from_secret_key(&seckey2);
@@ -76,10 +76,10 @@ fn main() {
 
     let session = Session::new(&secp, &musig_key_agg_cache, agg_nonce, msg);
 
-    let keypair1 = Keypair::from_secret_key(&secp, &seckey1);
+    let keypair1 = Keypair::from_secret_key(&seckey1);
     let partial_sign1 = session.partial_sign(&secp, sec_nonce1, &keypair1, &musig_key_agg_cache);
 
-    let keypair2 = Keypair::from_secret_key(&secp, &seckey2);
+    let keypair2 = Keypair::from_secret_key(&seckey2);
     let partial_sign2 = session.partial_sign(&secp, sec_nonce2, &keypair2, &musig_key_agg_cache);
 
     let is_partial_signature_valid =

src/context/mod.rs

@@ -38,13 +38,6 @@ pub mod global {
     ///
     /// If `rand` and `std` feature is enabled, context will have been randomized using
     /// `rng`.
-    ///
-    /// ```
-    /// # #[cfg(all(feature = "global-context", feature = "rand", feature = "std"))] {
-    /// use secp256k1::{PublicKey, SECP256K1};
-    /// let _ = SECP256K1.generate_keypair(&mut rand::rng());
-    /// # }
-    /// ```
     pub static SECP256K1: &GlobalContext = &GlobalContext { __private: () };
 
     impl Deref for GlobalContext {

src/ecdh.rs

@@ -21,11 +21,9 @@ const SHARED_SECRET_SIZE: usize = constants::SECRET_KEY_SIZE;
 ///
 /// ```
 /// # #[cfg(all(feature = "rand", feature = "std"))] {
-/// # use secp256k1::{rand, Secp256k1};
-/// # use secp256k1::ecdh::SharedSecret;
-/// let s = Secp256k1::new();
-/// let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
-/// let (sk2, pk2) = s.generate_keypair(&mut rand::rng());
+/// # use secp256k1::{rand, ecdh::SharedSecret};
+/// let (sk1, pk1) = secp256k1::generate_keypair(&mut rand::rng());
+/// let (sk2, pk2) = secp256k1::generate_keypair(&mut rand::rng());
 /// let sec1 = SharedSecret::new(&pk2, &sk1);
 /// let sec2 = SharedSecret::new(&pk1, &sk2);
 /// assert_eq!(sec1, sec2);
@@ -112,11 +110,10 @@ impl AsRef<[u8]> for SharedSecret {
 /// # Examples
 /// ```ignore
 /// use bitcoin_hashes::{Hash, sha512};
-/// use secp256k1::{ecdh, rand, Secp256k1, PublicKey, SecretKey};
+/// use secp256k1::{ecdh, rand, PublicKey, SecretKey};
 ///
-/// let s = Secp256k1::new();
-/// let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
-/// let (sk2, pk2) = s.generate_keypair(&mut rand::rng());
+/// let (sk1, pk1) = crate::generate_keypair(&mut rand::rng());
+/// let (sk2, pk2) = crate::generate_keypair(&mut rand::rng());
 ///
 /// let point1 = ecdh::shared_secret_point(&pk2, &sk1);
 /// let secret1 = sha512::Hash::hash(&point1);
@@ -189,7 +186,6 @@ mod tests {
     use wasm_bindgen_test::wasm_bindgen_test as test;
 
     use super::SharedSecret;
-    use crate::Secp256k1;
 
     #[test]
     fn ecdh() {
@@ -251,11 +247,9 @@ mod benches {
     use test::{black_box, Bencher};
 
     use super::SharedSecret;
-    use crate::Secp256k1;
 
     #[bench]
     pub fn bench_ecdh(bh: &mut Bencher) {
-        let s = Secp256k1::signing_only();
         let (sk, pk) = s.generate_keypair(&mut rand::rng());
 
         bh.iter(|| {

src/ecdsa/mod.rs

@@ -371,7 +371,7 @@ impl<C: Verification> Secp256k1<C> {
     /// # use secp256k1::{rand, Secp256k1, Message, Error};
     /// #
     /// # let secp = Secp256k1::new();
-    /// # let (secret_key, public_key) = secp.generate_keypair(&mut rand::rng());
+    /// # let (secret_key, public_key) = secp256k1::generate_keypair(&mut rand::rng());
     /// #
     /// let message = Message::from_digest_slice(&[0xab; 32]).expect("32 bytes");
     /// let sig = secp.sign_ecdsa(message, &secret_key);