Remove context sort_pubkeys

Take the `sort_pubkeys` function off of the context and make it stand
alone. Re-export it at the crate root because the `key` module is
private.

Author: tcharding

examples/musig.rs

@@ -4,10 +4,9 @@ use secp256k1::musig::{
     new_nonce_pair, AggregatedNonce, KeyAggCache, PartialSignature, PublicNonce, Session,
     SessionSecretRand,
 };
-use secp256k1::{Keypair, PublicKey, Scalar, Secp256k1, SecretKey};
+use secp256k1::{Keypair, PublicKey, Scalar, SecretKey};
 
 fn main() {
-    let secp = Secp256k1::new();
     let mut rng = rand::rng();
 
     let (seckey1, pubkey1) = secp256k1::generate_keypair(&mut rng);
@@ -19,7 +18,7 @@ fn main() {
     let mut pubkeys_ref: Vec<&PublicKey> = pubkeys.iter().collect();
     let pubkeys_ref = pubkeys_ref.as_mut_slice();
 
-    secp.sort_pubkeys(pubkeys_ref);
+    secp256k1::sort_pubkeys(pubkeys_ref);
 
     let mut musig_key_agg_cache = KeyAggCache::new(pubkeys_ref);
 

src/key/mod.rs

@@ -10,7 +10,7 @@ use core::{fmt, ptr, str};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
-use secp256k1_sys::secp256k1_ec_pubkey_sort;
+
 #[cfg(feature = "serde")]
 use serde::ser::SerializeTuple;
 
@@ -1298,38 +1298,40 @@ impl<'de> serde::Deserialize<'de> for XOnlyPublicKey {
     }
 }
 
-impl<C: Verification> Secp256k1<C> {
-    /// Sort public keys using lexicographic (of compressed serialization) order.
-    ///
-    /// This is the canonical way to sort public keys for use with Musig2.
-    ///
-    /// Example:
-    ///
-    /// ```rust
-    /// # # [cfg(any(test, feature = "rand-std"))] {
-    /// # use secp256k1::rand::{rng, RngCore};
-    /// # use secp256k1::{Secp256k1, SecretKey, Keypair, PublicKey, pubkey_sort};
-    /// # let secp = Secp256k1::new();
-    /// # let sk1 = SecretKey::new(&mut rng());
-    /// # let pub_key1 = PublicKey::from_secret_key(&sk1);
-    /// # let sk2 = SecretKey::new(&mut rng());
-    /// # let pub_key2 = PublicKey::from_secret_key(&sk2);
-    /// #
-    /// # let pubkeys = [pub_key1, pub_key2];
-    /// # let mut pubkeys_ref: Vec<&PublicKey> = pubkeys.iter().collect();
-    /// # let pubkeys_ref = pubkeys_ref.as_mut_slice();
-    /// #
-    /// # secp.sort_pubkeys(pubkeys_ref);
-    /// # }
-    /// ```
-    pub fn sort_pubkeys(&self, pubkeys: &mut [&PublicKey]) {
-        let cx = self.ctx().as_ptr();
-        unsafe {
-            // SAFETY: `PublicKey` has repr(transparent) so we can convert to `ffi::PublicKey`
-            let pubkeys_ptr = pubkeys.as_mut_c_ptr() as *mut *const ffi::PublicKey;
-            if secp256k1_ec_pubkey_sort(cx, pubkeys_ptr, pubkeys.len()) == 0 {
-                unreachable!("Invalid public keys for sorting function")
-            }
+/// Sort public keys using lexicographic (of compressed serialization) order.
+///
+/// This is the canonical way to sort public keys for use with Musig2.
+///
+/// Example:
+///
+/// ```rust
+/// # # [cfg(any(test, feature = "rand-std"))] {
+/// # use secp256k1::rand::{rng, RngCore};
+/// # use secp256k1::{SecretKey, Keypair, PublicKey, pubkey_sort};
+/// # let sk1 = SecretKey::new(&mut rng());
+/// # let pub_key1 = PublicKey::from_secret_key(&sk1);
+/// # let sk2 = SecretKey::new(&mut rng());
+/// # let pub_key2 = PublicKey::from_secret_key(&sk2);
+/// #
+/// # let pubkeys = [pub_key1, pub_key2];
+/// # let mut pubkeys_ref: Vec<&PublicKey> = pubkeys.iter().collect();
+/// # let pubkeys_ref = pubkeys_ref.as_mut_slice();
+/// #
+/// # secp256k1::sort_pubkeys(pubkeys_ref);
+/// # }
+/// ```
+pub fn sort_pubkeys(pubkeys: &mut [&PublicKey]) {
+    unsafe {
+        // SAFETY: `PublicKey` has repr(transparent) so we can convert to `ffi::PublicKey`
+        let pubkeys_ptr = pubkeys.as_mut_c_ptr() as *mut *const ffi::PublicKey;
+
+        let ret = crate::with_global_context(
+            |secp: &Secp256k1<crate::AllPreallocated>| ffi::secp256k1_ec_pubkey_sort(secp.ctx.as_ptr(), pubkeys_ptr, pubkeys.len()),
+            None,               // FIXME: What goes here.
+        );
+
+        if ret == 0 {
+            unreachable!("Invalid public keys for sorting function")
         }
     }
 }

src/lib.rs

@@ -197,7 +197,7 @@ pub use crate::context::{
 pub use crate::context::{All, SignOnly, VerifyOnly};
 use crate::ffi::types::AlignedType;
 use crate::ffi::CPtr;
-pub use crate::key::{InvalidParityValue, Keypair, Parity, PublicKey, SecretKey, XOnlyPublicKey};
+pub use crate::key::{sort_pubkeys, InvalidParityValue, Keypair, Parity, PublicKey, SecretKey, XOnlyPublicKey};
 pub use crate::scalar::Scalar;
 
 /// Trait describing something that promises to be a 32-byte uniformly random number.