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,6 @@ 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;
 
@@ -1305,38 +1304,44 @@ 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]) {
+    // We have no seed here but we want rerandomiziation to happen for `rand` users.
+    let seed = [0_u8; 32];
+    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())
+            },
+            Some(&seed),
+        );
+
+        if ret == 0 {
+            unreachable!("Invalid public keys for sorting function")
         }
     }
 }

src/lib.rs

@@ -202,7 +202,9 @@ pub use crate::{
         Context, PreallocatedContext, SignOnlyPreallocated, Signing, Verification,
         VerifyOnlyPreallocated,
     },
-    key::{InvalidParityValue, Keypair, Parity, PublicKey, SecretKey, XOnlyPublicKey},
+    key::{
+        sort_pubkeys, InvalidParityValue, Keypair, Parity, PublicKey, SecretKey, XOnlyPublicKey,
+    },
     scalar::Scalar,
 };
 

src/musig.rs

@@ -12,6 +12,8 @@ use core::mem::MaybeUninit;
 use std;
 
 use crate::ffi::{self, CPtr};
+#[cfg(doc)]
+use crate::key;
 use crate::{
     from_hex, schnorr, Error, Keypair, PublicKey, Scalar, Secp256k1, SecretKey, XOnlyPublicKey,
 };
@@ -369,7 +371,7 @@ impl KeyAggCache {
     /// ensures the same resulting `agg_pk` for the same multiset of pubkeys.
     /// This is useful to do before aggregating pubkeys, such that the order of pubkeys
     /// does not affect the combined public key.
-    /// To do this, call [`Secp256k1::sort_pubkeys`].
+    /// To do this, call [`key::sort_pubkeys`].
     ///
     /// # Returns
     ///