@qntx/nostr-native 0.0.0-stage → 0.12.1

package/vendor/secp256k1/src/ecdsa_impl.h

@@ -0,0 +1,309 @@
+/***********************************************************************
+ * Copyright (c) 2013-2015 Pieter Wuille                               *
+ * Distributed under the MIT software license, see the accompanying    *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
+ ***********************************************************************/
+
+
+#ifndef SECP256K1_ECDSA_IMPL_H
+#define SECP256K1_ECDSA_IMPL_H
+
+#include "scalar.h"
+#include "field.h"
+#include "group.h"
+#include "ecmult.h"
+#include "ecmult_gen.h"
+#include "ecdsa.h"
+
+/** Group order for secp256k1 defined as 'n' in "Standards for Efficient Cryptography" (SEC2) 2.7.1
+ *  $ sage -c 'load("nostr_native_secp256k1_params.sage"); print(hex(N))'
+ *  0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
+ */
+static const nostr_native_secp256k1_fe nostr_native_secp256k1_ecdsa_const_order_as_fe = SECP256K1_FE_CONST(
+    0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
+    0xBAAEDCE6UL, 0xAF48A03BUL, 0xBFD25E8CUL, 0xD0364141UL
+);
+
+/** Difference between field and order, values 'p' and 'n' values defined in
+ *  "Standards for Efficient Cryptography" (SEC2) 2.7.1.
+ *  $ sage -c 'load("nostr_native_secp256k1_params.sage"); print(hex(P-N))'
+ *  0x14551231950b75fc4402da1722fc9baee
+ */
+static const nostr_native_secp256k1_fe nostr_native_secp256k1_ecdsa_const_p_minus_order = SECP256K1_FE_CONST(
+    0, 0, 0, 1, 0x45512319UL, 0x50B75FC4UL, 0x402DA172UL, 0x2FC9BAEEUL
+);
+
+static int nostr_native_secp256k1_der_read_len(size_t *len, const unsigned char **sigp, const unsigned char *sigend) {
+    size_t lenleft;
+    unsigned char b1;
+    VERIFY_CHECK(len != NULL);
+    *len = 0;
+    if (*sigp >= sigend) {
+        return 0;
+    }
+    b1 = *((*sigp)++);
+    if (b1 == 0xFF) {
+        /* X.690-0207 8.1.3.5.c the value 0xFF shall not be used. */
+        return 0;
+    }
+    if ((b1 & 0x80) == 0) {
+        /* X.690-0207 8.1.3.4 short form length octets */
+        *len = b1;
+        return 1;
+    }
+    if (b1 == 0x80) {
+        /* Indefinite length is not allowed in DER. */
+        return 0;
+    }
+    /* X.690-207 8.1.3.5 long form length octets */
+    lenleft = b1 & 0x7F; /* lenleft is at least 1 */
+    if (lenleft > (size_t)(sigend - *sigp)) {
+        return 0;
+    }
+    if (**sigp == 0) {
+        /* Not the shortest possible length encoding. */
+        return 0;
+    }
+    if (lenleft > sizeof(size_t)) {
+        /* The resulting length would exceed the range of a size_t, so
+         * it is certainly longer than the passed array size. */
+        return 0;
+    }
+    while (lenleft > 0) {
+        *len = (*len << 8) | **sigp;
+        (*sigp)++;
+        lenleft--;
+    }
+    if (*len > (size_t)(sigend - *sigp)) {
+        /* Result exceeds the length of the passed array.
+           (Checking this is the responsibility of the caller but it
+           can't hurt do it here, too.) */
+        return 0;
+    }
+    if (*len < 128) {
+        /* Not the shortest possible length encoding. */
+        return 0;
+    }
+    return 1;
+}
+
+static int nostr_native_secp256k1_der_parse_integer(nostr_native_secp256k1_scalar *r, const unsigned char **sig, const unsigned char *sigend) {
+    int overflow = 0;
+    unsigned char ra[32] = {0};
+    size_t rlen;
+
+    if (*sig == sigend || **sig != 0x02) {
+        /* Not a primitive integer (X.690-0207 8.3.1). */
+        return 0;
+    }
+    (*sig)++;
+    if (nostr_native_secp256k1_der_read_len(&rlen, sig, sigend) == 0) {
+        return 0;
+    }
+    if (rlen == 0 || rlen > (size_t)(sigend - *sig)) {
+        /* Exceeds bounds or not at least length 1 (X.690-0207 8.3.1).  */
+        return 0;
+    }
+    if (**sig == 0x00 && rlen > 1 && (((*sig)[1]) & 0x80) == 0x00) {
+        /* Excessive 0x00 padding. */
+        return 0;
+    }
+    if (**sig == 0xFF && rlen > 1 && (((*sig)[1]) & 0x80) == 0x80) {
+        /* Excessive 0xFF padding. */
+        return 0;
+    }
+    if ((**sig & 0x80) == 0x80) {
+        /* Negative. */
+        overflow = 1;
+    }
+    /* There is at most one leading zero byte:
+     * if there were two leading zero bytes, we would have failed and returned 0
+     * because of excessive 0x00 padding already. */
+    if (rlen > 0 && **sig == 0) {
+        /* Skip leading zero byte */
+        rlen--;
+        (*sig)++;
+    }
+    if (rlen > 32) {
+        overflow = 1;
+    }
+    if (!overflow) {
+        if (rlen) memcpy(ra + 32 - rlen, *sig, rlen);
+        nostr_native_secp256k1_scalar_set_b32(r, ra, &overflow);
+    }
+    if (overflow) {
+        nostr_native_secp256k1_scalar_set_int(r, 0);
+    }
+    (*sig) += rlen;
+    return 1;
+}
+
+static int nostr_native_secp256k1_ecdsa_sig_parse(nostr_native_secp256k1_scalar *rr, nostr_native_secp256k1_scalar *rs, const unsigned char *sig, size_t size) {
+    const unsigned char *sigend = sig + size;
+    size_t rlen;
+    if (sig == sigend || *(sig++) != 0x30) {
+        /* The encoding doesn't start with a constructed sequence (X.690-0207 8.9.1). */
+        return 0;
+    }
+    if (nostr_native_secp256k1_der_read_len(&rlen, &sig, sigend) == 0) {
+        return 0;
+    }
+    if (rlen != (size_t)(sigend - sig)) {
+        /* Tuple exceeds bounds or garage after tuple. */
+        return 0;
+    }
+
+    if (!nostr_native_secp256k1_der_parse_integer(rr, &sig, sigend)) {
+        return 0;
+    }
+    if (!nostr_native_secp256k1_der_parse_integer(rs, &sig, sigend)) {
+        return 0;
+    }
+
+    if (sig != sigend) {
+        /* Trailing garbage inside tuple. */
+        return 0;
+    }
+
+    return 1;
+}
+
+static int nostr_native_secp256k1_ecdsa_sig_serialize(unsigned char *sig, size_t *size, const nostr_native_secp256k1_scalar* ar, const nostr_native_secp256k1_scalar* as) {
+    unsigned char r[33] = {0}, s[33] = {0};
+    unsigned char *rp = r, *sp = s;
+    size_t lenR = 33, lenS = 33;
+    nostr_native_secp256k1_scalar_get_b32(&r[1], ar);
+    nostr_native_secp256k1_scalar_get_b32(&s[1], as);
+    while (lenR > 1 && rp[0] == 0 && rp[1] < 0x80) { lenR--; rp++; }
+    while (lenS > 1 && sp[0] == 0 && sp[1] < 0x80) { lenS--; sp++; }
+    if (*size < 6+lenS+lenR) {
+        *size = 6 + lenS + lenR;
+        return 0;
+    }
+    *size = 6 + lenS + lenR;
+    sig[0] = 0x30;
+    sig[1] = 4 + lenS + lenR;
+    sig[2] = 0x02;
+    sig[3] = lenR;
+    memcpy(sig+4, rp, lenR);
+    sig[4+lenR] = 0x02;
+    sig[5+lenR] = lenS;
+    memcpy(sig+lenR+6, sp, lenS);
+    return 1;
+}
+
+static int nostr_native_secp256k1_ecdsa_sig_verify(const nostr_native_secp256k1_scalar *sigr, const nostr_native_secp256k1_scalar *sigs, const nostr_native_secp256k1_ge *pubkey, const nostr_native_secp256k1_scalar *message) {
+    unsigned char c[32];
+    nostr_native_secp256k1_scalar sn, u1, u2;
+#if !defined(EXHAUSTIVE_TEST_ORDER)
+    int range;
+    nostr_native_secp256k1_fe xr;
+#endif
+    nostr_native_secp256k1_gej pubkeyj;
+    nostr_native_secp256k1_gej pr;
+
+    if (nostr_native_secp256k1_scalar_is_zero(sigr) || nostr_native_secp256k1_scalar_is_zero(sigs)) {
+        return 0;
+    }
+
+    nostr_native_secp256k1_scalar_inverse_var(&sn, sigs);
+    nostr_native_secp256k1_scalar_mul(&u1, &sn, message);
+    nostr_native_secp256k1_scalar_mul(&u2, &sn, sigr);
+    nostr_native_secp256k1_gej_set_ge(&pubkeyj, pubkey);
+    nostr_native_secp256k1_ecmult(&pr, &pubkeyj, &u2, &u1);
+    if (nostr_native_secp256k1_gej_is_infinity(&pr)) {
+        return 0;
+    }
+
+#if defined(EXHAUSTIVE_TEST_ORDER)
+{
+    nostr_native_secp256k1_scalar computed_r;
+    nostr_native_secp256k1_ge pr_ge;
+    nostr_native_secp256k1_ge_set_gej(&pr_ge, &pr);
+    nostr_native_secp256k1_fe_normalize(&pr_ge.x);
+
+    nostr_native_secp256k1_fe_get_b32(c, &pr_ge.x);
+    nostr_native_secp256k1_scalar_set_b32(&computed_r, c, NULL);
+    return nostr_native_secp256k1_scalar_eq(sigr, &computed_r);
+}
+#else
+
+    /* Interpret sigr as a field element xr  */
+    nostr_native_secp256k1_scalar_get_b32(c, sigr);
+    range = nostr_native_secp256k1_fe_set_b32_limit(&xr, c);
+#ifdef VERIFY
+    /* We know that c is in range; it comes from a scalar. */
+    VERIFY_CHECK(range);
+#else
+    (void)range;
+#endif
+
+    /** We now have the recomputed R point in pr, and its claimed x coordinate (modulo n)
+     *  in xr. Naively, we would extract the x coordinate from pr (requiring a inversion modulo p),
+     *  compute the remainder modulo n, and compare it to xr. However:
+     *
+     *        xr == X(pr) mod n
+     *    <=> exists h. (xr + h * n < p && xr + h * n == X(pr))
+     *    [Since 2 * n > p, h can only be 0 or 1]
+     *    <=> (xr == X(pr)) || (xr + n < p && xr + n == X(pr))
+     *    [In Jacobian coordinates, X(pr) is pr.x / pr.z^2 mod p]
+     *    <=> (xr == pr.x / pr.z^2 mod p) || (xr + n < p && xr + n == pr.x / pr.z^2 mod p)
+     *    [Multiplying both sides of the equations by pr.z^2 mod p]
+     *    <=> (xr * pr.z^2 mod p == pr.x) || (xr + n < p && (xr + n) * pr.z^2 mod p == pr.x)
+     *
+     *  Thus, we can avoid the inversion, but we have to check both cases separately.
+     *  nostr_native_secp256k1_gej_eq_x implements the (xr * pr.z^2 mod p == pr.x) test.
+     */
+    if (nostr_native_secp256k1_gej_eq_x_var(&xr, &pr)) {
+        /* xr * pr.z^2 mod p == pr.x, so the signature is valid. */
+        return 1;
+    }
+    if (nostr_native_secp256k1_fe_cmp_var(&xr, &nostr_native_secp256k1_ecdsa_const_p_minus_order) >= 0) {
+        /* xr + n >= p, so we can skip testing the second case. */
+        return 0;
+    }
+    nostr_native_secp256k1_fe_add(&xr, &nostr_native_secp256k1_ecdsa_const_order_as_fe);
+    if (nostr_native_secp256k1_gej_eq_x_var(&xr, &pr)) {
+        /* (xr + n) * pr.z^2 mod p == pr.x, so the signature is valid. */
+        return 1;
+    }
+    return 0;
+#endif
+}
+
+static int nostr_native_secp256k1_ecdsa_sig_sign(const nostr_native_secp256k1_ecmult_gen_context *ctx, nostr_native_secp256k1_scalar *sigr, nostr_native_secp256k1_scalar *sigs, const nostr_native_secp256k1_scalar *seckey, const nostr_native_secp256k1_scalar *message, const nostr_native_secp256k1_scalar *nonce, int *recid) {
+    unsigned char b[32];
+    nostr_native_secp256k1_ge r;
+    nostr_native_secp256k1_scalar n;
+    int overflow = 0;
+    int high;
+
+    nostr_native_secp256k1_ecmult_gen_ge(ctx, &r, nonce);
+    nostr_native_secp256k1_fe_normalize(&r.x);
+    nostr_native_secp256k1_fe_normalize(&r.y);
+    nostr_native_secp256k1_fe_get_b32(b, &r.x);
+    nostr_native_secp256k1_scalar_set_b32(sigr, b, &overflow);
+    if (recid) {
+        /* The overflow condition is cryptographically unreachable as hitting it requires finding the discrete log
+         * of some P where P.x >= order, and only 1 in about 2^127 points meet this criteria.
+         */
+        *recid = (overflow << 1) | nostr_native_secp256k1_fe_is_odd(&r.y);
+    }
+    nostr_native_secp256k1_scalar_mul(&n, sigr, seckey);
+    nostr_native_secp256k1_scalar_add(&n, &n, message);
+    nostr_native_secp256k1_scalar_inverse(sigs, nonce);
+    nostr_native_secp256k1_scalar_mul(sigs, sigs, &n);
+    nostr_native_secp256k1_scalar_clear(&n);
+    nostr_native_secp256k1_ge_clear(&r);
+    high = nostr_native_secp256k1_scalar_is_high(sigs);
+    nostr_native_secp256k1_scalar_cond_negate(sigs, high);
+    if (recid) {
+        *recid ^= high;
+    }
+    /* P.x = order is on the curve, so technically sig->r could end up being zero, which would be an invalid signature.
+     * This is cryptographically unreachable as hitting it requires finding the discrete log of P.x = N.
+     */
+    return (int)(!nostr_native_secp256k1_scalar_is_zero(sigr)) & (int)(!nostr_native_secp256k1_scalar_is_zero(sigs));
+}
+
+#endif /* SECP256K1_ECDSA_IMPL_H */

