fixup! rename pubkey_sort -> ec_pubkey_sort

for consistency with other "ec_pubkey" functions
bitcoin-core · Mar 9, 2024 · dfd9849 · dfd9849
1 parent d3a8952
commit dfd9849
Show file tree

Hide file tree

Showing 4 changed files with 17 additions and 17 deletions.
diff --git a/include/secp256k1.h b/include/secp256k1.h
@@ -482,7 +482,7 @@ SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_cmp(
  *  In:   pubkeys: array of pointers to pubkeys to sort
  *      n_pubkeys: number of elements in the pubkeys array
  */
-SECP256K1_API int secp256k1_pubkey_sort(
+SECP256K1_API int secp256k1_ec_pubkey_sort(
     const secp256k1_context *ctx,
     const secp256k1_pubkey **pubkeys,
     size_t n_pubkeys

diff --git a/include/secp256k1_musig.h b/include/secp256k1_musig.h
@@ -184,7 +184,7 @@ SECP256K1_API int secp256k1_musig_partial_sig_parse(
  *
  *  Different orders of `pubkeys` result in different `agg_pk`s.
  *
- *  Before aggregating, the pubkeys can be sorted with `secp256k1_pubkey_sort`
+ *  Before aggregating, the pubkeys can be sorted with `secp256k1_ec_pubkey_sort`
  *  which ensures the same `agg_pk` result for the same multiset of pubkeys.
  *  This is useful to do before `pubkey_agg`, such that the order of pubkeys
  *  does not affect the aggregate public key.

diff --git a/src/secp256k1.c b/src/secp256k1.c
@@ -318,16 +318,16 @@ int secp256k1_ec_pubkey_cmp(const secp256k1_context* ctx, const secp256k1_pubkey
  * which expects a non-const cmp_data pointer. */
 typedef struct {
     const secp256k1_context *ctx;
-} secp256k1_pubkey_sort_cmp_data;
+} secp256k1_ec_pubkey_sort_cmp_data;
 
-static int secp256k1_pubkey_sort_cmp(const void* pk1, const void* pk2, void *cmp_data) {
-    return secp256k1_ec_pubkey_cmp(((secp256k1_pubkey_sort_cmp_data*)cmp_data)->ctx,
+static int secp256k1_ec_pubkey_sort_cmp(const void* pk1, const void* pk2, void *cmp_data) {
+    return secp256k1_ec_pubkey_cmp(((secp256k1_ec_pubkey_sort_cmp_data*)cmp_data)->ctx,
                                      *(secp256k1_pubkey **)pk1,
                                      *(secp256k1_pubkey **)pk2);
 }
 
-int secp256k1_pubkey_sort(const secp256k1_context* ctx, const secp256k1_pubkey **pubkeys, size_t n_pubkeys) {
-    secp256k1_pubkey_sort_cmp_data cmp_data;
+int secp256k1_ec_pubkey_sort(const secp256k1_context* ctx, const secp256k1_pubkey **pubkeys, size_t n_pubkeys) {
+    secp256k1_ec_pubkey_sort_cmp_data cmp_data;
     VERIFY_CHECK(ctx != NULL);
     ARG_CHECK(pubkeys != NULL);
 
@@ -339,7 +339,7 @@ int secp256k1_pubkey_sort(const secp256k1_context* ctx, const secp256k1_pubkey *
     #pragma warning(disable: 4090)
     #endif
 
-    secp256k1_hsort(pubkeys, n_pubkeys, sizeof(*pubkeys), secp256k1_pubkey_sort_cmp, &cmp_data);
+    secp256k1_hsort(pubkeys, n_pubkeys, sizeof(*pubkeys), secp256k1_ec_pubkey_sort_cmp, &cmp_data);
 
     #if defined(_MSC_VER) && (_MSC_VER < 1933)
     #pragma warning(pop)

diff --git a/src/tests.c b/src/tests.c
@@ -6661,7 +6661,7 @@ static void test_sort_helper(secp256k1_pubkey *pk, size_t *pk_order, size_t n_pk
     for (i = 0; i < n_pk; i++) {
         pk_test[i] = &pk[pk_order[i]];
     }
-    secp256k1_pubkey_sort(CTX, pk_test, n_pk);
+    secp256k1_ec_pubkey_sort(CTX, pk_test, n_pk);
     for (i = 0; i < n_pk; i++) {
         CHECK(secp256k1_memcmp_var(pk_test[i], &pk[i], sizeof(*pk_test[i])) == 0);
     }
@@ -6696,17 +6696,17 @@ static void test_sort_api(void) {
     rand_pk(&pks[0]);
     rand_pk(&pks[1]);
 
-    CHECK(secp256k1_pubkey_sort(CTX, pks_ptr, 2) == 1);
-    CHECK_ILLEGAL(CTX, secp256k1_pubkey_sort(CTX, NULL, 2));
-    CHECK(secp256k1_pubkey_sort(CTX, pks_ptr, 0) == 1);
+    CHECK(secp256k1_ec_pubkey_sort(CTX, pks_ptr, 2) == 1);
+    CHECK_ILLEGAL(CTX, secp256k1_ec_pubkey_sort(CTX, NULL, 2));
+    CHECK(secp256k1_ec_pubkey_sort(CTX, pks_ptr, 0) == 1);
     /* Test illegal public keys */
     memset(&pks[0], 0, sizeof(pks[0]));
-    CHECK_ILLEGAL_VOID(CTX, CHECK(secp256k1_pubkey_sort(CTX, pks_ptr, 2) == 1));
+    CHECK_ILLEGAL_VOID(CTX, CHECK(secp256k1_ec_pubkey_sort(CTX, pks_ptr, 2) == 1));
     memset(&pks[1], 0, sizeof(pks[1]));
     {
         int32_t ecount = 0;
         secp256k1_context_set_illegal_callback(CTX, counting_callback_fn, &ecount);
-        CHECK(secp256k1_pubkey_sort(CTX, pks_ptr, 2) == 1);
+        CHECK(secp256k1_ec_pubkey_sort(CTX, pks_ptr, 2) == 1);
         CHECK(ecount == 2);
         secp256k1_context_set_illegal_callback(CTX, NULL, NULL);
     }
@@ -6750,9 +6750,9 @@ static void test_sort(void) {
             rand_pk(&pk[j]);
             pk_ptr[j] = &pk[j];
         }
-        secp256k1_pubkey_sort(CTX, pk_ptr, 5);
+        secp256k1_ec_pubkey_sort(CTX, pk_ptr, 5);
         for (j = 1; j < 5; j++) {
-            CHECK(secp256k1_pubkey_sort_cmp(&pk_ptr[j - 1], &pk_ptr[j], CTX) <= 0);
+            CHECK(secp256k1_ec_pubkey_sort_cmp(&pk_ptr[j - 1], &pk_ptr[j], CTX) <= 0);
         }
     }
 }
@@ -6796,7 +6796,7 @@ static void test_sort_vectors(void) {
         CHECK(secp256k1_ec_pubkey_parse(CTX, &pubkeys[i], pk_ser[i], sizeof(pk_ser[i])));
         pks_ptr[i] = &pubkeys[i];
     }
-    CHECK(secp256k1_pubkey_sort(CTX, pks_ptr, N_PUBKEYS) == 1);
+    CHECK(secp256k1_ec_pubkey_sort(CTX, pks_ptr, N_PUBKEYS) == 1);
     for (i = 0; i < N_PUBKEYS; i++) {
         CHECK(secp256k1_memcmp_var(pks_ptr[i], sorted[i], sizeof(secp256k1_pubkey)) == 0);
     }