key: move pubkey_sort to method on Secp256k1; rename

This feels more natural as `secp.musig_sort_pubkeys` rather than `musig::pubkey_sort.

Author: apoelstra

examples/musig.rs

@@ -4,7 +4,7 @@ use secp256k1::musig::{
     new_nonce_pair, AggregatedNonce, KeyAggCache, PartialSignature, PublicNonce, Session,
     SessionSecretRand,
 };
-use secp256k1::{pubkey_sort, Keypair, Message, PublicKey, Scalar, Secp256k1, SecretKey};
+use secp256k1::{Keypair, Message, PublicKey, Scalar, Secp256k1, SecretKey};
 
 fn main() {
     let secp = Secp256k1::new();
@@ -19,7 +19,7 @@ fn main() {
     let mut pubkeys_ref: Vec<&PublicKey> = pubkeys.iter().collect();
     let pubkeys_ref = pubkeys_ref.as_mut_slice();
 
-    pubkey_sort(&secp, pubkeys_ref);
+    secp.musig_sort_pubkeys(pubkeys_ref);
 
     let mut musig_key_agg_cache = KeyAggCache::new(&secp, pubkeys_ref);
 

src/key.rs

@@ -1617,35 +1617,38 @@ impl<'de> serde::Deserialize<'de> for XOnlyPublicKey {
     }
 }
 
-/// Sort public keys using lexicographic (of compressed serialization) order.
-/// 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(&secp, &sk1);
-/// # let sk2 = SecretKey::new(&mut rng());
-/// # let pub_key2 = PublicKey::from_secret_key(&secp, &sk2);
-/// #
-/// # let pubkeys = [pub_key1, pub_key2];
-/// # let mut pubkeys_ref: Vec<&PublicKey> = pubkeys.iter().collect();
-/// # let pubkeys_ref = pubkeys_ref.as_mut_slice();
-/// #
-/// # pubkey_sort(&secp, pubkeys_ref);
-/// # }
-/// ```
-pub fn pubkey_sort<C: Verification>(secp: &Secp256k1<C>, pubkeys: &mut [&PublicKey]) {
-    let cx = secp.ctx().as_ptr();
-    unsafe {
-        let mut pubkeys_ref = core::slice::from_raw_parts(
-            pubkeys.as_c_ptr() as *mut *const ffi::PublicKey,
-            pubkeys.len(),
-        );
-        if secp256k1_ec_pubkey_sort(cx, pubkeys_ref.as_mut_c_ptr(), pubkeys_ref.len()) == 0 {
-            unreachable!("Invalid public keys for sorting function")
+impl<C: Verification> Secp256k1<C> {
+    /// Sort public keys using lexicographic (of compressed serialization) order.
+    ///
+    /// 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(&secp, &sk1);
+    /// # let sk2 = SecretKey::new(&mut rng());
+    /// # let pub_key2 = PublicKey::from_secret_key(&secp, &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.musig_sort_pubkeys(pubkeys_ref);
+    /// # }
+    /// ```
+    pub fn musig_sort_pubkeys(&self, pubkeys: &mut [&PublicKey]) {
+        let cx = self.ctx().as_ptr();
+        unsafe {
+            let mut pubkeys_ref = core::slice::from_raw_parts(
+                pubkeys.as_c_ptr() as *mut *const ffi::PublicKey,
+                pubkeys.len(),
+            );
+            if secp256k1_ec_pubkey_sort(cx, pubkeys_ref.as_mut_c_ptr(), pubkeys_ref.len()) == 0 {
+                unreachable!("Invalid public keys for sorting function")
+            }
         }
     }
 }

src/lib.rs

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