package/vendor/secp256k1/src/eckey.h

@@ -0,0 +1,28 @@
+/***********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille                              *
+ * Distributed under the MIT software license, see the accompanying    *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
+ ***********************************************************************/
+
+#ifndef SECP256K1_ECKEY_H
+#define SECP256K1_ECKEY_H
+
+#include <stddef.h>
+
+#include "group.h"
+#include "scalar.h"
+#include "ecmult.h"
+#include "ecmult_gen.h"
+
+static int nostr_native_secp256k1_eckey_pubkey_parse(nostr_native_secp256k1_ge *elem, const unsigned char *pub, size_t size);
+/** Serialize a group element (that is not allowed to be infinity) to a compressed public key (33 bytes). */
+static void nostr_native_secp256k1_eckey_pubkey_serialize33(nostr_native_secp256k1_ge *elem, unsigned char *pub33);
+/** Serialize a group element (that is not allowed to be infinity) to an uncompressed public key (65 bytes). */
+static void nostr_native_secp256k1_eckey_pubkey_serialize65(nostr_native_secp256k1_ge *elem, unsigned char *pub65);
+
+static int nostr_native_secp256k1_eckey_privkey_tweak_add(nostr_native_secp256k1_scalar *key, const nostr_native_secp256k1_scalar *tweak);
+static int nostr_native_secp256k1_eckey_pubkey_tweak_add(nostr_native_secp256k1_ge *key, const nostr_native_secp256k1_scalar *tweak);
+static int nostr_native_secp256k1_eckey_privkey_tweak_mul(nostr_native_secp256k1_scalar *key, const nostr_native_secp256k1_scalar *tweak);
+static int nostr_native_secp256k1_eckey_pubkey_tweak_mul(nostr_native_secp256k1_ge *key, const nostr_native_secp256k1_scalar *tweak);
+
+#endif /* SECP256K1_ECKEY_H */

