Like secp256k1_ecmult_compute_table, but one for both gen and gen*2^128. */

Fill a table 'pre_a' with precomputed odd multiples of a. * pre_a will contain [1*a,3*a,...,(2*n-1)*a], so it needs space for n group elements. *

out_nonce = nonce_pts[0] + b*nonce_pts[1] */

Find an ElligatorSwift encoding (u, t) for point P. * * This is similar secp256k1_ellswift_xelligatorswift_var, except it takes a full group element

Use SHA256 as a PRNG, returning SHA256(hasher || cnt). * * hasher is a SHA256 object to which an incrementing 4-byte counter is written to generate

Set hash state to the BIP340 tagged hash midstate for "bip324_ellswift_xonly_ecdh". */

Set hash state to the BIP340 tagged hash midstate for "secp256k1_ellswift_create". */

Set hash state to the BIP340 tagged hash midstate for "secp256k1_ellswift_encode". */

Decode ElligatorSwift encoding (u, t) to a fraction xn/xd representing a curve X coordinate. */

Try to complete an ElligatorSwift encoding (u, t) for X coordinate x, given u and x. * * There may be up to 8 distinct t values such that (u, t) dec

Decode ElligatorSwift encoding (u, t) to X coordinate. */

Set r to the affine coordinates of Jacobian point (a.x, a.y, 1/zi). */

Constant-time addition for secp256k1_gej points for all inputs (including infinity). Implementation strategy: - Use libsecp256k1's `secp256k1_gej_add_

This function accepts an array arr containing heap_size elements, each of * size stride. The elements in the array at indices >i satisfy the max-heap

Compute the inverse of x modulo modinfo->modulus, and replace x with it (constant time in x). */

Compute a*factor and put it in r. All but the top limb in r will be in range [0,2^30). */

Take as input a signed30 number in range (-2*modulus,modulus), and add a multiple of the modulus * to it to bring it to range [0,modulus). If sign <

Compute (t/2^30) * [d, e] mod modulus, where t is a transition matrix for 30 divsteps. * * On input and output, d and e are in range (-2*modulus,mod

Compute (t/2^30) * [f, g], where t is a transition matrix for 30 divsteps. * * Version that operates on a variable number of limbs in f and g. * *

Compute the inverse of x modulo modinfo->modulus, and replace x with it (variable time). */

Compute the inverse of x modulo modinfo->modulus, and replace x with it (constant time in x). */

Compute a*factor and put it in r. All but the top limb in r will be in range [0,2^62). */

Take as input a signed62 number in range (-2*modulus,modulus), and add a multiple of the modulus * to it to bring it to range [0,modulus). If sign <

Compute (t/2^62) * [d, e] mod modulus, where t is a transition matrix scaled by 2^62. * * On input and output, d and e are in range (-2*modulus,modu

Compute (t/2^62) * [f, g], where t is a transition matrix for 62 divsteps. * * Version that operates on a variable number of limbs in f and g. * *

Compute the inverse of x modulo modinfo->modulus, and replace x with it (variable time). */

Initializes SHA256 with fixed midstate. This midstate was computed by applying * SHA256 to SHA256("MuSig/noncecoef")||SHA256("MuSig/noncecoef"). */

Outputs 33 zero bytes if the given group element is the point at infinity and * otherwise outputs the compressed serialization */

Assumes that pk is not the point at infinity and that the Y-coordinates of pk * and cache_i->second_pk are normalized. */

Compute KeyAgg coefficient which is constant 1 for the second pubkey and * otherwise tagged_hash(pks_hash, pk) where pks_hash is the hash of public k

Initializes SHA256 with fixed midstate. This midstate was computed by applying * SHA256 to SHA256("KeyAgg coefficient")||SHA256("KeyAgg coefficient")

Initializes SHA256 with fixed midstate. This midstate was computed by applying * SHA256 to SHA256("KeyAgg list")||SHA256("KeyAgg list"). */

If flag is true, invalidate the secnonce; otherwise leave it. Constant-time. */

Initializes SHA256 with fixed midstate. This midstate was computed by applying * SHA256 to SHA256("BIP0340/nonce")||SHA256("BIP0340/nonce"). */

Initializes SHA256 with fixed midstate. This midstate was computed by applying * SHA256 to SHA256("BIP0340/aux")||SHA256("BIP0340/aux"). */

Initializes SHA256 with fixed midstate. This midstate was computed by applying * SHA256 to SHA256("MuSig/nonce")||SHA256("MuSig/nonce"). */

Initializes SHA256 with fixed midstate. This midstate was computed by applying * SHA256 to SHA256("MuSig/aux")||SHA256("MuSig/aux"). */

* Returns the maximum number of points in addition to G that can be used with * a given scratch space. The function ensures that fewer points may als

Initializes SHA256 with fixed midstate. This midstate was computed by applying * SHA256 to SHA256("BIP0340/challenge")||SHA256("BIP0340/challenge").

data_transport_i overrides using parallel_id 0

Sets the cardinality of this expectation spec.

Sets the OS stack trace getter. Does nothing if the input and the current OS stack trace getter are the same; otherwise, deletes the old getter and m