fix multiple definition link errors

Author: attente

go-ethereum/crypto/secp256k1/ext.h

@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
-// secp256k1_context_create_sign_verify creates a context for signing and signature verification.
-static secp256k1_context* secp256k1_context_create_sign_verify() {
-	return secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
+// ethkit_secp256k1_context_create_sign_verify creates a context for signing and signature verification.
+static secp256k1_context* ethkit_secp256k1_context_create_sign_verify() {
+	return ethkit_secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
 }
 
 // secp256k1_ext_ecdsa_recover recovers the public key of an encoded compact signature.
@@ -21,17 +21,17 @@ static int secp256k1_ext_ecdsa_recover(
 	const unsigned char *sigdata,
 	const unsigned char *msgdata
 ) {
-	secp256k1_ecdsa_recoverable_signature sig;
+	ethkit_secp256k1_ecdsa_recoverable_signature sig;
 	secp256k1_pubkey pubkey;
 
-	if (!secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &sig, sigdata, (int)sigdata[64])) {
+	if (!ethkit_ethkit_secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &sig, sigdata, (int)sigdata[64])) {
 		return 0;
 	}
-	if (!secp256k1_ecdsa_recover(ctx, &pubkey, &sig, msgdata)) {
+	if (!ethkit_secp256k1_ecdsa_recover(ctx, &pubkey, &sig, msgdata)) {
 		return 0;
 	}
 	size_t outputlen = 65;
-	return secp256k1_ec_pubkey_serialize(ctx, pubkey_out, &outputlen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
+	return ethkit_secp256k1_ec_pubkey_serialize(ctx, pubkey_out, &outputlen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
 }
 
 // secp256k1_ext_ecdsa_verify verifies an encoded compact signature.
@@ -50,16 +50,16 @@ static int secp256k1_ext_ecdsa_verify(
 	const unsigned char *pubkeydata,
 	size_t pubkeylen
 ) {
-	secp256k1_ecdsa_signature sig;
+	ethkit_secp256k1_ecdsa_signature sig;
 	secp256k1_pubkey pubkey;
 
-	if (!secp256k1_ecdsa_signature_parse_compact(ctx, &sig, sigdata)) {
+	if (!ethkit_ethkit_secp256k1_ecdsa_signature_parse_compact(ctx, &sig, sigdata)) {
 		return 0;
 	}
-	if (!secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeydata, pubkeylen)) {
+	if (!ethkit_secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeydata, pubkeylen)) {
 		return 0;
 	}
-	return secp256k1_ecdsa_verify(ctx, &sig, msgdata, &pubkey);
+	return ethkit_secp256k1_ecdsa_verify(ctx, &sig, msgdata, &pubkey);
 }
 
 // secp256k1_ext_reencode_pubkey decodes then encodes a public key. It can be used to
@@ -82,14 +82,14 @@ static int secp256k1_ext_reencode_pubkey(
 ) {
 	secp256k1_pubkey pubkey;
 
-	if (!secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeydata, pubkeylen)) {
+	if (!ethkit_secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeydata, pubkeylen)) {
 		return 0;
 	}
 	unsigned int flag = (outlen == 33) ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED;
-	return secp256k1_ec_pubkey_serialize(ctx, out, &outlen, &pubkey, flag);
+	return ethkit_secp256k1_ec_pubkey_serialize(ctx, out, &outlen, &pubkey, flag);
 }
 
-// secp256k1_ext_scalar_mul multiplies a point by a scalar in constant time.
+// ethkit_secp256k1_ext_scalar_mul multiplies a point by a scalar in constant time.
 //
 // Returns: 1: multiplication was successful
 //          0: scalar was invalid (zero or overflow)
@@ -98,7 +98,7 @@ static int secp256k1_ext_reencode_pubkey(
 //  In:     point:    pointer to a 64-byte public point,
 //                    encoded as two 256bit big-endian numbers.
 //          scalar:   a 32-byte scalar with which to multiply the point
-int secp256k1_ext_scalar_mul(const secp256k1_context* ctx, unsigned char *point, const unsigned char *scalar) {
+int ethkit_secp256k1_ext_scalar_mul(const secp256k1_context* ctx, unsigned char *point, const unsigned char *scalar) {
 	int ret = 0;
 	int overflow = 0;
 	secp256k1_fe feX, feY;

go-ethereum/crypto/secp256k1/libsecp256k1/CHANGELOG.md

@@ -60,7 +60,7 @@ The ABI is backward compatible with versions 0.4.x and 0.3.x.
 
 #### Changed
  - The point multiplication algorithm used for ECDH operations (module `ecdh`) was replaced with a slightly faster one.
- - Optional handwritten x86_64 assembly for field operations was removed because modern C compilers are able to output more efficient assembly. This change results in a significant speedup of some library functions when handwritten x86_64 assembly is enabled (`--with-asm=x86_64` in GNU Autotools, `-DSECP256K1_ASM=x86_64` in CMake), which is the default on x86_64. Benchmarks with GCC 10.5.0 show a 10% speedup for `secp256k1_ecdsa_verify` and `secp256k1_schnorrsig_verify`.
+ - Optional handwritten x86_64 assembly for field operations was removed because modern C compilers are able to output more efficient assembly. This change results in a significant speedup of some library functions when handwritten x86_64 assembly is enabled (`--with-asm=x86_64` in GNU Autotools, `-DSECP256K1_ASM=x86_64` in CMake), which is the default on x86_64. Benchmarks with GCC 10.5.0 show a 10% speedup for `ethkit_secp256k1_ecdsa_verify` and `secp256k1_schnorrsig_verify`.
 
 #### ABI Compatibility
 The ABI is backward compatible with versions 0.4.0 and 0.3.x.
@@ -147,7 +147,7 @@ Due to changes in the API regarding `secp256k1_context_static` described above,
 
 #### Changed
  - Enabled modules `schnorrsig`, `extrakeys` and `ecdh` by default in `./configure`.
- - The `secp256k1_nonce_function_rfc6979` nonce function, used by default by `secp256k1_ecdsa_sign`, now reduces the message hash modulo the group order to match the specification. This only affects improper use of ECDSA signing API.
+ - The `ethkit_secp256k1_nonce_function_rfc6979` nonce function, used by default by `ethkit_secp256k1_ecdsa_sign`, now reduces the message hash modulo the group order to match the specification. This only affects improper use of ECDSA signing API.
 
 #### Deprecated
  - Deprecated context flags `SECP256K1_CONTEXT_VERIFY` and `SECP256K1_CONTEXT_SIGN`. Use `SECP256K1_CONTEXT_NONE` instead.

go-ethereum/crypto/secp256k1/libsecp256k1/CONTRIBUTING.md

@@ -44,7 +44,7 @@ The Contributor Workflow & Peer Review in libsecp256k1 are similar to Bitcoin Co
 
 In addition, libsecp256k1 tries to maintain the following coding conventions:
 
-* No runtime heap allocation (e.g., no `malloc`) unless explicitly requested by the caller (via `secp256k1_context_create` or `secp256k1_scratch_space_create`, for example). Moreover, it should be possible to use the library without any heap allocations.
+* No runtime heap allocation (e.g., no `malloc`) unless explicitly requested by the caller (via `ethkit_secp256k1_context_create` or `secp256k1_scratch_space_create`, for example). Moreover, it should be possible to use the library without any heap allocations.
 * The tests should cover all lines and branches of the library (see [Test coverage](#coverage)).
 * Operations involving secret data should be tested for being constant time with respect to the secrets (see [src/ctime_tests.c](src/ctime_tests.c)).
 * Local variables containing secret data should be cleared explicitly to try to delete secrets from memory.

go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_parsing.c

@@ -8,15 +8,15 @@
 
 #include "lax_der_parsing.h"
 
-int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
+int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, ethkit_secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
     size_t rpos, rlen, spos, slen;
     size_t pos = 0;
     size_t lenbyte;
     unsigned char tmpsig[64] = {0};
     int overflow = 0;
 
     /* Hack to initialize sig with a correctly-parsed but invalid signature. */
-    secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
+    ethkit_ethkit_secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
 
     /* Sequence tag byte */
     if (pos == inputlen || input[pos] != 0x30) {
@@ -137,11 +137,11 @@ int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_
     }
 
     if (!overflow) {
-        overflow = !secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
+        overflow = !ethkit_ethkit_secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
     }
     if (overflow) {
         memset(tmpsig, 0, 64);
-        secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
+        ethkit_ethkit_secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
     }
     return 1;
 }

go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_parsing.h

@@ -26,8 +26,8 @@
  * certain violations are easily supported. You may need to adapt it.
  *
  * Do not use this for new systems. Use well-defined DER or compact signatures
- * instead if you have the choice (see secp256k1_ecdsa_signature_parse_der and
- * secp256k1_ecdsa_signature_parse_compact).
+ * instead if you have the choice (see ethkit_ethkit_secp256k1_ecdsa_signature_parse_der and
+ * ethkit_ethkit_secp256k1_ecdsa_signature_parse_compact).
  *
  * The supported violations are:
  * - All numbers are parsed as nonnegative integers, even though X.609-0207
@@ -85,7 +85,7 @@ extern "C" {
  */
 int ecdsa_signature_parse_der_lax(
     const secp256k1_context* ctx,
-    secp256k1_ecdsa_signature* sig,
+    ethkit_secp256k1_ecdsa_signature* sig,
     const unsigned char *input,
     size_t inputlen
 ) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);

go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_privatekey_parsing.c

@@ -45,7 +45,7 @@ int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *out32, co
         return 0;
     }
     if (privkey[1]) memcpy(out32 + 32 - privkey[1], privkey + 2, privkey[1]);
-    if (!secp256k1_ec_seckey_verify(ctx, out32)) {
+    if (!ethkit_secp256k1_ec_seckey_verify(ctx, out32)) {
         memset(out32, 0, 32);
         return 0;
     }
@@ -55,7 +55,7 @@ int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *out32, co
 int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey, size_t *privkeylen, const unsigned char *key32, int compressed) {
     secp256k1_pubkey pubkey;
     size_t pubkeylen = 0;
-    if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
+    if (!ethkit_secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
         *privkeylen = 0;
         return 0;
     }
@@ -79,7 +79,7 @@ int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey,
         memcpy(ptr, key32, 32); ptr += 32;
         memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
         pubkeylen = 33;
-        secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
+        ethkit_secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
         ptr += pubkeylen;
         *privkeylen = ptr - privkey;
     } else {
@@ -104,7 +104,7 @@ int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey,
         memcpy(ptr, key32, 32); ptr += 32;
         memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
         pubkeylen = 65;
-        secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
+        ethkit_secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
         ptr += pubkeylen;
         *privkeylen = ptr - privkey;
     }

go-ethereum/crypto/secp256k1/libsecp256k1/doc/musig.md

@@ -22,7 +22,7 @@ Therefore, users of the musig module must take great care to make sure of the fo
 ## Key Aggregation and (Taproot) Tweaking
 
 Given a set of public keys, the aggregate public key is computed with `secp256k1_musig_pubkey_agg`.
-A plain tweak can be added to the resulting public key with `secp256k1_ec_pubkey_tweak_add` by setting the `tweak32` argument to the hash defined in BIP 32. Similarly, a Taproot tweak can be added with `secp256k1_xonly_pubkey_tweak_add` by setting the `tweak32` argument to the TapTweak hash defined in BIP 341.
+A plain tweak can be added to the resulting public key with `ethkit_secp256k1_ec_pubkey_tweak_add` by setting the `tweak32` argument to the hash defined in BIP 32. Similarly, a Taproot tweak can be added with `secp256k1_xonly_pubkey_tweak_add` by setting the `tweak32` argument to the TapTweak hash defined in BIP 341.
 Both types of tweaking can be combined and invoked multiple times if the specific application requires it.
 
 ## Signing