package/vendor/secp256k1/src/eckey_impl.h

@@ -0,0 +1,94 @@
+/***********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille                              *
+ * Distributed under the MIT software license, see the accompanying    *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
+ ***********************************************************************/
+
+#ifndef SECP256K1_ECKEY_IMPL_H
+#define SECP256K1_ECKEY_IMPL_H
+
+#include "eckey.h"
+
+#include "util.h"
+#include "scalar.h"
+#include "field.h"
+#include "group.h"
+#include "ecmult_gen.h"
+
+static int nostr_native_secp256k1_eckey_pubkey_parse(nostr_native_secp256k1_ge *elem, const unsigned char *pub, size_t size) {
+    if (size == 33 && (pub[0] == SECP256K1_TAG_PUBKEY_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_ODD)) {
+        nostr_native_secp256k1_fe x;
+        return nostr_native_secp256k1_fe_set_b32_limit(&x, pub+1) && nostr_native_secp256k1_ge_set_xo_var(elem, &x, pub[0] == SECP256K1_TAG_PUBKEY_ODD);
+    } else if (size == 65 && (pub[0] == SECP256K1_TAG_PUBKEY_UNCOMPRESSED || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD)) {
+        nostr_native_secp256k1_fe x, y;
+        if (!nostr_native_secp256k1_fe_set_b32_limit(&x, pub+1) || !nostr_native_secp256k1_fe_set_b32_limit(&y, pub+33)) {
+            return 0;
+        }
+        nostr_native_secp256k1_ge_set_xy(elem, &x, &y);
+        if ((pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD) &&
+            nostr_native_secp256k1_fe_is_odd(&y) != (pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD)) {
+            return 0;
+        }
+        return nostr_native_secp256k1_ge_is_valid_var(elem);
+    } else {
+        return 0;
+    }
+}
+
+static void nostr_native_secp256k1_eckey_pubkey_serialize33(nostr_native_secp256k1_ge *elem, unsigned char *pub33) {
+    VERIFY_CHECK(!nostr_native_secp256k1_ge_is_infinity(elem));
+
+    nostr_native_secp256k1_fe_normalize_var(&elem->x);
+    nostr_native_secp256k1_fe_normalize_var(&elem->y);
+    pub33[0] = nostr_native_secp256k1_fe_is_odd(&elem->y) ? SECP256K1_TAG_PUBKEY_ODD : SECP256K1_TAG_PUBKEY_EVEN;
+    nostr_native_secp256k1_fe_get_b32(&pub33[1], &elem->x);
+}
+
+static void nostr_native_secp256k1_eckey_pubkey_serialize65(nostr_native_secp256k1_ge *elem, unsigned char *pub65) {
+    VERIFY_CHECK(!nostr_native_secp256k1_ge_is_infinity(elem));
+
+    nostr_native_secp256k1_fe_normalize_var(&elem->x);
+    nostr_native_secp256k1_fe_normalize_var(&elem->y);
+    pub65[0] = SECP256K1_TAG_PUBKEY_UNCOMPRESSED;
+    nostr_native_secp256k1_fe_get_b32(&pub65[1], &elem->x);
+    nostr_native_secp256k1_fe_get_b32(&pub65[33], &elem->y);
+}
+
+static int nostr_native_secp256k1_eckey_privkey_tweak_add(nostr_native_secp256k1_scalar *key, const nostr_native_secp256k1_scalar *tweak) {
+    nostr_native_secp256k1_scalar_add(key, key, tweak);
+    return !nostr_native_secp256k1_scalar_is_zero(key);
+}
+
+static int nostr_native_secp256k1_eckey_pubkey_tweak_add(nostr_native_secp256k1_ge *key, const nostr_native_secp256k1_scalar *tweak) {
+    nostr_native_secp256k1_gej pt;
+    nostr_native_secp256k1_gej_set_ge(&pt, key);
+    nostr_native_secp256k1_ecmult(&pt, &pt, &nostr_native_secp256k1_scalar_one, tweak);
+
+    if (nostr_native_secp256k1_gej_is_infinity(&pt)) {
+        return 0;
+    }
+    nostr_native_secp256k1_ge_set_gej(key, &pt);
+    return 1;
+}
+
+static int nostr_native_secp256k1_eckey_privkey_tweak_mul(nostr_native_secp256k1_scalar *key, const nostr_native_secp256k1_scalar *tweak) {
+    int ret;
+    ret = !nostr_native_secp256k1_scalar_is_zero(tweak);
+
+    nostr_native_secp256k1_scalar_mul(key, key, tweak);
+    return ret;
+}
+
+static int nostr_native_secp256k1_eckey_pubkey_tweak_mul(nostr_native_secp256k1_ge *key, const nostr_native_secp256k1_scalar *tweak) {
+    nostr_native_secp256k1_gej pt;
+    if (nostr_native_secp256k1_scalar_is_zero(tweak)) {
+        return 0;
+    }
+
+    nostr_native_secp256k1_gej_set_ge(&pt, key);
+    nostr_native_secp256k1_ecmult(&pt, &pt, tweak, NULL);
+    nostr_native_secp256k1_ge_set_gej(key, &pt);
+    return 1;
+}
+
+#endif /* SECP256K1_ECKEY_IMPL_H */

