key: update a couple arbitrary API functions to no longer take a context

This updates a couple functions, and their associated unit tests (which
no longer need any std/alloc/global-context feature gates). This runs
clean in valgrind, providing some evidence that my new code is sound.

Author: apoelstra

src/key.rs

@@ -19,8 +19,7 @@ use crate::Error::{self, InvalidPublicKey, InvalidPublicKeySum, InvalidSecretKey
 #[cfg(feature = "global-context")]
 use crate::SECP256K1;
 use crate::{
-    constants, ecdsa, from_hex, schnorr, AllPreallocated, Message, Scalar, Secp256k1, Signing,
-    Verification,
+    constants, ecdsa, from_hex, schnorr, Message, Scalar, Secp256k1, Signing, Verification,
 };
 
 /// Secret key - a 256-bit key used to create ECDSA and Taproot signatures.
@@ -600,11 +599,12 @@ impl PublicKey {
     /// Negates the public key.
     #[inline]
     #[must_use = "you forgot to use the negated public key"]
-    pub fn negate<C: Verification>(mut self, secp: &Secp256k1<C>) -> PublicKey {
-        unsafe {
-            let res = ffi::secp256k1_ec_pubkey_negate(secp.ctx.as_ptr(), &mut self.0);
-            debug_assert_eq!(res, 1);
-        }
+    pub fn negate(mut self) -> PublicKey {
+        let res = crate::with_raw_global_context(
+            |ctx| unsafe { ffi::secp256k1_ec_pubkey_negate(ctx.as_ptr(), &mut self.0) },
+            None,
+        );
+        debug_assert_eq!(res, 1);
         self
     }
 
@@ -614,19 +614,17 @@ impl PublicKey {
     ///
     /// Returns an error if the resulting key would be invalid.
     #[inline]
-    pub fn add_exp_tweak<C: Verification>(
-        mut self,
-        secp: &Secp256k1<C>,
-        tweak: &Scalar,
-    ) -> Result<PublicKey, Error> {
-        unsafe {
-            if ffi::secp256k1_ec_pubkey_tweak_add(secp.ctx.as_ptr(), &mut self.0, tweak.as_c_ptr())
-                == 1
-            {
-                Ok(self)
-            } else {
-                Err(Error::InvalidTweak)
-            }
+    pub fn add_exp_tweak(mut self, tweak: &Scalar) -> Result<PublicKey, Error> {
+        if crate::with_raw_global_context(
+            |ctx| unsafe {
+                ffi::secp256k1_ec_pubkey_tweak_add(ctx.as_ptr(), &mut self.0, tweak.as_c_ptr())
+            },
+            None,
+        ) == 1
+        {
+            Ok(self)
+        } else {
+            Err(Error::InvalidTweak)
         }
     }
 
@@ -870,12 +868,9 @@ impl Keypair {
     /// or if the encoded number is an invalid scalar.
     #[deprecated(since = "0.31.0", note = "Use `from_seckey_byte_array` instead.")]
     #[inline]
-    pub fn from_seckey_slice<C: Signing>(
-        secp: &Secp256k1<C>,
-        data: &[u8],
-    ) -> Result<Keypair, Error> {
+    pub fn from_seckey_slice(data: &[u8]) -> Result<Keypair, Error> {
         match <[u8; constants::SECRET_KEY_SIZE]>::try_from(data) {
-            Ok(data) => Self::from_seckey_byte_array(secp, data),
+            Ok(data) => Self::from_seckey_byte_array(data),
             Err(_) => Err(Error::InvalidSecretKey),
         }
     }
@@ -886,13 +881,16 @@ impl Keypair {
     ///
     /// [`Error::InvalidSecretKey`] if the encoded number is an invalid scalar.
     #[inline]
-    pub fn from_seckey_byte_array<C: Signing>(
-        secp: &Secp256k1<C>,
+    pub fn from_seckey_byte_array(
         data: [u8; constants::SECRET_KEY_SIZE],
     ) -> Result<Keypair, Error> {
         unsafe {
             let mut kp = ffi::Keypair::new();
-            if ffi::secp256k1_keypair_create(secp.ctx.as_ptr(), &mut kp, data.as_c_ptr()) == 1 {
+            if crate::with_raw_global_context(
+                |ctx| ffi::secp256k1_keypair_create(ctx.as_ptr(), &mut kp, data.as_c_ptr()),
+                Some(&data),
+            ) == 1
+            {
                 Ok(Keypair(kp))
             } else {
                 Err(Error::InvalidSecretKey)
@@ -907,13 +905,8 @@ impl Keypair {
     /// [`Error::InvalidSecretKey`] if the string does not consist of exactly 64 hex characters,
     /// or if the encoded number is an invalid scalar.
     #[inline]
-    pub fn from_seckey_str<C: Signing>(secp: &Secp256k1<C>, s: &str) -> Result<Keypair, Error> {
-        let mut res = [0u8; constants::SECRET_KEY_SIZE];
-        match from_hex(s, &mut res) {
-            Ok(constants::SECRET_KEY_SIZE) => Keypair::from_seckey_byte_array(secp, res),
-            _ => Err(Error::InvalidSecretKey),
-        }
-    }
+    #[deprecated(note = "use FromStr or parse instead")]
+    pub fn from_seckey_str(s: &str) -> Result<Self, Error> { s.parse() }
 
     /// Creates a [`Keypair`] directly from a secret key string and the global [`SECP256K1`] context.
     ///
@@ -922,10 +915,8 @@ impl Keypair {
     /// [`Error::InvalidSecretKey`] if the string does not consist of exactly 64 hex characters,
     /// or if the encoded number is an invalid scalar.
     #[inline]
-    #[cfg(feature = "global-context")]
-    pub fn from_seckey_str_global(s: &str) -> Result<Keypair, Error> {
-        Keypair::from_seckey_str(SECP256K1, s)
-    }
+    #[deprecated(note = "use FromStr or parse instead")]
+    pub fn from_seckey_str_global(s: &str) -> Result<Keypair, Error> { s.parse() }
 
     /// Generates a new random key pair.
     /// # Examples
@@ -1097,10 +1088,11 @@ impl str::FromStr for Keypair {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        crate::with_global_context(
-            |secp: &Secp256k1<AllPreallocated>| Self::from_seckey_str(secp, s),
-            None,
-        )
+        let mut res = [0u8; constants::SECRET_KEY_SIZE];
+        match from_hex(s, &mut res) {
+            Ok(constants::SECRET_KEY_SIZE) => Keypair::from_seckey_byte_array(res),
+            _ => Err(Error::InvalidSecretKey),
+        }
     }
 }
 
@@ -1131,12 +1123,10 @@ impl<'de> serde::Deserialize<'de> for Keypair {
                 "a hex string representing 32 byte Keypair",
             ))
         } else {
-            let visitor = super::serde_util::Tuple32Visitor::new("raw 32 bytes Keypair", |data| {
-                crate::with_global_context(
-                    |secp: &Secp256k1<AllPreallocated>| Self::from_seckey_byte_array(secp, data),
-                    None,
-                )
-            });
+            let visitor = super::serde_util::Tuple32Visitor::new(
+                "raw 32 bytes Keypair",
+                Keypair::from_seckey_byte_array,
+            );
             d.deserialize_tuple(constants::SECRET_KEY_SIZE, visitor)
         }
     }
@@ -1767,10 +1757,9 @@ mod test {
     }
 
     #[test]
-    #[cfg(all(feature = "std", not(secp256k1_fuzz)))]
+    #[cfg(not(secp256k1_fuzz))]
     fn erased_keypair_is_valid() {
-        let s = Secp256k1::new();
-        let kp = Keypair::from_seckey_byte_array(&s, [1u8; constants::SECRET_KEY_SIZE])
+        let kp = Keypair::from_seckey_byte_array([1u8; constants::SECRET_KEY_SIZE])
             .expect("valid secret key");
         let mut kp2 = kp;
         kp2.non_secure_erase();
@@ -2045,24 +2034,21 @@ mod test {
 
         let tweaked_sk = sk.add_tweak(&tweak).unwrap();
         assert_ne!(sk, tweaked_sk); // Make sure we did something.
-        let tweaked_pk = pk.add_exp_tweak(&s, &tweak).unwrap();
+        let tweaked_pk = pk.add_exp_tweak(&tweak).unwrap();
         assert_ne!(pk, tweaked_pk);
 
         assert_eq!(PublicKey::from_secret_key(&s, &tweaked_sk), tweaked_pk);
     }
 
     #[test]
-    #[cfg(feature = "std")]
     fn tweak_add_zero() {
-        let s = Secp256k1::new();
-
         let (sk, pk) = crate::test_random_keypair();
 
         let tweak = Scalar::ZERO;
 
         let tweaked_sk = sk.add_tweak(&tweak).unwrap();
         assert_eq!(sk, tweaked_sk); // Tweak by zero does nothing.
-        let tweaked_pk = pk.add_exp_tweak(&s, &tweak).unwrap();
+        let tweaked_pk = pk.add_exp_tweak(&tweak).unwrap();
         assert_eq!(pk, tweaked_pk);
     }
 
@@ -2107,9 +2093,9 @@ mod test {
         let back_sk = neg.negate();
         assert_eq!(sk, back_sk);
 
-        let neg = pk.negate(&s);
+        let neg = pk.negate();
         assert_ne!(pk, neg);
-        let back_pk = neg.negate(&s);
+        let back_pk = neg.negate();
         assert_eq!(pk, back_pk);
 
         assert_eq!(PublicKey::from_secret_key(&s, &back_sk), pk);
@@ -2367,7 +2353,7 @@ mod test {
         ];
         static SK_STR: &str = "01010101010101010001020304050607ffff0000ffff00006363636363636363";
 
-        let sk = Keypair::from_seckey_byte_array(SECP256K1, SK_BYTES).unwrap();
+        let sk = Keypair::from_seckey_byte_array(SK_BYTES).unwrap();
         #[rustfmt::skip]
         assert_tokens(&sk.compact(), &[
             Token::Tuple{ len: 32 },
@@ -2548,7 +2534,7 @@ mod test {
 
         static PK_STR: &str = "18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166";
 
-        let kp = Keypair::from_seckey_byte_array(crate::SECP256K1, SK_BYTES).unwrap();
+        let kp = Keypair::from_seckey_byte_array(SK_BYTES).unwrap();
         let (pk, _parity) = XOnlyPublicKey::from_keypair(&kp);
 
         #[rustfmt::skip]
@@ -2576,11 +2562,10 @@ mod test {
     }
 
     #[test]
-    #[cfg(all(any(feature = "alloc", feature = "global-context"), feature = "serde"))]
+    #[cfg(feature = "serde")]
     fn test_keypair_deserialize_serde() {
-        let ctx = crate::Secp256k1::new();
         let sec_key_str = "4242424242424242424242424242424242424242424242424242424242424242";
-        let keypair = Keypair::from_seckey_str(&ctx, sec_key_str).unwrap();
+        let keypair = Keypair::from_str(sec_key_str).unwrap();
 
         serde_test::assert_tokens(&keypair.readable(), &[Token::String(sec_key_str)]);
 

src/schnorr.rs

@@ -279,11 +279,9 @@ mod tests {
         let secp = Secp256k1::new();
 
         let msg = hex_32!("E48441762FB75010B2AA31A512B62B4148AA3FB08EB0765D76B252559064A614");
-        let sk = Keypair::from_seckey_str(
-            &secp,
-            "688C77BC2D5AAFF5491CF309D4753B732135470D05B7B2CD21ADD0744FE97BEF",
-        )
-        .unwrap();
+        let sk =
+            Keypair::from_str("688C77BC2D5AAFF5491CF309D4753B732135470D05B7B2CD21ADD0744FE97BEF")
+                .unwrap();
         let aux_rand: [u8; 32] =
             hex_32!("02CCE08E913F22A36C5648D6405A2C7C50106E7AA2F1649E381C7F09D16B80AB");
         let expected_sig = Signature::from_str("6470FD1303DDA4FDA717B9837153C24A6EAB377183FC438F939E0ED2B620E9EE5077C4A8B8DCA28963D772A94F5F0DDF598E1C47C137F91933274C7C3EDADCE8").unwrap();
@@ -378,7 +376,7 @@ mod tests {
     fn test_xonly_key_extraction() {
         let secp = Secp256k1::new();
         let sk_str = "688C77BC2D5AAFF5491CF309D4753B732135470D05B7B2CD21ADD0744FE97BEF";
-        let keypair = Keypair::from_seckey_str(&secp, sk_str).unwrap();
+        let keypair = Keypair::from_str(sk_str).unwrap();
         let sk = SecretKey::from_keypair(&keypair);
         assert_eq!(SecretKey::from_str(sk_str).unwrap(), sk);
         let pk = crate::key::PublicKey::from_keypair(&keypair);
@@ -392,14 +390,13 @@ mod tests {
     fn test_pubkey_display_output() {
         #[cfg(not(secp256k1_fuzz))]
         let pk = {
-            let secp = Secp256k1::new();
             static SK_BYTES: [u8; 32] = [
                 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
                 0x06, 0x07, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x63, 0x63, 0x63, 0x63,
                 0x63, 0x63, 0x63, 0x63,
             ];
 
-            let kp = Keypair::from_seckey_byte_array(&secp, SK_BYTES).expect("sk");
+            let kp = Keypair::from_seckey_byte_array(SK_BYTES).expect("sk");
 
             // In fuzzing mode secret->public key derivation is different, so
             // hard-code the expected result.
@@ -479,7 +476,7 @@ mod tests {
         let s = Secp256k1::new();
 
         let msg = [1; 32];
-        let keypair = Keypair::from_seckey_byte_array(&s, [2; 32]).unwrap();
+        let keypair = Keypair::from_seckey_byte_array([2; 32]).unwrap();
         let aux = [3u8; 32];
         let sig = s.sign_schnorr_with_aux_rand(&msg, &keypair, &aux);
         static SIG_BYTES: [u8; constants::SCHNORR_SIGNATURE_SIZE] = [
@@ -712,7 +709,7 @@ mod tests {
         } in vectors
         {
             if let (Some(secret_key), Some(aux_rand)) = (secret_key, aux_rand) {
-                let keypair = Keypair::from_seckey_byte_array(&secp, secret_key).unwrap();
+                let keypair = Keypair::from_seckey_byte_array(secret_key).unwrap();
                 assert_eq!(keypair.x_only_public_key().0.serialize(), public_key);
                 let sig = secp.sign_schnorr_with_aux_rand(&message, &keypair, &aux_rand);
                 assert_eq!(sig.to_byte_array(), signature);

tests/serde.rs

@@ -4,9 +4,9 @@ extern crate bincode;
 extern crate secp256k1;
 extern crate serde_cbor;
 
-use secp256k1::{musig, PublicKey, SecretKey, XOnlyPublicKey};
 #[cfg(feature = "global-context")]
-use secp256k1::{Keypair, Secp256k1};
+use secp256k1::Keypair;
+use secp256k1::{musig, PublicKey, SecretKey, XOnlyPublicKey};
 
 // Arbitrary key data.
 
@@ -97,8 +97,7 @@ fn bincode_public_key() {
 #[test]
 #[cfg(feature = "global-context")]
 fn bincode_keypair() {
-    let secp = Secp256k1::new();
-    let kp = Keypair::from_seckey_byte_array(&secp, SK_BYTES).expect("failed to create keypair");
+    let kp = Keypair::from_seckey_byte_array(SK_BYTES).expect("failed to create keypair");
     let ser = bincode::serialize(&kp).unwrap();
 
     assert_eq!(ser, SK_BYTES);