package/vendor/secp256k1/src/ecmult.h

@@ -0,0 +1,64 @@
+/***********************************************************************
+ * Copyright (c) 2013, 2014, 2017 Pieter Wuille, Andrew Poelstra       *
+ * Distributed under the MIT software license, see the accompanying    *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
+ ***********************************************************************/
+
+#ifndef SECP256K1_ECMULT_H
+#define SECP256K1_ECMULT_H
+
+#include "group.h"
+#include "scalar.h"
+#include "scratch.h"
+
+#ifndef ECMULT_WINDOW_SIZE
+#  define ECMULT_WINDOW_SIZE 15
+#  ifdef DEBUG_CONFIG
+#     pragma message DEBUG_CONFIG_MSG("ECMULT_WINDOW_SIZE undefined, assuming default value")
+#  endif
+#endif
+
+#ifdef DEBUG_CONFIG
+#  pragma message DEBUG_CONFIG_DEF(ECMULT_WINDOW_SIZE)
+#endif
+
+/* No one will ever need more than a window size of 24. The code might
+ * be correct for larger values of ECMULT_WINDOW_SIZE but this is not
+ * tested.
+ *
+ * The following limitations are known, and there are probably more:
+ * If WINDOW_G > 27 and size_t has 32 bits, then the code is incorrect
+ * because the size of the memory object that we allocate (in bytes)
+ * will not fit in a size_t.
+ * If WINDOW_G > 31 and int has 32 bits, then the code is incorrect
+ * because certain expressions will overflow.
+ */
+#if ECMULT_WINDOW_SIZE < 2 || ECMULT_WINDOW_SIZE > 24
+#  error Set ECMULT_WINDOW_SIZE to an integer in range [2..24].
+#endif
+
+/** The number of entries a table with precomputed multiples needs to have. */
+#define ECMULT_TABLE_SIZE(w) ((size_t)1 << ((w)-2))
+
+/** Double multiply: R = na*A + ng*G
+ *
+ * Passing NULL as ng is equivalent to the zero scalar but a tiny bit faster.
+ */
+static void nostr_native_secp256k1_ecmult(nostr_native_secp256k1_gej *r, const nostr_native_secp256k1_gej *a, const nostr_native_secp256k1_scalar *na, const nostr_native_secp256k1_scalar *ng);
+
+typedef int (nostr_native_secp256k1_ecmult_multi_callback)(nostr_native_secp256k1_scalar *sc, nostr_native_secp256k1_ge *pt, size_t idx, void *data);
+
+/**
+ * Multi-multiply: R = inp_g_sc * G + sum_i ni * Ai.
+ * Chooses the right algorithm for a given number of points and scratch space
+ * size. Resets and overwrites the given scratch space. If the points do not
+ * fit in the scratch space the algorithm is repeatedly run with batches of
+ * points. If no scratch space is given then a simple algorithm is used that
+ * simply multiplies the points with the corresponding scalars and adds them up.
+ * Returns: 1 on success (including when inp_g_sc is NULL and n is 0)
+ *          0 if there is not enough scratch space for a single point or
+ *          callback returns 0
+ */
+static int nostr_native_secp256k1_ecmult_multi_var(const nostr_native_secp256k1_callback* error_callback, nostr_native_secp256k1_scratch *scratch, nostr_native_secp256k1_gej *r, const nostr_native_secp256k1_scalar *inp_g_sc, nostr_native_secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n);
+
+#endif /* SECP256K1_ECMULT_H */

package/vendor/secp256k1/src/ecmult_compute_table.h

@@ -0,0 +1,16 @@
+/*****************************************************************************************************
+ * Copyright (c) 2013, 2014, 2017, 2021 Pieter Wuille, Andrew Poelstra, Jonas Nick, Russell O'Connor *
+ * Distributed under the MIT software license, see the accompanying                                  *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.                              *
+ *****************************************************************************************************/
+
+#ifndef SECP256K1_ECMULT_COMPUTE_TABLE_H
+#define SECP256K1_ECMULT_COMPUTE_TABLE_H
+
+/* Construct table of all odd multiples of gen in range 1..(2**(window_g-1)-1). */
+static void nostr_native_secp256k1_ecmult_compute_table(nostr_native_secp256k1_ge_storage* table, int window_g, const nostr_native_secp256k1_gej* gen);
+
+/* Like nostr_native_secp256k1_ecmult_compute_table, but one for both gen and gen*2^128. */
+static void nostr_native_secp256k1_ecmult_compute_two_tables(nostr_native_secp256k1_ge_storage* table, nostr_native_secp256k1_ge_storage* table_128, int window_g, const nostr_native_secp256k1_ge* gen);
+
+#endif /* SECP256K1_ECMULT_COMPUTE_TABLE_H */

package/vendor/secp256k1/src/ecmult_compute_table_impl.h

@@ -0,0 +1,49 @@
+/*****************************************************************************************************
+ * Copyright (c) 2013, 2014, 2017, 2021 Pieter Wuille, Andrew Poelstra, Jonas Nick, Russell O'Connor *
+ * Distributed under the MIT software license, see the accompanying                                  *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.                              *
+ *****************************************************************************************************/
+
+#ifndef SECP256K1_ECMULT_COMPUTE_TABLE_IMPL_H
+#define SECP256K1_ECMULT_COMPUTE_TABLE_IMPL_H
+
+#include "ecmult_compute_table.h"
+#include "group_impl.h"
+#include "field_impl.h"
+#include "ecmult.h"
+#include "util.h"
+
+static void nostr_native_secp256k1_ecmult_compute_table(nostr_native_secp256k1_ge_storage* table, int window_g, const nostr_native_secp256k1_gej* gen) {
+    nostr_native_secp256k1_gej gj;
+    nostr_native_secp256k1_ge ge, dgen;
+    size_t j;
+
+    gj = *gen;
+    nostr_native_secp256k1_ge_set_gej_var(&ge, &gj);
+    nostr_native_secp256k1_ge_to_storage(&table[0], &ge);
+
+    nostr_native_secp256k1_gej_double_var(&gj, gen, NULL);
+    nostr_native_secp256k1_ge_set_gej_var(&dgen, &gj);
+
+    for (j = 1; j < ECMULT_TABLE_SIZE(window_g); ++j) {
+        nostr_native_secp256k1_gej_set_ge(&gj, &ge);
+        nostr_native_secp256k1_gej_add_ge_var(&gj, &gj, &dgen, NULL);
+        nostr_native_secp256k1_ge_set_gej_var(&ge, &gj);
+        nostr_native_secp256k1_ge_to_storage(&table[j], &ge);
+    }
+}
+
+/* Like nostr_native_secp256k1_ecmult_compute_table, but one for both gen and gen*2^128. */
+static void nostr_native_secp256k1_ecmult_compute_two_tables(nostr_native_secp256k1_ge_storage* table, nostr_native_secp256k1_ge_storage* table_128, int window_g, const nostr_native_secp256k1_ge* gen) {
+    nostr_native_secp256k1_gej gj;
+    int i;
+
+    nostr_native_secp256k1_gej_set_ge(&gj, gen);
+    nostr_native_secp256k1_ecmult_compute_table(table, window_g, &gj);
+    for (i = 0; i < 128; ++i) {
+        nostr_native_secp256k1_gej_double_var(&gj, &gj, NULL);
+    }
+    nostr_native_secp256k1_ecmult_compute_table(table_128, window_g, &gj);
+}
+
+#endif /* SECP256K1_ECMULT_COMPUTE_TABLE_IMPL_H */

package/vendor/secp256k1/src/ecmult_const.h

@@ -0,0 +1,38 @@
+/***********************************************************************
+ * Copyright (c) 2015 Andrew Poelstra                                  *
+ * Distributed under the MIT software license, see the accompanying    *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
+ ***********************************************************************/
+
+#ifndef SECP256K1_ECMULT_CONST_H
+#define SECP256K1_ECMULT_CONST_H
+
+#include "scalar.h"
+#include "group.h"
+
+/**
+ * Multiply: R = q*A (in constant-time for q)
+ */
+static void nostr_native_secp256k1_ecmult_const(nostr_native_secp256k1_gej *r, const nostr_native_secp256k1_ge *a, const nostr_native_secp256k1_scalar *q);
+
+/**
+ * Same as nostr_native_secp256k1_ecmult_const, but takes in an x coordinate of the base point
+ * only, specified as fraction n/d (numerator/denominator). Only the x coordinate of the result is
+ * returned.
+ *
+ * If known_on_curve is 0, a verification is performed that n/d is a valid X
+ * coordinate, and 0 is returned if not. Otherwise, 1 is returned.
+ *
+ * d being NULL is interpreted as d=1. If non-NULL, d must not be zero. q must not be zero.
+ *
+ * Constant time in the value of q, but not any other inputs.
+ */
+static int nostr_native_secp256k1_ecmult_const_xonly(
+    nostr_native_secp256k1_fe *r,
+    const nostr_native_secp256k1_fe *n,
+    const nostr_native_secp256k1_fe *d,
+    const nostr_native_secp256k1_scalar *q,
+    int known_on_curve
+);
+
+#endif /* SECP256K1_ECMULT_CONST_H */