{"version":3,"file":"static/chunks/1629-7e25e53343128469.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@noble/curves/esm/abstract/curve.js","webpack://_N_E/./node_modules/@noble/curves/esm/abstract/modular.js","webpack://_N_E/./node_modules/@noble/curves/esm/abstract/utils.js","webpack://_N_E/./node_modules/@noble/hashes/esm/hmac.js","webpack://_N_E/./node_modules/@noble/curves/esm/abstract/weierstrass.js","webpack://_N_E/./node_modules/@noble/curves/esm/_shortw_utils.js","webpack://_N_E/./node_modules/@noble/curves/esm/secp256k1.js"],"sourcesContent":["/**\n * Methods for elliptic curve multiplication by scalars.\n * Contains wNAF, pippenger\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { nLength, validateField } from './modular.js';\nimport { bitLen, validateObject } from './utils.js';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nfunction constTimeNegate(condition, item) {\n    const neg = item.negate();\n    return condition ? neg : item;\n}\nfunction validateW(W, bits) {\n    if (!Number.isSafeInteger(W) || W <= 0 || W > bits)\n        throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);\n}\nfunction calcWOpts(W, bits) {\n    validateW(W, bits);\n    const windows = Math.ceil(bits / W) + 1; // +1, because\n    const windowSize = 2 ** (W - 1); // -1 because we skip zero\n    return { windows, windowSize };\n}\nfunction validateMSMPoints(points, c) {\n    if (!Array.isArray(points))\n        throw new Error('array expected');\n    points.forEach((p, i) => {\n        if (!(p instanceof c))\n            throw new Error('invalid point at index ' + i);\n    });\n}\nfunction validateMSMScalars(scalars, field) {\n    if (!Array.isArray(scalars))\n        throw new Error('array of scalars expected');\n    scalars.forEach((s, i) => {\n        if (!field.isValid(s))\n            throw new Error('invalid scalar at index ' + i);\n    });\n}\n// Since points in different groups cannot be equal (different object constructor),\n// we can have single place to store precomputes\nconst pointPrecomputes = new WeakMap();\nconst pointWindowSizes = new WeakMap(); // This allows use make points immutable (nothing changes inside)\nfunction getW(P) {\n    return pointWindowSizes.get(P) || 1;\n}\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Scalars should always be less than curve order: this should be checked inside of a curve itself.\n * Creates precomputation tables for fast multiplication:\n * - private scalar is split by fixed size windows of W bits\n * - every window point is collected from window's table & added to accumulator\n * - since windows are different, same point inside tables won't be accessed more than once per calc\n * - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n * - +1 window is neccessary for wNAF\n * - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n *\n * @todo Research returning 2d JS array of windows, instead of a single window.\n * This would allow windows to be in different memory locations\n */\nexport function wNAF(c, bits) {\n    return {\n        constTimeNegate,\n        hasPrecomputes(elm) {\n            return getW(elm) !== 1;\n        },\n        // non-const time multiplication ladder\n        unsafeLadder(elm, n, p = c.ZERO) {\n            let d = elm;\n            while (n > _0n) {\n                if (n & _1n)\n                    p = p.add(d);\n                d = d.double();\n                n >>= _1n;\n            }\n            return p;\n        },\n        /**\n         * Creates a wNAF precomputation window. Used for caching.\n         * Default window size is set by `utils.precompute()` and is equal to 8.\n         * Number of precomputed points depends on the curve size:\n         * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n         * - 𝑊 is the window size\n         * - 𝑛 is the bitlength of the curve order.\n         * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n         * @param elm Point instance\n         * @param W window size\n         * @returns precomputed point tables flattened to a single array\n         */\n        precomputeWindow(elm, W) {\n            const { windows, windowSize } = calcWOpts(W, bits);\n            const points = [];\n            let p = elm;\n            let base = p;\n            for (let window = 0; window < windows; window++) {\n                base = p;\n                points.push(base);\n                // =1, because we skip zero\n                for (let i = 1; i < windowSize; i++) {\n                    base = base.add(p);\n                    points.push(base);\n                }\n                p = base.double();\n            }\n            return points;\n        },\n        /**\n         * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @returns real and fake (for const-time) points\n         */\n        wNAF(W, precomputes, n) {\n            // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise\n            // But need to carefully remove other checks before wNAF. ORDER == bits here\n            const { windows, windowSize } = calcWOpts(W, bits);\n            let p = c.ZERO;\n            let f = c.BASE;\n            const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n            const maxNumber = 2 ** W;\n            const shiftBy = BigInt(W);\n            for (let window = 0; window < windows; window++) {\n                const offset = window * windowSize;\n                // Extract W bits.\n                let wbits = Number(n & mask);\n                // Shift number by W bits.\n                n >>= shiftBy;\n                // If the bits are bigger than max size, we'll split those.\n                // +224 => 256 - 32\n                if (wbits > windowSize) {\n                    wbits -= maxNumber;\n                    n += _1n;\n                }\n                // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n                // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n                // there is negate now: it is possible that negated element from low value\n                // would be the same as high element, which will create carry into next window.\n                // It's not obvious how this can fail, but still worth investigating later.\n                // Check if we're onto Zero point.\n                // Add random point inside current window to f.\n                const offset1 = offset;\n                const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero\n                const cond1 = window % 2 !== 0;\n                const cond2 = wbits < 0;\n                if (wbits === 0) {\n                    // The most important part for const-time getPublicKey\n                    f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n                }\n                else {\n                    p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n                }\n            }\n            // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()\n            // Even if the variable is still unused, there are some checks which will\n            // throw an exception, so compiler needs to prove they won't happen, which is hard.\n            // At this point there is a way to F be infinity-point even if p is not,\n            // which makes it less const-time: around 1 bigint multiply.\n            return { p, f };\n        },\n        /**\n         * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @param acc accumulator point to add result of multiplication\n         * @returns point\n         */\n        wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {\n            const { windows, windowSize } = calcWOpts(W, bits);\n            const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n            const maxNumber = 2 ** W;\n            const shiftBy = BigInt(W);\n            for (let window = 0; window < windows; window++) {\n                const offset = window * windowSize;\n                if (n === _0n)\n                    break; // No need to go over empty scalar\n                // Extract W bits.\n                let wbits = Number(n & mask);\n                // Shift number by W bits.\n                n >>= shiftBy;\n                // If the bits are bigger than max size, we'll split those.\n                // +224 => 256 - 32\n                if (wbits > windowSize) {\n                    wbits -= maxNumber;\n                    n += _1n;\n                }\n                if (wbits === 0)\n                    continue;\n                let curr = precomputes[offset + Math.abs(wbits) - 1]; // -1 because we skip zero\n                if (wbits < 0)\n                    curr = curr.negate();\n                // NOTE: by re-using acc, we can save a lot of additions in case of MSM\n                acc = acc.add(curr);\n            }\n            return acc;\n        },\n        getPrecomputes(W, P, transform) {\n            // Calculate precomputes on a first run, reuse them after\n            let comp = pointPrecomputes.get(P);\n            if (!comp) {\n                comp = this.precomputeWindow(P, W);\n                if (W !== 1)\n                    pointPrecomputes.set(P, transform(comp));\n            }\n            return comp;\n        },\n        wNAFCached(P, n, transform) {\n            const W = getW(P);\n            return this.wNAF(W, this.getPrecomputes(W, P, transform), n);\n        },\n        wNAFCachedUnsafe(P, n, transform, prev) {\n            const W = getW(P);\n            if (W === 1)\n                return this.unsafeLadder(P, n, prev); // For W=1 ladder is ~x2 faster\n            return this.wNAFUnsafe(W, this.getPrecomputes(W, P, transform), n, prev);\n        },\n        // We calculate precomputes for elliptic curve point multiplication\n        // using windowed method. This specifies window size and\n        // stores precomputed values. Usually only base point would be precomputed.\n        setWindowSize(P, W) {\n            validateW(W, bits);\n            pointWindowSizes.set(P, W);\n            pointPrecomputes.delete(P);\n        },\n    };\n}\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster with precomputes.\n * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.\n * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @param scalars array of L scalars (aka private keys / bigints)\n */\nexport function pippenger(c, fieldN, points, scalars) {\n    // If we split scalars by some window (let's say 8 bits), every chunk will only\n    // take 256 buckets even if there are 4096 scalars, also re-uses double.\n    // TODO:\n    // - https://eprint.iacr.org/2024/750.pdf\n    // - https://tches.iacr.org/index.php/TCHES/article/view/10287\n    // 0 is accepted in scalars\n    validateMSMPoints(points, c);\n    validateMSMScalars(scalars, fieldN);\n    if (points.length !== scalars.length)\n        throw new Error('arrays of points and scalars must have equal length');\n    const zero = c.ZERO;\n    const wbits = bitLen(BigInt(points.length));\n    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1; // in bits\n    const MASK = (1 << windowSize) - 1;\n    const buckets = new Array(MASK + 1).fill(zero); // +1 for zero array\n    const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;\n    let sum = zero;\n    for (let i = lastBits; i >= 0; i -= windowSize) {\n        buckets.fill(zero);\n        for (let j = 0; j < scalars.length; j++) {\n            const scalar = scalars[j];\n            const wbits = Number((scalar >> BigInt(i)) & BigInt(MASK));\n            buckets[wbits] = buckets[wbits].add(points[j]);\n        }\n        let resI = zero; // not using this will do small speed-up, but will lose ct\n        // Skip first bucket, because it is zero\n        for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {\n            sumI = sumI.add(buckets[j]);\n            resI = resI.add(sumI);\n        }\n        sum = sum.add(resI);\n        if (i !== 0)\n            for (let j = 0; j < windowSize; j++)\n                sum = sum.double();\n    }\n    return sum;\n}\n/**\n * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @returns function which multiplies points with scaars\n */\nexport function precomputeMSMUnsafe(c, fieldN, points, windowSize) {\n    /**\n     * Performance Analysis of Window-based Precomputation\n     *\n     * Base Case (256-bit scalar, 8-bit window):\n     * - Standard precomputation requires:\n     *   - 31 additions per scalar × 256 scalars = 7,936 ops\n     *   - Plus 255 summary additions = 8,191 total ops\n     *   Note: Summary additions can be optimized via accumulator\n     *\n     * Chunked Precomputation Analysis:\n     * - Using 32 chunks requires:\n     *   - 255 additions per chunk\n     *   - 256 doublings\n     *   - Total: (255 × 32) + 256 = 8,416 ops\n     *\n     * Memory Usage Comparison:\n     * Window Size | Standard Points | Chunked Points\n     * ------------|-----------------|---------------\n     *     4-bit   |     520         |      15\n     *     8-bit   |    4,224        |     255\n     *    10-bit   |   13,824        |   1,023\n     *    16-bit   |  557,056        |  65,535\n     *\n     * Key Advantages:\n     * 1. Enables larger window sizes due to reduced memory overhead\n     * 2. More efficient for smaller scalar counts:\n     *    - 16 chunks: (16 × 255) + 256 = 4,336 ops\n     *    - ~2x faster than standard 8,191 ops\n     *\n     * Limitations:\n     * - Not suitable for plain precomputes (requires 256 constant doublings)\n     * - Performance degrades with larger scalar counts:\n     *   - Optimal for ~256 scalars\n     *   - Less efficient for 4096+ scalars (Pippenger preferred)\n     */\n    validateW(windowSize, fieldN.BITS);\n    validateMSMPoints(points, c);\n    const zero = c.ZERO;\n    const tableSize = 2 ** windowSize - 1; // table size (without zero)\n    const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item\n    const MASK = BigInt((1 << windowSize) - 1);\n    const tables = points.map((p) => {\n        const res = [];\n        for (let i = 0, acc = p; i < tableSize; i++) {\n            res.push(acc);\n            acc = acc.add(p);\n        }\n        return res;\n    });\n    return (scalars) => {\n        validateMSMScalars(scalars, fieldN);\n        if (scalars.length > points.length)\n            throw new Error('array of scalars must be smaller than array of points');\n        let res = zero;\n        for (let i = 0; i < chunks; i++) {\n            // No need to double if accumulator is still zero.\n            if (res !== zero)\n                for (let j = 0; j < windowSize; j++)\n                    res = res.double();\n            const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);\n            for (let j = 0; j < scalars.length; j++) {\n                const n = scalars[j];\n                const curr = Number((n >> shiftBy) & MASK);\n                if (!curr)\n                    continue; // skip zero scalars chunks\n                res = res.add(tables[j][curr - 1]);\n            }\n        }\n        return res;\n    };\n}\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\n//# sourceMappingURL=curve.js.map","/**\n * Utils for modular division and finite fields.\n * A finite field over 11 is integer number operations `mod 11`.\n * There is no division: it is replaced by modular multiplicative inverse.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { bitMask, bytesToNumberBE, bytesToNumberLE, ensureBytes, numberToBytesBE, numberToBytesLE, validateObject, } from './utils.js';\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3);\n// prettier-ignore\nconst _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5), _8n = /* @__PURE__ */ BigInt(8);\n// prettier-ignore\nconst _9n = /* @__PURE__ */ BigInt(9), _16n = /* @__PURE__ */ BigInt(16);\n// Calculates a modulo b\nexport function mod(a, b) {\n    const result = a % b;\n    return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @todo use field version && remove\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\nexport function pow(num, power, modulo) {\n    if (power < _0n)\n        throw new Error('invalid exponent, negatives unsupported');\n    if (modulo <= _0n)\n        throw new Error('invalid modulus');\n    if (modulo === _1n)\n        return _0n;\n    let res = _1n;\n    while (power > _0n) {\n        if (power & _1n)\n            res = (res * num) % modulo;\n        num = (num * num) % modulo;\n        power >>= _1n;\n    }\n    return res;\n}\n/** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */\nexport function pow2(x, power, modulo) {\n    let res = x;\n    while (power-- > _0n) {\n        res *= res;\n        res %= modulo;\n    }\n    return res;\n}\n/**\n * Inverses number over modulo.\n * Implemented using [Euclidean GCD](https://brilliant.org/wiki/extended-euclidean-algorithm/).\n */\nexport function invert(number, modulo) {\n    if (number === _0n)\n        throw new Error('invert: expected non-zero number');\n    if (modulo <= _0n)\n        throw new Error('invert: expected positive modulus, got ' + modulo);\n    // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n    let a = mod(number, modulo);\n    let b = modulo;\n    // prettier-ignore\n    let x = _0n, y = _1n, u = _1n, v = _0n;\n    while (a !== _0n) {\n        // JIT applies optimization if those two lines follow each other\n        const q = b / a;\n        const r = b % a;\n        const m = x - u * q;\n        const n = y - v * q;\n        // prettier-ignore\n        b = a, a = r, x = u, y = v, u = m, v = n;\n    }\n    const gcd = b;\n    if (gcd !== _1n)\n        throw new Error('invert: does not exist');\n    return mod(x, modulo);\n}\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * Will start an infinite loop if field order P is not prime.\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P) {\n    // Legendre constant: used to calculate Legendre symbol (a | p),\n    // which denotes the value of a^((p-1)/2) (mod p).\n    // (a | p) ≡ 1    if a is a square (mod p)\n    // (a | p) ≡ -1   if a is not a square (mod p)\n    // (a | p) ≡ 0    if a ≡ 0 (mod p)\n    const legendreC = (P - _1n) / _2n;\n    let Q, S, Z;\n    // Step 1: By factoring out powers of 2 from p - 1,\n    // find q and s such that p - 1 = q*(2^s) with q odd\n    for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++)\n        ;\n    // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq\n    for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++) {\n        // Crash instead of infinity loop, we cannot reasonable count until P.\n        if (Z > 1000)\n            throw new Error('Cannot find square root: likely non-prime P');\n    }\n    // Fast-path\n    if (S === 1) {\n        const p1div4 = (P + _1n) / _4n;\n        return function tonelliFast(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Slow-path\n    const Q1div2 = (Q + _1n) / _2n;\n    return function tonelliSlow(Fp, n) {\n        // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1\n        if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))\n            throw new Error('Cannot find square root');\n        let r = S;\n        // TODO: will fail at Fp2/etc\n        let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b\n        let x = Fp.pow(n, Q1div2); // first guess at the square root\n        let b = Fp.pow(n, Q); // first guess at the fudge factor\n        while (!Fp.eql(b, Fp.ONE)) {\n            if (Fp.eql(b, Fp.ZERO))\n                return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)\n            // Find m such b^(2^m)==1\n            let m = 1;\n            for (let t2 = Fp.sqr(b); m < r; m++) {\n                if (Fp.eql(t2, Fp.ONE))\n                    break;\n                t2 = Fp.sqr(t2); // t2 *= t2\n            }\n            // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow\n            const ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)\n            g = Fp.sqr(ge); // g = ge * ge\n            x = Fp.mul(x, ge); // x *= ge\n            b = Fp.mul(b, g); // b *= g\n            r = m;\n        }\n        return x;\n    };\n}\n/**\n * Square root for a finite field. It will try to check if optimizations are applicable and fall back to 4:\n *\n * 1. P ≡ 3 (mod 4)\n * 2. P ≡ 5 (mod 8)\n * 3. P ≡ 9 (mod 16)\n * 4. Tonelli-Shanks algorithm\n *\n * Different algorithms can give different roots, it is up to user to decide which one they want.\n * For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n */\nexport function FpSqrt(P) {\n    // P ≡ 3 (mod 4)\n    // √n = n^((P+1)/4)\n    if (P % _4n === _3n) {\n        // Not all roots possible!\n        // const ORDER =\n        //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;\n        // const NUM = 72057594037927816n;\n        const p1div4 = (P + _1n) / _4n;\n        return function sqrt3mod4(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            // Throw if root**2 != n\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)\n    if (P % _8n === _5n) {\n        const c1 = (P - _5n) / _8n;\n        return function sqrt5mod8(Fp, n) {\n            const n2 = Fp.mul(n, _2n);\n            const v = Fp.pow(n2, c1);\n            const nv = Fp.mul(n, v);\n            const i = Fp.mul(Fp.mul(nv, _2n), v);\n            const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // P ≡ 9 (mod 16)\n    if (P % _16n === _9n) {\n        // NOTE: tonelli is too slow for bls-Fp2 calculations even on start\n        // Means we cannot use sqrt for constants at all!\n        //\n        // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n        // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n        // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n        // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic\n        // sqrt = (x) => {\n        //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4\n        //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1\n        //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1\n        //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1\n        //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x\n        //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x\n        //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n        //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n        //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x\n        //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2\n        // }\n    }\n    // Other cases: Tonelli-Shanks algorithm\n    return tonelliShanks(P);\n}\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;\n// prettier-ignore\nconst FIELD_FIELDS = [\n    'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n    'eql', 'add', 'sub', 'mul', 'pow', 'div',\n    'addN', 'subN', 'mulN', 'sqrN'\n];\nexport function validateField(field) {\n    const initial = {\n        ORDER: 'bigint',\n        MASK: 'bigint',\n        BYTES: 'isSafeInteger',\n        BITS: 'isSafeInteger',\n    };\n    const opts = FIELD_FIELDS.reduce((map, val) => {\n        map[val] = 'function';\n        return map;\n    }, initial);\n    return validateObject(field, opts);\n}\n// Generic field functions\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow(f, num, power) {\n    // Should have same speed as pow for bigints\n    // TODO: benchmark!\n    if (power < _0n)\n        throw new Error('invalid exponent, negatives unsupported');\n    if (power === _0n)\n        return f.ONE;\n    if (power === _1n)\n        return num;\n    let p = f.ONE;\n    let d = num;\n    while (power > _0n) {\n        if (power & _1n)\n            p = f.mul(p, d);\n        d = f.sqr(d);\n        power >>= _1n;\n    }\n    return p;\n}\n/**\n * Efficiently invert an array of Field elements.\n * `inv(0)` will return `undefined` here: make sure to throw an error.\n */\nexport function FpInvertBatch(f, nums) {\n    const tmp = new Array(nums.length);\n    // Walk from first to last, multiply them by each other MOD p\n    const lastMultiplied = nums.reduce((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = acc;\n        return f.mul(acc, num);\n    }, f.ONE);\n    // Invert last element\n    const inverted = f.inv(lastMultiplied);\n    // Walk from last to first, multiply them by inverted each other MOD p\n    nums.reduceRight((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = f.mul(acc, tmp[i]);\n        return f.mul(acc, num);\n    }, inverted);\n    return tmp;\n}\nexport function FpDiv(f, lhs, rhs) {\n    return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));\n}\n/**\n * Legendre symbol.\n * * (a | p) ≡ 1    if a is a square (mod p), quadratic residue\n * * (a | p) ≡ -1   if a is not a square (mod p), quadratic non residue\n * * (a | p) ≡ 0    if a ≡ 0 (mod p)\n */\nexport function FpLegendre(order) {\n    const legendreConst = (order - _1n) / _2n; // Integer arithmetic\n    return (f, x) => f.pow(x, legendreConst);\n}\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare(f) {\n    const legendre = FpLegendre(f.ORDER);\n    return (x) => {\n        const p = legendre(f, x);\n        return f.eql(p, f.ZERO) || f.eql(p, f.ONE);\n    };\n}\n// CURVE.n lengths\nexport function nLength(n, nBitLength) {\n    // Bit size, byte size of CURVE.n\n    const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n    const nByteLength = Math.ceil(_nBitLength / 8);\n    return { nBitLength: _nBitLength, nByteLength };\n}\n/**\n * Initializes a finite field over prime.\n * Major performance optimizations:\n * * a) denormalized operations like mulN instead of mul\n * * b) same object shape: never add or remove keys\n * * c) Object.freeze\n * Fragile: always run a benchmark on a change.\n * Security note: operations don't check 'isValid' for all elements for performance reasons,\n * it is caller responsibility to check this.\n * This is low-level code, please make sure you know what you're doing.\n * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER, bitLen, isLE = false, redef = {}) {\n    if (ORDER <= _0n)\n        throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);\n    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n    if (BYTES > 2048)\n        throw new Error('invalid field: expected ORDER of <= 2048 bytes');\n    let sqrtP; // cached sqrtP\n    const f = Object.freeze({\n        ORDER,\n        isLE,\n        BITS,\n        BYTES,\n        MASK: bitMask(BITS),\n        ZERO: _0n,\n        ONE: _1n,\n        create: (num) => mod(num, ORDER),\n        isValid: (num) => {\n            if (typeof num !== 'bigint')\n                throw new Error('invalid field element: expected bigint, got ' + typeof num);\n            return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n        },\n        is0: (num) => num === _0n,\n        isOdd: (num) => (num & _1n) === _1n,\n        neg: (num) => mod(-num, ORDER),\n        eql: (lhs, rhs) => lhs === rhs,\n        sqr: (num) => mod(num * num, ORDER),\n        add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n        sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n        mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n        pow: (num, power) => FpPow(f, num, power),\n        div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n        // Same as above, but doesn't normalize\n        sqrN: (num) => num * num,\n        addN: (lhs, rhs) => lhs + rhs,\n        subN: (lhs, rhs) => lhs - rhs,\n        mulN: (lhs, rhs) => lhs * rhs,\n        inv: (num) => invert(num, ORDER),\n        sqrt: redef.sqrt ||\n            ((n) => {\n                if (!sqrtP)\n                    sqrtP = FpSqrt(ORDER);\n                return sqrtP(f, n);\n            }),\n        invertBatch: (lst) => FpInvertBatch(f, lst),\n        // TODO: do we really need constant cmov?\n        // We don't have const-time bigints anyway, so probably will be not very useful\n        cmov: (a, b, c) => (c ? b : a),\n        toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n        fromBytes: (bytes) => {\n            if (bytes.length !== BYTES)\n                throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);\n            return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n        },\n    });\n    return Object.freeze(f);\n}\nexport function FpSqrtOdd(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(\"Field doesn't have isOdd\");\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? root : Fp.neg(root);\n}\nexport function FpSqrtEven(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(\"Field doesn't have isOdd\");\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use `mapKeyToField` instead\n */\nexport function hashToPrivateScalar(hash, groupOrder, isLE = false) {\n    hash = ensureBytes('privateHash', hash);\n    const hashLen = hash.length;\n    const minLen = nLength(groupOrder).nByteLength + 8;\n    if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n        throw new Error('hashToPrivateScalar: expected ' + minLen + '-1024 bytes of input, got ' + hashLen);\n    const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n    return mod(num, groupOrder - _1n) + _1n;\n}\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder) {\n    if (typeof fieldOrder !== 'bigint')\n        throw new Error('field order must be bigint');\n    const bitLength = fieldOrder.toString(2).length;\n    return Math.ceil(bitLength / 8);\n}\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder) {\n    const length = getFieldBytesLength(fieldOrder);\n    return length + Math.ceil(length / 2);\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n    const len = key.length;\n    const fieldLen = getFieldBytesLength(fieldOrder);\n    const minLen = getMinHashLength(fieldOrder);\n    // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n    if (len < 16 || len < minLen || len > 1024)\n        throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);\n    const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);\n    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n    const reduced = mod(num, fieldOrder - _1n) + _1n;\n    return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n//# sourceMappingURL=modular.js.map","/**\n * Hex, bytes and number utilities.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\nexport function abytes(item) {\n    if (!isBytes(item))\n        throw new Error('Uint8Array expected');\n}\nexport function abool(title, value) {\n    if (typeof value !== 'boolean')\n        throw new Error(title + ' boolean expected, got ' + value);\n}\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\nexport function numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? '0' + hex : hex;\n}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    abytes(bytes);\n    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n, len) {\n    return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n    return hexToBytes(numberToHexUnpadded(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes(hex);\n        }\n        catch (e) {\n            throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);\n        }\n    }\n    else if (isBytes(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(title + ' must be hex string or Uint8Array');\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);\n    return res;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a, b) {\n    if (a.length !== b.length)\n        return false;\n    let diff = 0;\n    for (let i = 0; i < a.length; i++)\n        diff |= a[i] ^ b[i];\n    return diff === 0;\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n// Is positive bigint\nconst isPosBig = (n) => typeof n === 'bigint' && _0n <= n;\nexport function inRange(n, min, max) {\n    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;\n}\n/**\n * Asserts min <= n < max. NOTE: It's < max and not <= max.\n * @example\n * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)\n */\nexport function aInRange(title, n, min, max) {\n    // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?\n    // consider P=256n, min=0n, max=P\n    // - a for min=0 would require -1:          `inRange('x', x, -1n, P)`\n    // - b would commonly require subtraction:  `inRange('x', x, 0n, P - 1n)`\n    // - our way is the cleanest:               `inRange('x', x, 0n, P)\n    if (!inRange(n, min, max))\n        throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n */\nexport function bitLen(n) {\n    let len;\n    for (len = 0; n > _0n; n >>= _1n, len += 1)\n        ;\n    return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n    return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport function bitSet(n, pos, value) {\n    return n | ((value ? _1n : _0n) << BigInt(pos));\n}\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;\n// DRBG\nconst u8n = (data) => new Uint8Array(data); // creates Uint8Array\nconst u8fr = (arr) => Uint8Array.from(arr); // another shortcut\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n()) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)\n        v = h(); // v = hmac(k || v)\n    };\n    const gen = () => {\n        // HMAC-DRBG generate() function\n        if (i++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\n        let len = 0;\n        const out = [];\n        while (len < qByteLen) {\n            v = h();\n            const sl = v.slice();\n            out.push(sl);\n            len += v.length;\n        }\n        return concatBytes(...out);\n    };\n    const genUntil = (seed, pred) => {\n        reset();\n        reseed(seed); // Steps D-G\n        let res = undefined; // Step H: grind until k is in [1..n-1]\n        while (!(res = pred(gen())))\n            reseed();\n        reset();\n        return res;\n    };\n    return genUntil;\n}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || isBytes(val),\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error('invalid validator function');\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error('param ' + String(fieldName) + ' is invalid. Expected ' + type + ', got ' + val);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\n/**\n * throws not implemented error\n */\nexport const notImplemented = () => {\n    throw new Error('not implemented');\n};\n/**\n * Memoizes (caches) computation result.\n * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.\n */\nexport function memoized(fn) {\n    const map = new WeakMap();\n    return (arg, ...args) => {\n        const val = map.get(arg);\n        if (val !== undefined)\n            return val;\n        const computed = fn(arg, ...args);\n        map.set(arg, computed);\n        return computed;\n    };\n}\n//# sourceMappingURL=utils.js.map","/**\n * HMAC: RFC2104 message authentication code.\n * @module\n */\nimport { abytes, aexists, ahash } from './_assert.js';\nimport { Hash, toBytes } from './utils.js';\nexport class HMAC extends Hash {\n    constructor(hash, _key) {\n        super();\n        this.finished = false;\n        this.destroyed = false;\n        ahash(hash);\n        const key = toBytes(_key);\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new Error('Expected instance of class which extends utils.Hash');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        pad.fill(0);\n    }\n    update(buf) {\n        aexists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        abytes(out, this.outputLen);\n        this.finished = true;\n        this.iHash.digestInto(out);\n        this.oHash.update(out);\n        this.oHash.digestInto(out);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since key already in state and we don't know it.\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n * @example\n * import { hmac } from '@noble/hashes/hmac';\n * import { sha256 } from '@noble/hashes/sha2';\n * const mac1 = hmac(sha256, 'key', 'message');\n */\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n//# sourceMappingURL=hmac.js.map","/**\n * Short Weierstrass curve methods. The formula is: y² = x³ + ax + b.\n *\n * ### Design rationale for types\n *\n * * Interaction between classes from different curves should fail:\n *   `k256.Point.BASE.add(p256.Point.BASE)`\n * * For this purpose we want to use `instanceof` operator, which is fast and works during runtime\n * * Different calls of `curve()` would return different classes -\n *   `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,\n *   it won't affect others\n *\n * TypeScript can't infer types for classes created inside a function. Classes is one instance\n * of nominative types in TypeScript and interfaces only check for shape, so it's hard to create\n * unique type for every function call.\n *\n * We can use generic types via some param, like curve opts, but that would:\n *     1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)\n *     which is hard to debug.\n *     2. Params can be generic and we can't enforce them to be constant value:\n *     if somebody creates curve from non-constant params,\n *     it would be allowed to interact with other curves with non-constant params\n *\n * @todo https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { pippenger, validateBasic, wNAF, } from './curve.js';\nimport { Field, getMinHashLength, invert, mapHashToField, mod, validateField, } from './modular.js';\nimport * as ut from './utils.js';\nimport { abool, ensureBytes, memoized } from './utils.js';\nfunction validateSigVerOpts(opts) {\n    if (opts.lowS !== undefined)\n        abool('lowS', opts.lowS);\n    if (opts.prehash !== undefined)\n        abool('prehash', opts.prehash);\n}\nfunction validatePointOpts(curve) {\n    const opts = validateBasic(curve);\n    ut.validateObject(opts, {\n        a: 'field',\n        b: 'field',\n    }, {\n        allowedPrivateKeyLengths: 'array',\n        wrapPrivateKey: 'boolean',\n        isTorsionFree: 'function',\n        clearCofactor: 'function',\n        allowInfinityPoint: 'boolean',\n        fromBytes: 'function',\n        toBytes: 'function',\n    });\n    const { endo, Fp, a } = opts;\n    if (endo) {\n        if (!Fp.eql(a, Fp.ZERO)) {\n            throw new Error('invalid endomorphism, can only be defined for Koblitz curves that have a=0');\n        }\n        if (typeof endo !== 'object' ||\n            typeof endo.beta !== 'bigint' ||\n            typeof endo.splitScalar !== 'function') {\n            throw new Error('invalid endomorphism, expected beta: bigint and splitScalar: function');\n        }\n    }\n    return Object.freeze({ ...opts });\n}\nconst { bytesToNumberBE: b2n, hexToBytes: h2b } = ut;\nexport class DERErr extends Error {\n    constructor(m = '') {\n        super(m);\n    }\n}\n/**\n * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:\n *\n *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]\n *\n * Docs: https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/, https://luca.ntop.org/Teaching/Appunti/asn1.html\n */\nexport const DER = {\n    // asn.1 DER encoding utils\n    Err: DERErr,\n    // Basic building block is TLV (Tag-Length-Value)\n    _tlv: {\n        encode: (tag, data) => {\n            const { Err: E } = DER;\n            if (tag < 0 || tag > 256)\n                throw new E('tlv.encode: wrong tag');\n            if (data.length & 1)\n                throw new E('tlv.encode: unpadded data');\n            const dataLen = data.length / 2;\n            const len = ut.numberToHexUnpadded(dataLen);\n            if ((len.length / 2) & 128)\n                throw new E('tlv.encode: long form length too big');\n            // length of length with long form flag\n            const lenLen = dataLen > 127 ? ut.numberToHexUnpadded((len.length / 2) | 128) : '';\n            const t = ut.numberToHexUnpadded(tag);\n            return t + lenLen + len + data;\n        },\n        // v - value, l - left bytes (unparsed)\n        decode(tag, data) {\n            const { Err: E } = DER;\n            let pos = 0;\n            if (tag < 0 || tag > 256)\n                throw new E('tlv.encode: wrong tag');\n            if (data.length < 2 || data[pos++] !== tag)\n                throw new E('tlv.decode: wrong tlv');\n            const first = data[pos++];\n            const isLong = !!(first & 128); // First bit of first length byte is flag for short/long form\n            let length = 0;\n            if (!isLong)\n                length = first;\n            else {\n                // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]\n                const lenLen = first & 127;\n                if (!lenLen)\n                    throw new E('tlv.decode(long): indefinite length not supported');\n                if (lenLen > 4)\n                    throw new E('tlv.decode(long): byte length is too big'); // this will overflow u32 in js\n                const lengthBytes = data.subarray(pos, pos + lenLen);\n                if (lengthBytes.length !== lenLen)\n                    throw new E('tlv.decode: length bytes not complete');\n                if (lengthBytes[0] === 0)\n                    throw new E('tlv.decode(long): zero leftmost byte');\n                for (const b of lengthBytes)\n                    length = (length << 8) | b;\n                pos += lenLen;\n                if (length < 128)\n                    throw new E('tlv.decode(long): not minimal encoding');\n            }\n            const v = data.subarray(pos, pos + length);\n            if (v.length !== length)\n                throw new E('tlv.decode: wrong value length');\n            return { v, l: data.subarray(pos + length) };\n        },\n    },\n    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n    // since we always use positive integers here. It must always be empty:\n    // - add zero byte if exists\n    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n    _int: {\n        encode(num) {\n            const { Err: E } = DER;\n            if (num < _0n)\n                throw new E('integer: negative integers are not allowed');\n            let hex = ut.numberToHexUnpadded(num);\n            // Pad with zero byte if negative flag is present\n            if (Number.parseInt(hex[0], 16) & 0b1000)\n                hex = '00' + hex;\n            if (hex.length & 1)\n                throw new E('unexpected DER parsing assertion: unpadded hex');\n            return hex;\n        },\n        decode(data) {\n            const { Err: E } = DER;\n            if (data[0] & 128)\n                throw new E('invalid signature integer: negative');\n            if (data[0] === 0x00 && !(data[1] & 128))\n                throw new E('invalid signature integer: unnecessary leading zero');\n            return b2n(data);\n        },\n    },\n    toSig(hex) {\n        // parse DER signature\n        const { Err: E, _int: int, _tlv: tlv } = DER;\n        const data = typeof hex === 'string' ? h2b(hex) : hex;\n        ut.abytes(data);\n        const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);\n        if (seqLeftBytes.length)\n            throw new E('invalid signature: left bytes after parsing');\n        const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);\n        const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);\n        if (sLeftBytes.length)\n            throw new E('invalid signature: left bytes after parsing');\n        return { r: int.decode(rBytes), s: int.decode(sBytes) };\n    },\n    hexFromSig(sig) {\n        const { _tlv: tlv, _int: int } = DER;\n        const rs = tlv.encode(0x02, int.encode(sig.r));\n        const ss = tlv.encode(0x02, int.encode(sig.s));\n        const seq = rs + ss;\n        return tlv.encode(0x30, seq);\n    },\n};\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\nexport function weierstrassPoints(opts) {\n    const CURVE = validatePointOpts(opts);\n    const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ\n    const Fn = Field(CURVE.n, CURVE.nBitLength);\n    const toBytes = CURVE.toBytes ||\n        ((_c, point, _isCompressed) => {\n            const a = point.toAffine();\n            return ut.concatBytes(Uint8Array.from([0x04]), Fp.toBytes(a.x), Fp.toBytes(a.y));\n        });\n    const fromBytes = CURVE.fromBytes ||\n        ((bytes) => {\n            // const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // if (head !== 0x04) throw new Error('Only non-compressed encoding is supported');\n            const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n            const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n            return { x, y };\n        });\n    /**\n     * y² = x³ + ax + b: Short weierstrass curve formula\n     * @returns y²\n     */\n    function weierstrassEquation(x) {\n        const { a, b } = CURVE;\n        const x2 = Fp.sqr(x); // x * x\n        const x3 = Fp.mul(x2, x); // x2 * x\n        return Fp.add(Fp.add(x3, Fp.mul(x, a)), b); // x3 + a * x + b\n    }\n    // Validate whether the passed curve params are valid.\n    // We check if curve equation works for generator point.\n    // `assertValidity()` won't work: `isTorsionFree()` is not available at this point in bls12-381.\n    // ProjectivePoint class has not been initialized yet.\n    if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))\n        throw new Error('bad generator point: equation left != right');\n    // Valid group elements reside in range 1..n-1\n    function isWithinCurveOrder(num) {\n        return ut.inRange(num, _1n, CURVE.n);\n    }\n    // Validates if priv key is valid and converts it to bigint.\n    // Supports options allowedPrivateKeyLengths and wrapPrivateKey.\n    function normPrivateKeyToScalar(key) {\n        const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;\n        if (lengths && typeof key !== 'bigint') {\n            if (ut.isBytes(key))\n                key = ut.bytesToHex(key);\n            // Normalize to hex string, pad. E.g. P521 would norm 130-132 char hex to 132-char bytes\n            if (typeof key !== 'string' || !lengths.includes(key.length))\n                throw new Error('invalid private key');\n            key = key.padStart(nByteLength * 2, '0');\n        }\n        let num;\n        try {\n            num =\n                typeof key === 'bigint'\n                    ? key\n                    : ut.bytesToNumberBE(ensureBytes('private key', key, nByteLength));\n        }\n        catch (error) {\n            throw new Error('invalid private key, expected hex or ' + nByteLength + ' bytes, got ' + typeof key);\n        }\n        if (wrapPrivateKey)\n            num = mod(num, N); // disabled by default, enabled for BLS\n        ut.aInRange('private key', num, _1n, N); // num in range [1..N-1]\n        return num;\n    }\n    function assertPrjPoint(other) {\n        if (!(other instanceof Point))\n            throw new Error('ProjectivePoint expected');\n    }\n    // Memoized toAffine / validity check. They are heavy. Points are immutable.\n    // Converts Projective point to affine (x, y) coordinates.\n    // Can accept precomputed Z^-1 - for example, from invertBatch.\n    // (x, y, z) ∋ (x=x/z, y=y/z)\n    const toAffineMemo = memoized((p, iz) => {\n        const { px: x, py: y, pz: z } = p;\n        // Fast-path for normalized points\n        if (Fp.eql(z, Fp.ONE))\n            return { x, y };\n        const is0 = p.is0();\n        // If invZ was 0, we return zero point. However we still want to execute\n        // all operations, so we replace invZ with a random number, 1.\n        if (iz == null)\n            iz = is0 ? Fp.ONE : Fp.inv(z);\n        const ax = Fp.mul(x, iz);\n        const ay = Fp.mul(y, iz);\n        const zz = Fp.mul(z, iz);\n        if (is0)\n            return { x: Fp.ZERO, y: Fp.ZERO };\n        if (!Fp.eql(zz, Fp.ONE))\n            throw new Error('invZ was invalid');\n        return { x: ax, y: ay };\n    });\n    // NOTE: on exception this will crash 'cached' and no value will be set.\n    // Otherwise true will be return\n    const assertValidMemo = memoized((p) => {\n        if (p.is0()) {\n            // (0, 1, 0) aka ZERO is invalid in most contexts.\n            // In BLS, ZERO can be serialized, so we allow it.\n            // (0, 0, 0) is invalid representation of ZERO.\n            if (CURVE.allowInfinityPoint && !Fp.is0(p.py))\n                return;\n            throw new Error('bad point: ZERO');\n        }\n        // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`\n        const { x, y } = p.toAffine();\n        // Check if x, y are valid field elements\n        if (!Fp.isValid(x) || !Fp.isValid(y))\n            throw new Error('bad point: x or y not FE');\n        const left = Fp.sqr(y); // y²\n        const right = weierstrassEquation(x); // x³ + ax + b\n        if (!Fp.eql(left, right))\n            throw new Error('bad point: equation left != right');\n        if (!p.isTorsionFree())\n            throw new Error('bad point: not in prime-order subgroup');\n        return true;\n    });\n    /**\n     * Projective Point works in 3d / projective (homogeneous) coordinates: (x, y, z) ∋ (x=x/z, y=y/z)\n     * Default Point works in 2d / affine coordinates: (x, y)\n     * We're doing calculations in projective, because its operations don't require costly inversion.\n     */\n    class Point {\n        constructor(px, py, pz) {\n            this.px = px;\n            this.py = py;\n            this.pz = pz;\n            if (px == null || !Fp.isValid(px))\n                throw new Error('x required');\n            if (py == null || !Fp.isValid(py))\n                throw new Error('y required');\n            if (pz == null || !Fp.isValid(pz))\n                throw new Error('z required');\n            Object.freeze(this);\n        }\n        // Does not validate if the point is on-curve.\n        // Use fromHex instead, or call assertValidity() later.\n        static fromAffine(p) {\n            const { x, y } = p || {};\n            if (!p || !Fp.isValid(x) || !Fp.isValid(y))\n                throw new Error('invalid affine point');\n            if (p instanceof Point)\n                throw new Error('projective point not allowed');\n            const is0 = (i) => Fp.eql(i, Fp.ZERO);\n            // fromAffine(x:0, y:0) would produce (x:0, y:0, z:1), but we need (x:0, y:1, z:0)\n            if (is0(x) && is0(y))\n                return Point.ZERO;\n            return new Point(x, y, Fp.ONE);\n        }\n        get x() {\n            return this.toAffine().x;\n        }\n        get y() {\n            return this.toAffine().y;\n        }\n        /**\n         * Takes a bunch of Projective Points but executes only one\n         * inversion on all of them. Inversion is very slow operation,\n         * so this improves performance massively.\n         * Optimization: converts a list of projective points to a list of identical points with Z=1.\n         */\n        static normalizeZ(points) {\n            const toInv = Fp.invertBatch(points.map((p) => p.pz));\n            return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n        }\n        /**\n         * Converts hash string or Uint8Array to Point.\n         * @param hex short/long ECDSA hex\n         */\n        static fromHex(hex) {\n            const P = Point.fromAffine(fromBytes(ensureBytes('pointHex', hex)));\n            P.assertValidity();\n            return P;\n        }\n        // Multiplies generator point by privateKey.\n        static fromPrivateKey(privateKey) {\n            return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));\n        }\n        // Multiscalar Multiplication\n        static msm(points, scalars) {\n            return pippenger(Point, Fn, points, scalars);\n        }\n        // \"Private method\", don't use it directly\n        _setWindowSize(windowSize) {\n            wnaf.setWindowSize(this, windowSize);\n        }\n        // A point on curve is valid if it conforms to equation.\n        assertValidity() {\n            assertValidMemo(this);\n        }\n        hasEvenY() {\n            const { y } = this.toAffine();\n            if (Fp.isOdd)\n                return !Fp.isOdd(y);\n            throw new Error(\"Field doesn't support isOdd\");\n        }\n        /**\n         * Compare one point to another.\n         */\n        equals(other) {\n            assertPrjPoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));\n            const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));\n            return U1 && U2;\n        }\n        /**\n         * Flips point to one corresponding to (x, -y) in Affine coordinates.\n         */\n        negate() {\n            return new Point(this.px, Fp.neg(this.py), this.pz);\n        }\n        // Renes-Costello-Batina exception-free doubling formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 3\n        // Cost: 8M + 3S + 3*a + 2*b3 + 15add.\n        double() {\n            const { a, b } = CURVE;\n            const b3 = Fp.mul(b, _3n);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            let t0 = Fp.mul(X1, X1); // step 1\n            let t1 = Fp.mul(Y1, Y1);\n            let t2 = Fp.mul(Z1, Z1);\n            let t3 = Fp.mul(X1, Y1);\n            t3 = Fp.add(t3, t3); // step 5\n            Z3 = Fp.mul(X1, Z1);\n            Z3 = Fp.add(Z3, Z3);\n            X3 = Fp.mul(a, Z3);\n            Y3 = Fp.mul(b3, t2);\n            Y3 = Fp.add(X3, Y3); // step 10\n            X3 = Fp.sub(t1, Y3);\n            Y3 = Fp.add(t1, Y3);\n            Y3 = Fp.mul(X3, Y3);\n            X3 = Fp.mul(t3, X3);\n            Z3 = Fp.mul(b3, Z3); // step 15\n            t2 = Fp.mul(a, t2);\n            t3 = Fp.sub(t0, t2);\n            t3 = Fp.mul(a, t3);\n            t3 = Fp.add(t3, Z3);\n            Z3 = Fp.add(t0, t0); // step 20\n            t0 = Fp.add(Z3, t0);\n            t0 = Fp.add(t0, t2);\n            t0 = Fp.mul(t0, t3);\n            Y3 = Fp.add(Y3, t0);\n            t2 = Fp.mul(Y1, Z1); // step 25\n            t2 = Fp.add(t2, t2);\n            t0 = Fp.mul(t2, t3);\n            X3 = Fp.sub(X3, t0);\n            Z3 = Fp.mul(t2, t1);\n            Z3 = Fp.add(Z3, Z3); // step 30\n            Z3 = Fp.add(Z3, Z3);\n            return new Point(X3, Y3, Z3);\n        }\n        // Renes-Costello-Batina exception-free addition formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 1\n        // Cost: 12M + 0S + 3*a + 3*b3 + 23add.\n        add(other) {\n            assertPrjPoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            const a = CURVE.a;\n            const b3 = Fp.mul(CURVE.b, _3n);\n            let t0 = Fp.mul(X1, X2); // step 1\n            let t1 = Fp.mul(Y1, Y2);\n            let t2 = Fp.mul(Z1, Z2);\n            let t3 = Fp.add(X1, Y1);\n            let t4 = Fp.add(X2, Y2); // step 5\n            t3 = Fp.mul(t3, t4);\n            t4 = Fp.add(t0, t1);\n            t3 = Fp.sub(t3, t4);\n            t4 = Fp.add(X1, Z1);\n            let t5 = Fp.add(X2, Z2); // step 10\n            t4 = Fp.mul(t4, t5);\n            t5 = Fp.add(t0, t2);\n            t4 = Fp.sub(t4, t5);\n            t5 = Fp.add(Y1, Z1);\n            X3 = Fp.add(Y2, Z2); // step 15\n            t5 = Fp.mul(t5, X3);\n            X3 = Fp.add(t1, t2);\n            t5 = Fp.sub(t5, X3);\n            Z3 = Fp.mul(a, t4);\n            X3 = Fp.mul(b3, t2); // step 20\n            Z3 = Fp.add(X3, Z3);\n            X3 = Fp.sub(t1, Z3);\n            Z3 = Fp.add(t1, Z3);\n            Y3 = Fp.mul(X3, Z3);\n            t1 = Fp.add(t0, t0); // step 25\n            t1 = Fp.add(t1, t0);\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.mul(b3, t4);\n            t1 = Fp.add(t1, t2);\n            t2 = Fp.sub(t0, t2); // step 30\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.add(t4, t2);\n            t0 = Fp.mul(t1, t4);\n            Y3 = Fp.add(Y3, t0);\n            t0 = Fp.mul(t5, t4); // step 35\n            X3 = Fp.mul(t3, X3);\n            X3 = Fp.sub(X3, t0);\n            t0 = Fp.mul(t3, t1);\n            Z3 = Fp.mul(t5, Z3);\n            Z3 = Fp.add(Z3, t0); // step 40\n            return new Point(X3, Y3, Z3);\n        }\n        subtract(other) {\n            return this.add(other.negate());\n        }\n        is0() {\n            return this.equals(Point.ZERO);\n        }\n        wNAF(n) {\n            return wnaf.wNAFCached(this, n, Point.normalizeZ);\n        }\n        /**\n         * Non-constant-time multiplication. Uses double-and-add algorithm.\n         * It's faster, but should only be used when you don't care about\n         * an exposed private key e.g. sig verification, which works over *public* keys.\n         */\n        multiplyUnsafe(sc) {\n            const { endo, n: N } = CURVE;\n            ut.aInRange('scalar', sc, _0n, N);\n            const I = Point.ZERO;\n            if (sc === _0n)\n                return I;\n            if (this.is0() || sc === _1n)\n                return this;\n            // Case a: no endomorphism. Case b: has precomputes.\n            if (!endo || wnaf.hasPrecomputes(this))\n                return wnaf.wNAFCachedUnsafe(this, sc, Point.normalizeZ);\n            // Case c: endomorphism\n            let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);\n            let k1p = I;\n            let k2p = I;\n            let d = this;\n            while (k1 > _0n || k2 > _0n) {\n                if (k1 & _1n)\n                    k1p = k1p.add(d);\n                if (k2 & _1n)\n                    k2p = k2p.add(d);\n                d = d.double();\n                k1 >>= _1n;\n                k2 >>= _1n;\n            }\n            if (k1neg)\n                k1p = k1p.negate();\n            if (k2neg)\n                k2p = k2p.negate();\n            k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n            return k1p.add(k2p);\n        }\n        /**\n         * Constant time multiplication.\n         * Uses wNAF method. Windowed method may be 10% faster,\n         * but takes 2x longer to generate and consumes 2x memory.\n         * Uses precomputes when available.\n         * Uses endomorphism for Koblitz curves.\n         * @param scalar by which the point would be multiplied\n         * @returns New point\n         */\n        multiply(scalar) {\n            const { endo, n: N } = CURVE;\n            ut.aInRange('scalar', scalar, _1n, N);\n            let point, fake; // Fake point is used to const-time mult\n            if (endo) {\n                const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);\n                let { p: k1p, f: f1p } = this.wNAF(k1);\n                let { p: k2p, f: f2p } = this.wNAF(k2);\n                k1p = wnaf.constTimeNegate(k1neg, k1p);\n                k2p = wnaf.constTimeNegate(k2neg, k2p);\n                k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n                point = k1p.add(k2p);\n                fake = f1p.add(f2p);\n            }\n            else {\n                const { p, f } = this.wNAF(scalar);\n                point = p;\n                fake = f;\n            }\n            // Normalize `z` for both points, but return only real one\n            return Point.normalizeZ([point, fake])[0];\n        }\n        /**\n         * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.\n         * Not using Strauss-Shamir trick: precomputation tables are faster.\n         * The trick could be useful if both P and Q are not G (not in our case).\n         * @returns non-zero affine point\n         */\n        multiplyAndAddUnsafe(Q, a, b) {\n            const G = Point.BASE; // No Strauss-Shamir trick: we have 10% faster G precomputes\n            const mul = (P, a // Select faster multiply() method\n            ) => (a === _0n || a === _1n || !P.equals(G) ? P.multiplyUnsafe(a) : P.multiply(a));\n            const sum = mul(this, a).add(mul(Q, b));\n            return sum.is0() ? undefined : sum;\n        }\n        // Converts Projective point to affine (x, y) coordinates.\n        // Can accept precomputed Z^-1 - for example, from invertBatch.\n        // (x, y, z) ∋ (x=x/z, y=y/z)\n        toAffine(iz) {\n            return toAffineMemo(this, iz);\n        }\n        isTorsionFree() {\n            const { h: cofactor, isTorsionFree } = CURVE;\n            if (cofactor === _1n)\n                return true; // No subgroups, always torsion-free\n            if (isTorsionFree)\n                return isTorsionFree(Point, this);\n            throw new Error('isTorsionFree() has not been declared for the elliptic curve');\n        }\n        clearCofactor() {\n            const { h: cofactor, clearCofactor } = CURVE;\n            if (cofactor === _1n)\n                return this; // Fast-path\n            if (clearCofactor)\n                return clearCofactor(Point, this);\n            return this.multiplyUnsafe(CURVE.h);\n        }\n        toRawBytes(isCompressed = true) {\n            abool('isCompressed', isCompressed);\n            this.assertValidity();\n            return toBytes(Point, this, isCompressed);\n        }\n        toHex(isCompressed = true) {\n            abool('isCompressed', isCompressed);\n            return ut.bytesToHex(this.toRawBytes(isCompressed));\n        }\n    }\n    Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n    Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);\n    const _bits = CURVE.nBitLength;\n    const wnaf = wNAF(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);\n    // Validate if generator point is on curve\n    return {\n        CURVE,\n        ProjectivePoint: Point,\n        normPrivateKeyToScalar,\n        weierstrassEquation,\n        isWithinCurveOrder,\n    };\n}\nfunction validateOpts(curve) {\n    const opts = validateBasic(curve);\n    ut.validateObject(opts, {\n        hash: 'hash',\n        hmac: 'function',\n        randomBytes: 'function',\n    }, {\n        bits2int: 'function',\n        bits2int_modN: 'function',\n        lowS: 'boolean',\n    });\n    return Object.freeze({ lowS: true, ...opts });\n}\n/**\n * Creates short weierstrass curve and ECDSA signature methods for it.\n * @example\n * import { Field } from '@noble/curves/abstract/modular';\n * // Before that, define BigInt-s: a, b, p, n, Gx, Gy\n * const curve = weierstrass({ a, b, Fp: Field(p), n, Gx, Gy, h: 1n })\n */\nexport function weierstrass(curveDef) {\n    const CURVE = validateOpts(curveDef);\n    const { Fp, n: CURVE_ORDER } = CURVE;\n    const compressedLen = Fp.BYTES + 1; // e.g. 33 for 32\n    const uncompressedLen = 2 * Fp.BYTES + 1; // e.g. 65 for 32\n    function modN(a) {\n        return mod(a, CURVE_ORDER);\n    }\n    function invN(a) {\n        return invert(a, CURVE_ORDER);\n    }\n    const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder, } = weierstrassPoints({\n        ...CURVE,\n        toBytes(_c, point, isCompressed) {\n            const a = point.toAffine();\n            const x = Fp.toBytes(a.x);\n            const cat = ut.concatBytes;\n            abool('isCompressed', isCompressed);\n            if (isCompressed) {\n                return cat(Uint8Array.from([point.hasEvenY() ? 0x02 : 0x03]), x);\n            }\n            else {\n                return cat(Uint8Array.from([0x04]), x, Fp.toBytes(a.y));\n            }\n        },\n        fromBytes(bytes) {\n            const len = bytes.length;\n            const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // this.assertValidity() is done inside of fromHex\n            if (len === compressedLen && (head === 0x02 || head === 0x03)) {\n                const x = ut.bytesToNumberBE(tail);\n                if (!ut.inRange(x, _1n, Fp.ORDER))\n                    throw new Error('Point is not on curve');\n                const y2 = weierstrassEquation(x); // y² = x³ + ax + b\n                let y;\n                try {\n                    y = Fp.sqrt(y2); // y = y² ^ (p+1)/4\n                }\n                catch (sqrtError) {\n                    const suffix = sqrtError instanceof Error ? ': ' + sqrtError.message : '';\n                    throw new Error('Point is not on curve' + suffix);\n                }\n                const isYOdd = (y & _1n) === _1n;\n                // ECDSA\n                const isHeadOdd = (head & 1) === 1;\n                if (isHeadOdd !== isYOdd)\n                    y = Fp.neg(y);\n                return { x, y };\n            }\n            else if (len === uncompressedLen && head === 0x04) {\n                const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n                const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n                return { x, y };\n            }\n            else {\n                const cl = compressedLen;\n                const ul = uncompressedLen;\n                throw new Error('invalid Point, expected length of ' + cl + ', or uncompressed ' + ul + ', got ' + len);\n            }\n        },\n    });\n    const numToNByteStr = (num) => ut.bytesToHex(ut.numberToBytesBE(num, CURVE.nByteLength));\n    function isBiggerThanHalfOrder(number) {\n        const HALF = CURVE_ORDER >> _1n;\n        return number > HALF;\n    }\n    function normalizeS(s) {\n        return isBiggerThanHalfOrder(s) ? modN(-s) : s;\n    }\n    // slice bytes num\n    const slcNum = (b, from, to) => ut.bytesToNumberBE(b.slice(from, to));\n    /**\n     * ECDSA signature with its (r, s) properties. Supports DER & compact representations.\n     */\n    class Signature {\n        constructor(r, s, recovery) {\n            this.r = r;\n            this.s = s;\n            this.recovery = recovery;\n            this.assertValidity();\n        }\n        // pair (bytes of r, bytes of s)\n        static fromCompact(hex) {\n            const l = CURVE.nByteLength;\n            hex = ensureBytes('compactSignature', hex, l * 2);\n            return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));\n        }\n        // DER encoded ECDSA signature\n        // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script\n        static fromDER(hex) {\n            const { r, s } = DER.toSig(ensureBytes('DER', hex));\n            return new Signature(r, s);\n        }\n        assertValidity() {\n            ut.aInRange('r', this.r, _1n, CURVE_ORDER); // r in [1..N]\n            ut.aInRange('s', this.s, _1n, CURVE_ORDER); // s in [1..N]\n        }\n        addRecoveryBit(recovery) {\n            return new Signature(this.r, this.s, recovery);\n        }\n        recoverPublicKey(msgHash) {\n            const { r, s, recovery: rec } = this;\n            const h = bits2int_modN(ensureBytes('msgHash', msgHash)); // Truncate hash\n            if (rec == null || ![0, 1, 2, 3].includes(rec))\n                throw new Error('recovery id invalid');\n            const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;\n            if (radj >= Fp.ORDER)\n                throw new Error('recovery id 2 or 3 invalid');\n            const prefix = (rec & 1) === 0 ? '02' : '03';\n            const R = Point.fromHex(prefix + numToNByteStr(radj));\n            const ir = invN(radj); // r^-1\n            const u1 = modN(-h * ir); // -hr^-1\n            const u2 = modN(s * ir); // sr^-1\n            const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2); // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1)\n            if (!Q)\n                throw new Error('point at infinify'); // unsafe is fine: no priv data leaked\n            Q.assertValidity();\n            return Q;\n        }\n        // Signatures should be low-s, to prevent malleability.\n        hasHighS() {\n            return isBiggerThanHalfOrder(this.s);\n        }\n        normalizeS() {\n            return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;\n        }\n        // DER-encoded\n        toDERRawBytes() {\n            return ut.hexToBytes(this.toDERHex());\n        }\n        toDERHex() {\n            return DER.hexFromSig({ r: this.r, s: this.s });\n        }\n        // padded bytes of r, then padded bytes of s\n        toCompactRawBytes() {\n            return ut.hexToBytes(this.toCompactHex());\n        }\n        toCompactHex() {\n            return numToNByteStr(this.r) + numToNByteStr(this.s);\n        }\n    }\n    const utils = {\n        isValidPrivateKey(privateKey) {\n            try {\n                normPrivateKeyToScalar(privateKey);\n                return true;\n            }\n            catch (error) {\n                return false;\n            }\n        },\n        normPrivateKeyToScalar: normPrivateKeyToScalar,\n        /**\n         * Produces cryptographically secure private key from random of size\n         * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.\n         */\n        randomPrivateKey: () => {\n            const length = getMinHashLength(CURVE.n);\n            return mapHashToField(CURVE.randomBytes(length), CURVE.n);\n        },\n        /**\n         * Creates precompute table for an arbitrary EC point. Makes point \"cached\".\n         * Allows to massively speed-up `point.multiply(scalar)`.\n         * @returns cached point\n         * @example\n         * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));\n         * fast.multiply(privKey); // much faster ECDH now\n         */\n        precompute(windowSize = 8, point = Point.BASE) {\n            point._setWindowSize(windowSize);\n            point.multiply(BigInt(3)); // 3 is arbitrary, just need any number here\n            return point;\n        },\n    };\n    /**\n     * Computes public key for a private key. Checks for validity of the private key.\n     * @param privateKey private key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns Public key, full when isCompressed=false; short when isCompressed=true\n     */\n    function getPublicKey(privateKey, isCompressed = true) {\n        return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\n    }\n    /**\n     * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n     */\n    function isProbPub(item) {\n        const arr = ut.isBytes(item);\n        const str = typeof item === 'string';\n        const len = (arr || str) && item.length;\n        if (arr)\n            return len === compressedLen || len === uncompressedLen;\n        if (str)\n            return len === 2 * compressedLen || len === 2 * uncompressedLen;\n        if (item instanceof Point)\n            return true;\n        return false;\n    }\n    /**\n     * ECDH (Elliptic Curve Diffie Hellman).\n     * Computes shared public key from private key and public key.\n     * Checks: 1) private key validity 2) shared key is on-curve.\n     * Does NOT hash the result.\n     * @param privateA private key\n     * @param publicB different public key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns shared public key\n     */\n    function getSharedSecret(privateA, publicB, isCompressed = true) {\n        if (isProbPub(privateA))\n            throw new Error('first arg must be private key');\n        if (!isProbPub(publicB))\n            throw new Error('second arg must be public key');\n        const b = Point.fromHex(publicB); // check for being on-curve\n        return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);\n    }\n    // RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.\n    // FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.\n    // bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.\n    // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors\n    const bits2int = CURVE.bits2int ||\n        function (bytes) {\n            // Our custom check \"just in case\"\n            if (bytes.length > 8192)\n                throw new Error('input is too large');\n            // For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)\n            // for some cases, since bytes.length * 8 is not actual bitLength.\n            const num = ut.bytesToNumberBE(bytes); // check for == u8 done here\n            const delta = bytes.length * 8 - CURVE.nBitLength; // truncate to nBitLength leftmost bits\n            return delta > 0 ? num >> BigInt(delta) : num;\n        };\n    const bits2int_modN = CURVE.bits2int_modN ||\n        function (bytes) {\n            return modN(bits2int(bytes)); // can't use bytesToNumberBE here\n        };\n    // NOTE: pads output with zero as per spec\n    const ORDER_MASK = ut.bitMask(CURVE.nBitLength);\n    /**\n     * Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`.\n     */\n    function int2octets(num) {\n        ut.aInRange('num < 2^' + CURVE.nBitLength, num, _0n, ORDER_MASK);\n        // works with order, can have different size than numToField!\n        return ut.numberToBytesBE(num, CURVE.nByteLength);\n    }\n    // Steps A, D of RFC6979 3.2\n    // Creates RFC6979 seed; converts msg/privKey to numbers.\n    // Used only in sign, not in verify.\n    // NOTE: we cannot assume here that msgHash has same amount of bytes as curve order,\n    // this will be invalid at least for P521. Also it can be bigger for P224 + SHA256\n    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {\n        if (['recovered', 'canonical'].some((k) => k in opts))\n            throw new Error('sign() legacy options not supported');\n        const { hash, randomBytes } = CURVE;\n        let { lowS, prehash, extraEntropy: ent } = opts; // generates low-s sigs by default\n        if (lowS == null)\n            lowS = true; // RFC6979 3.2: we skip step A, because we already provide hash\n        msgHash = ensureBytes('msgHash', msgHash);\n        validateSigVerOpts(opts);\n        if (prehash)\n            msgHash = ensureBytes('prehashed msgHash', hash(msgHash));\n        // We can't later call bits2octets, since nested bits2int is broken for curves\n        // with nBitLength % 8 !== 0. Because of that, we unwrap it here as int2octets call.\n        // const bits2octets = (bits) => int2octets(bits2int_modN(bits))\n        const h1int = bits2int_modN(msgHash);\n        const d = normPrivateKeyToScalar(privateKey); // validate private key, convert to bigint\n        const seedArgs = [int2octets(d), int2octets(h1int)];\n        // extraEntropy. RFC6979 3.6: additional k' (optional).\n        if (ent != null && ent !== false) {\n            // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')\n            const e = ent === true ? randomBytes(Fp.BYTES) : ent; // generate random bytes OR pass as-is\n            seedArgs.push(ensureBytes('extraEntropy', e)); // check for being bytes\n        }\n        const seed = ut.concatBytes(...seedArgs); // Step D of RFC6979 3.2\n        const m = h1int; // NOTE: no need to call bits2int second time here, it is inside truncateHash!\n        // Converts signature params into point w r/s, checks result for validity.\n        function k2sig(kBytes) {\n            // RFC 6979 Section 3.2, step 3: k = bits2int(T)\n            const k = bits2int(kBytes); // Cannot use fields methods, since it is group element\n            if (!isWithinCurveOrder(k))\n                return; // Important: all mod() calls here must be done over N\n            const ik = invN(k); // k^-1 mod n\n            const q = Point.BASE.multiply(k).toAffine(); // q = Gk\n            const r = modN(q.x); // r = q.x mod n\n            if (r === _0n)\n                return;\n            // Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to\n            // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:\n            // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT\n            const s = modN(ik * modN(m + r * d)); // Not using blinding here\n            if (s === _0n)\n                return;\n            let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3, when q.x > n)\n            let normS = s;\n            if (lowS && isBiggerThanHalfOrder(s)) {\n                normS = normalizeS(s); // if lowS was passed, ensure s is always\n                recovery ^= 1; // // in the bottom half of N\n            }\n            return new Signature(r, normS, recovery); // use normS, not s\n        }\n        return { seed, k2sig };\n    }\n    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };\n    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };\n    /**\n     * Signs message hash with a private key.\n     * ```\n     * sign(m, d, k) where\n     *   (x, y) = G × k\n     *   r = x mod n\n     *   s = (m + dr)/k mod n\n     * ```\n     * @param msgHash NOT message. msg needs to be hashed to `msgHash`, or use `prehash`.\n     * @param privKey private key\n     * @param opts lowS for non-malleable sigs. extraEntropy for mixing randomness into k. prehash will hash first arg.\n     * @returns signature with recovery param\n     */\n    function sign(msgHash, privKey, opts = defaultSigOpts) {\n        const { seed, k2sig } = prepSig(msgHash, privKey, opts); // Steps A, D of RFC6979 3.2.\n        const C = CURVE;\n        const drbg = ut.createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);\n        return drbg(seed, k2sig); // Steps B, C, D, E, F, G\n    }\n    // Enable precomputes. Slows down first publicKey computation by 20ms.\n    Point.BASE._setWindowSize(8);\n    // utils.precompute(8, ProjectivePoint.BASE)\n    /**\n     * Verifies a signature against message hash and public key.\n     * Rejects lowS signatures by default: to override,\n     * specify option `{lowS: false}`. Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:\n     *\n     * ```\n     * verify(r, s, h, P) where\n     *   U1 = hs^-1 mod n\n     *   U2 = rs^-1 mod n\n     *   R = U1⋅G - U2⋅P\n     *   mod(R.x, n) == r\n     * ```\n     */\n    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {\n        const sg = signature;\n        msgHash = ensureBytes('msgHash', msgHash);\n        publicKey = ensureBytes('publicKey', publicKey);\n        const { lowS, prehash, format } = opts;\n        // Verify opts, deduce signature format\n        validateSigVerOpts(opts);\n        if ('strict' in opts)\n            throw new Error('options.strict was renamed to lowS');\n        if (format !== undefined && format !== 'compact' && format !== 'der')\n            throw new Error('format must be compact or der');\n        const isHex = typeof sg === 'string' || ut.isBytes(sg);\n        const isObj = !isHex &&\n            !format &&\n            typeof sg === 'object' &&\n            sg !== null &&\n            typeof sg.r === 'bigint' &&\n            typeof sg.s === 'bigint';\n        if (!isHex && !isObj)\n            throw new Error('invalid signature, expected Uint8Array, hex string or Signature instance');\n        let _sig = undefined;\n        let P;\n        try {\n            if (isObj)\n                _sig = new Signature(sg.r, sg.s);\n            if (isHex) {\n                // Signature can be represented in 2 ways: compact (2*nByteLength) & DER (variable-length).\n                // Since DER can also be 2*nByteLength bytes, we check for it first.\n                try {\n                    if (format !== 'compact')\n                        _sig = Signature.fromDER(sg);\n                }\n                catch (derError) {\n                    if (!(derError instanceof DER.Err))\n                        throw derError;\n                }\n                if (!_sig && format !== 'der')\n                    _sig = Signature.fromCompact(sg);\n            }\n            P = Point.fromHex(publicKey);\n        }\n        catch (error) {\n            return false;\n        }\n        if (!_sig)\n            return false;\n        if (lowS && _sig.hasHighS())\n            return false;\n        if (prehash)\n            msgHash = CURVE.hash(msgHash);\n        const { r, s } = _sig;\n        const h = bits2int_modN(msgHash); // Cannot use fields methods, since it is group element\n        const is = invN(s); // s^-1\n        const u1 = modN(h * is); // u1 = hs^-1 mod n\n        const u2 = modN(r * is); // u2 = rs^-1 mod n\n        const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine(); // R = u1⋅G + u2⋅P\n        if (!R)\n            return false;\n        const v = modN(R.x);\n        return v === r;\n    }\n    return {\n        CURVE,\n        getPublicKey,\n        getSharedSecret,\n        sign,\n        verify,\n        ProjectivePoint: Point,\n        Signature,\n        utils,\n    };\n}\n/**\n * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.\n * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.\n * b = True and y = sqrt(u / v) if (u / v) is square in F, and\n * b = False and y = sqrt(Z * (u / v)) otherwise.\n * @param Fp\n * @param Z\n * @returns\n */\nexport function SWUFpSqrtRatio(Fp, Z) {\n    // Generic implementation\n    const q = Fp.ORDER;\n    let l = _0n;\n    for (let o = q - _1n; o % _2n === _0n; o /= _2n)\n        l += _1n;\n    const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.\n    // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.\n    // 2n ** c1 == 2n << (c1-1)\n    const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);\n    const _2n_pow_c1 = _2n_pow_c1_1 * _2n;\n    const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic\n    const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic\n    const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic\n    const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic\n    const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2\n    const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)\n    let sqrtRatio = (u, v) => {\n        let tv1 = c6; // 1. tv1 = c6\n        let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4\n        let tv3 = Fp.sqr(tv2); // 3. tv3 = tv2^2\n        tv3 = Fp.mul(tv3, v); // 4. tv3 = tv3 * v\n        let tv5 = Fp.mul(u, tv3); // 5. tv5 = u * tv3\n        tv5 = Fp.pow(tv5, c3); // 6. tv5 = tv5^c3\n        tv5 = Fp.mul(tv5, tv2); // 7. tv5 = tv5 * tv2\n        tv2 = Fp.mul(tv5, v); // 8. tv2 = tv5 * v\n        tv3 = Fp.mul(tv5, u); // 9. tv3 = tv5 * u\n        let tv4 = Fp.mul(tv3, tv2); // 10. tv4 = tv3 * tv2\n        tv5 = Fp.pow(tv4, c5); // 11. tv5 = tv4^c5\n        let isQR = Fp.eql(tv5, Fp.ONE); // 12. isQR = tv5 == 1\n        tv2 = Fp.mul(tv3, c7); // 13. tv2 = tv3 * c7\n        tv5 = Fp.mul(tv4, tv1); // 14. tv5 = tv4 * tv1\n        tv3 = Fp.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)\n        tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)\n        // 17. for i in (c1, c1 - 1, ..., 2):\n        for (let i = c1; i > _1n; i--) {\n            let tv5 = i - _2n; // 18.    tv5 = i - 2\n            tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5\n            let tvv5 = Fp.pow(tv4, tv5); // 20.    tv5 = tv4^tv5\n            const e1 = Fp.eql(tvv5, Fp.ONE); // 21.    e1 = tv5 == 1\n            tv2 = Fp.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1\n            tv1 = Fp.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1\n            tvv5 = Fp.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1\n            tv3 = Fp.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)\n            tv4 = Fp.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)\n        }\n        return { isValid: isQR, value: tv3 };\n    };\n    if (Fp.ORDER % _4n === _3n) {\n        // sqrt_ratio_3mod4(u, v)\n        const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic\n        const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)\n        sqrtRatio = (u, v) => {\n            let tv1 = Fp.sqr(v); // 1. tv1 = v^2\n            const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n            tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n            let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n            y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n            const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n            const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n            const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n            let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n            return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n        };\n    }\n    // No curves uses that\n    // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n    return sqrtRatio;\n}\n/**\n * Simplified Shallue-van de Woestijne-Ulas Method\n * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2\n */\nexport function mapToCurveSimpleSWU(Fp, opts) {\n    validateField(Fp);\n    if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))\n        throw new Error('mapToCurveSimpleSWU: invalid opts');\n    const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);\n    if (!Fp.isOdd)\n        throw new Error('Fp.isOdd is not implemented!');\n    // Input: u, an element of F.\n    // Output: (x, y), a point on E.\n    return (u) => {\n        // prettier-ignore\n        let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n        tv1 = Fp.sqr(u); // 1.  tv1 = u^2\n        tv1 = Fp.mul(tv1, opts.Z); // 2.  tv1 = Z * tv1\n        tv2 = Fp.sqr(tv1); // 3.  tv2 = tv1^2\n        tv2 = Fp.add(tv2, tv1); // 4.  tv2 = tv2 + tv1\n        tv3 = Fp.add(tv2, Fp.ONE); // 5.  tv3 = tv2 + 1\n        tv3 = Fp.mul(tv3, opts.B); // 6.  tv3 = B * tv3\n        tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)\n        tv4 = Fp.mul(tv4, opts.A); // 8.  tv4 = A * tv4\n        tv2 = Fp.sqr(tv3); // 9.  tv2 = tv3^2\n        tv6 = Fp.sqr(tv4); // 10. tv6 = tv4^2\n        tv5 = Fp.mul(tv6, opts.A); // 11. tv5 = A * tv6\n        tv2 = Fp.add(tv2, tv5); // 12. tv2 = tv2 + tv5\n        tv2 = Fp.mul(tv2, tv3); // 13. tv2 = tv2 * tv3\n        tv6 = Fp.mul(tv6, tv4); // 14. tv6 = tv6 * tv4\n        tv5 = Fp.mul(tv6, opts.B); // 15. tv5 = B * tv6\n        tv2 = Fp.add(tv2, tv5); // 16. tv2 = tv2 + tv5\n        x = Fp.mul(tv1, tv3); // 17.   x = tv1 * tv3\n        const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)\n        y = Fp.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1\n        y = Fp.mul(y, value); // 20.   y = y * y1\n        x = Fp.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)\n        y = Fp.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)\n        const e1 = Fp.isOdd(u) === Fp.isOdd(y); // 23.  e1 = sgn0(u) == sgn0(y)\n        y = Fp.cmov(Fp.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)\n        x = Fp.div(x, tv4); // 25.   x = x / tv4\n        return { x, y };\n    };\n}\n//# sourceMappingURL=weierstrass.js.map","/**\n * Utilities for short weierstrass curves, combined with noble-hashes.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac } from '@noble/hashes/hmac';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils';\nimport { weierstrass } from './abstract/weierstrass.js';\n/** connects noble-curves to noble-hashes */\nexport function getHash(hash) {\n    return {\n        hash,\n        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),\n        randomBytes,\n    };\n}\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });\n    return { ...create(defHash), create };\n}\n//# sourceMappingURL=_shortw_utils.js.map","/**\n * NIST secp256k1. See [pdf](https://www.secg.org/sec2-v2.pdf).\n *\n * Seems to be rigid (not backdoored)\n * [as per discussion](https://bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975).\n *\n * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.\n * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.\n * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.\n * [See explanation](https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066).\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha256 } from '@noble/hashes/sha256';\nimport { randomBytes } from '@noble/hashes/utils';\nimport { createCurve } from './_shortw_utils.js';\nimport { createHasher, isogenyMap } from './abstract/hash-to-curve.js';\nimport { Field, mod, pow2 } from './abstract/modular.js';\nimport { aInRange, bytesToNumberBE, concatBytes, ensureBytes, inRange, numberToBytesBE, } from './abstract/utils.js';\nimport { mapToCurveSimpleSWU } from './abstract/weierstrass.js';\nconst secp256k1P = BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f');\nconst secp256k1N = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst divNearest = (a, b) => (a + b / _2n) / b;\n/**\n * √n = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.\n * (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]\n */\nfunction sqrtMod(y) {\n    const P = secp256k1P;\n    // prettier-ignore\n    const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);\n    // prettier-ignore\n    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);\n    const b2 = (y * y * y) % P; // x^3, 11\n    const b3 = (b2 * b2 * y) % P; // x^7\n    const b6 = (pow2(b3, _3n, P) * b3) % P;\n    const b9 = (pow2(b6, _3n, P) * b3) % P;\n    const b11 = (pow2(b9, _2n, P) * b2) % P;\n    const b22 = (pow2(b11, _11n, P) * b11) % P;\n    const b44 = (pow2(b22, _22n, P) * b22) % P;\n    const b88 = (pow2(b44, _44n, P) * b44) % P;\n    const b176 = (pow2(b88, _88n, P) * b88) % P;\n    const b220 = (pow2(b176, _44n, P) * b44) % P;\n    const b223 = (pow2(b220, _3n, P) * b3) % P;\n    const t1 = (pow2(b223, _23n, P) * b22) % P;\n    const t2 = (pow2(t1, _6n, P) * b2) % P;\n    const root = pow2(t2, _2n, P);\n    if (!Fpk1.eql(Fpk1.sqr(root), y))\n        throw new Error('Cannot find square root');\n    return root;\n}\nconst Fpk1 = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });\n/**\n * secp256k1 short weierstrass curve and ECDSA signatures over it.\n *\n * @example\n * import { secp256k1 } from '@noble/curves/secp256k1';\n *\n * const priv = secp256k1.utils.randomPrivateKey();\n * const pub = secp256k1.getPublicKey(priv);\n * const msg = new Uint8Array(32).fill(1); // message hash (not message) in ecdsa\n * const sig = secp256k1.sign(msg, priv); // `{prehash: true}` option is available\n * const isValid = secp256k1.verify(sig, msg, pub) === true;\n */\nexport const secp256k1 = createCurve({\n    a: BigInt(0), // equation params: a, b\n    b: BigInt(7),\n    Fp: Fpk1, // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n\n    n: secp256k1N, // Curve order, total count of valid points in the field\n    // Base point (x, y) aka generator point\n    Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),\n    Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),\n    h: BigInt(1), // Cofactor\n    lowS: true, // Allow only low-S signatures by default in sign() and verify()\n    endo: {\n        // Endomorphism, see above\n        beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n        splitScalar: (k) => {\n            const n = secp256k1N;\n            const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');\n            const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');\n            const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');\n            const b2 = a1;\n            const POW_2_128 = BigInt('0x100000000000000000000000000000000'); // (2n**128n).toString(16)\n            const c1 = divNearest(b2 * k, n);\n            const c2 = divNearest(-b1 * k, n);\n            let k1 = mod(k - c1 * a1 - c2 * a2, n);\n            let k2 = mod(-c1 * b1 - c2 * b2, n);\n            const k1neg = k1 > POW_2_128;\n            const k2neg = k2 > POW_2_128;\n            if (k1neg)\n                k1 = n - k1;\n            if (k2neg)\n                k2 = n - k2;\n            if (k1 > POW_2_128 || k2 > POW_2_128) {\n                throw new Error('splitScalar: Endomorphism failed, k=' + k);\n            }\n            return { k1neg, k1, k2neg, k2 };\n        },\n    },\n}, sha256);\n// Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.\n// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\nconst _0n = BigInt(0);\n/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */\nconst TAGGED_HASH_PREFIXES = {};\nfunction taggedHash(tag, ...messages) {\n    let tagP = TAGGED_HASH_PREFIXES[tag];\n    if (tagP === undefined) {\n        const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n        tagP = concatBytes(tagH, tagH);\n        TAGGED_HASH_PREFIXES[tag] = tagP;\n    }\n    return sha256(concatBytes(tagP, ...messages));\n}\n// ECDSA compact points are 33-byte. Schnorr is 32: we strip first byte 0x02 or 0x03\nconst pointToBytes = (point) => point.toRawBytes(true).slice(1);\nconst numTo32b = (n) => numberToBytesBE(n, 32);\nconst modP = (x) => mod(x, secp256k1P);\nconst modN = (x) => mod(x, secp256k1N);\nconst Point = secp256k1.ProjectivePoint;\nconst GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);\n// Calculate point, scalar and bytes\nfunction schnorrGetExtPubKey(priv) {\n    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv); // same method executed in fromPrivateKey\n    let p = Point.fromPrivateKey(d_); // P = d'⋅G; 0 < d' < n check is done inside\n    const scalar = p.hasEvenY() ? d_ : modN(-d_);\n    return { scalar: scalar, bytes: pointToBytes(p) };\n}\n/**\n * lift_x from BIP340. Convert 32-byte x coordinate to elliptic curve point.\n * @returns valid point checked for being on-curve\n */\nfunction lift_x(x) {\n    aInRange('x', x, _1n, secp256k1P); // Fail if x ≥ p.\n    const xx = modP(x * x);\n    const c = modP(xx * x + BigInt(7)); // Let c = x³ + 7 mod p.\n    let y = sqrtMod(c); // Let y = c^(p+1)/4 mod p.\n    if (y % _2n !== _0n)\n        y = modP(-y); // Return the unique point P such that x(P) = x and\n    const p = new Point(x, y, _1n); // y(P) = y if y mod 2 = 0 or y(P) = p-y otherwise.\n    p.assertValidity();\n    return p;\n}\nconst num = bytesToNumberBE;\n/**\n * Create tagged hash, convert it to bigint, reduce modulo-n.\n */\nfunction challenge(...args) {\n    return modN(num(taggedHash('BIP0340/challenge', ...args)));\n}\n/**\n * Schnorr public key is just `x` coordinate of Point as per BIP340.\n */\nfunction schnorrGetPublicKey(privateKey) {\n    return schnorrGetExtPubKey(privateKey).bytes; // d'=int(sk). Fail if d'=0 or d'≥n. Ret bytes(d'⋅G)\n}\n/**\n * Creates Schnorr signature as per BIP340. Verifies itself before returning anything.\n * auxRand is optional and is not the sole source of k generation: bad CSPRNG won't be dangerous.\n */\nfunction schnorrSign(message, privateKey, auxRand = randomBytes(32)) {\n    const m = ensureBytes('message', message);\n    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey); // checks for isWithinCurveOrder\n    const a = ensureBytes('auxRand', auxRand, 32); // Auxiliary random data a: a 32-byte array\n    const t = numTo32b(d ^ num(taggedHash('BIP0340/aux', a))); // Let t be the byte-wise xor of bytes(d) and hash/aux(a)\n    const rand = taggedHash('BIP0340/nonce', t, px, m); // Let rand = hash/nonce(t || bytes(P) || m)\n    const k_ = modN(num(rand)); // Let k' = int(rand) mod n\n    if (k_ === _0n)\n        throw new Error('sign failed: k is zero'); // Fail if k' = 0.\n    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_); // Let R = k'⋅G.\n    const e = challenge(rx, px, m); // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.\n    const sig = new Uint8Array(64); // Let sig = bytes(R) || bytes((k + ed) mod n).\n    sig.set(rx, 0);\n    sig.set(numTo32b(modN(k + e * d)), 32);\n    // If Verify(bytes(P), m, sig) (see below) returns failure, abort\n    if (!schnorrVerify(sig, m, px))\n        throw new Error('sign: Invalid signature produced');\n    return sig;\n}\n/**\n * Verifies Schnorr signature.\n * Will swallow errors & return false except for initial type validation of arguments.\n */\nfunction schnorrVerify(signature, message, publicKey) {\n    const sig = ensureBytes('signature', signature, 64);\n    const m = ensureBytes('message', message);\n    const pub = ensureBytes('publicKey', publicKey, 32);\n    try {\n        const P = lift_x(num(pub)); // P = lift_x(int(pk)); fail if that fails\n        const r = num(sig.subarray(0, 32)); // Let r = int(sig[0:32]); fail if r ≥ p.\n        if (!inRange(r, _1n, secp256k1P))\n            return false;\n        const s = num(sig.subarray(32, 64)); // Let s = int(sig[32:64]); fail if s ≥ n.\n        if (!inRange(s, _1n, secp256k1N))\n            return false;\n        const e = challenge(numTo32b(r), pointToBytes(P), m); // int(challenge(bytes(r)||bytes(P)||m))%n\n        const R = GmulAdd(P, s, modN(-e)); // R = s⋅G - e⋅P\n        if (!R || !R.hasEvenY() || R.toAffine().x !== r)\n            return false; // -eP == (n-e)P\n        return true; // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.\n    }\n    catch (error) {\n        return false;\n    }\n}\n/**\n * Schnorr signatures over secp256k1.\n * https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n * @example\n * import { schnorr } from '@noble/curves/secp256k1';\n * const priv = schnorr.utils.randomPrivateKey();\n * const pub = schnorr.getPublicKey(priv);\n * const msg = new TextEncoder().encode('hello');\n * const sig = schnorr.sign(msg, priv);\n * const isValid = schnorr.verify(sig, msg, pub);\n */\nexport const schnorr = /* @__PURE__ */ (() => ({\n    getPublicKey: schnorrGetPublicKey,\n    sign: schnorrSign,\n    verify: schnorrVerify,\n    utils: {\n        randomPrivateKey: secp256k1.utils.randomPrivateKey,\n        lift_x,\n        pointToBytes,\n        numberToBytesBE,\n        bytesToNumberBE,\n        taggedHash,\n        mod,\n    },\n}))();\nconst isoMap = /* @__PURE__ */ (() => isogenyMap(Fpk1, [\n    // xNum\n    [\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7',\n        '0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581',\n        '0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262',\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c',\n    ],\n    // xDen\n    [\n        '0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b',\n        '0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n    // yNum\n    [\n        '0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c',\n        '0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3',\n        '0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931',\n        '0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84',\n    ],\n    // yDen\n    [\n        '0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b',\n        '0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573',\n        '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n].map((i) => i.map((j) => BigInt(j)))))();\nconst mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fpk1, {\n    A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),\n    B: BigInt('1771'),\n    Z: Fpk1.create(BigInt('-11')),\n}))();\nconst htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {\n    const { x, y } = mapSWU(Fpk1.create(scalars[0]));\n    return isoMap(x, y);\n}, {\n    DST: 'secp256k1_XMD:SHA-256_SSWU_RO_',\n    encodeDST: 'secp256k1_XMD:SHA-256_SSWU_NU_',\n    p: Fpk1.ORDER,\n    m: 1,\n    k: 128,\n    expand: 'xmd',\n    hash: sha256,\n}))();\n/** secp256k1 hash-to-curve from [RFC 9380](https://www.rfc-editor.org/rfc/rfc9380). */\nexport const hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();\n/** secp256k1 encode-to-curve from [RFC 9380](https://www.rfc-editor.org/rfc/rfc9380). */\nexport const encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();\n//# sourceMappingURL=secp256k1.js.map"],"names":["_0n","BigInt","_1n","constTimeNegate","condition","item","neg","negate","validateW","W","bits","Number","isSafeInteger","calcWOpts","windows","Math","ceil","windowSize","pointPrecomputes","WeakMap","pointWindowSizes","getW","P","get","wNAF","c","hasPrecomputes","elm","unsafeLadder","n","p","ZERO","d","add","double","precomputeWindow","points","base","window","push","i","precomputes","f","BASE","mask","maxNumber","shiftBy","offset","wbits","offset2","abs","cond1","cond2","wNAFUnsafe","acc","curr","getPrecomputes","transform","comp","set","wNAFCached","wNAFCachedUnsafe","prev","setWindowSize","delete","pippenger","fieldN","scalars","validateMSMPoints","Array","isArray","forEach","validateMSMScalars","field","s","isValid","length","zero","_utils_js__WEBPACK_IMPORTED_MODULE_0__","Dd","MASK","buckets","fill","lastBits","floor","BITS","sum","j","resI","sumI","validateBasic","curve","_modular_js__WEBPACK_IMPORTED_MODULE_1__","OP","Fp","FF","h","Gx","Gy","nBitLength","nByteLength","Object","freeze","kK","ORDER","_2n","_3n","_4n","_5n","_8n","mod","a","b","result","pow2","x","power","modulo","res","invert","number","y","u","v","q","r","m","gcd","isNegativeLE","num","FIELD_FIELDS","validateField","opts","reduce","map","val","BYTES","nLength","_nBitLength","undefined","toString","Field","bitLen","isLE","redef","sqrtP","dQ","ONE","create","is0","isOdd","eql","lhs","rhs","sqr","sub","mul","pow","FpPow","div","sqrN","addN","subN","mulN","inv","sqrt","FpSqrt","p1div4","root","c1","n2","nv","tonelliShanks","Q","S","Z","legendreC","Q1div2","g","t2","ge","invertBatch","FpInvertBatch","nums","tmp","lastMultiplied","inverted","reduceRight","lst","cmov","toBytes","S5","tL","fromBytes","bytes","ty","bytesToNumberBE","getFieldBytesLength","fieldOrder","bitLength","getMinHashLength","mapHashToField","key","len","fieldLen","minLen","reduced","isBytes","Uint8Array","ArrayBuffer","isView","constructor","name","abytes","abool","title","value","hexes","from","_","padStart","bytesToHex","hex","numberToHexUnpadded","hexToNumber","asciis","_0","_9","A","F","asciiToBase16","ch","hexToBytes","hl","al","array","ai","hi","n1","charCodeAt","bytesToNumberLE","reverse","numberToBytesBE","numberToBytesLE","ensureBytes","expectedLength","e","concatBytes","arrays","pad","isPosBig","inRange","min","max","aInRange","bitMask","u8n","data","u8fr","arr","createHmacDrbg","hashLen","qByteLen","hmacFn","k","reset","reseed","seed","gen","out","sl","slice","pred","validatorFns","bigint","function","boolean","string","stringOrUint8Array","object","hash","outputLen","validateObject","validators","optValidators","checkField","fieldName","type","isOptional","checkVal","String","entries","memoized","fn","arg","args","computed","HMAC","utils","kb","_key","finished","destroyed","_assert","z3","O0","iHash","update","blockLen","digest","oHash","buf","$h","digestInto","gk","destroy","_cloneInto","to","getPrototypeOf","hmac","message","validateSigVerOpts","lowS","abstract_utils","uw","prehash","b2n","h2b","DERErr","Error","DER","Err","_tlv","encode","tag","E","dataLen","uz","lenLen","t","decode","pos","first","lengthBytes","subarray","l","_int","parseInt","toSig","int","tlv","seqBytes","seqLeftBytes","rBytes","rLeftBytes","sBytes","sLeftBytes","hexFromSig","sig","rs","ss","secp256k1P","secp256k1N","secp256k1_1n","secp256k1_2n","divNearest","Fpk1","modular","gN","_6n","_11n","_22n","_23n","_44n","_88n","b2","b3","b6","oA","b9","b11","b22","b44","b88","b176","b220","b223","t1","secp256k1","createCurve","curveDef","defHash","weierstrass","CURVE","validateOpts","abstract_curve","Kd","randomBytes","bits2int","bits2int_modN","CURVE_ORDER","compressedLen","uncompressedLen","modN","wQ","invN","U_","ProjectivePoint","Point","normPrivateKeyToScalar","weierstrassEquation","isWithinCurveOrder","weierstrassPoints","validatePointOpts","allowedPrivateKeyLengths","wrapPrivateKey","isTorsionFree","clearCofactor","allowInfinityPoint","endo","beta","splitScalar","Fn","_c","point","_isCompressed","toAffine","eV","tail","x2","x3","lengths","N","_t","ci","includes","ql","error","Fy","assertPrjPoint","other","toAffineMemo","H9","iz","px","py","pz","z","ax","ay","zz","assertValidMemo","left","right","fromAffine","normalizeZ","toInv","fromHex","assertValidity","fromPrivateKey","privateKey","multiply","msm","D1","_setWindowSize","wnaf","hasEvenY","equals","X1","Y1","Z1","X2","Y2","Z2","U1","U2","X3","Y3","Z3","t0","t3","t4","t5","subtract","multiplyUnsafe","sc","I","k1neg","k1","k2neg","k2","k1p","k2p","scalar","fake","f1p","f2p","multiplyAndAddUnsafe","G","cofactor","toRawBytes","isCompressed","toHex","_bits","Mx","cat","head","y2","sqrtError","numToNByteStr","slcNum","Signature","recovery","fromCompact","fromDER","addRecoveryBit","recoverPublicKey","msgHash","rec","radj","prefix","R","ir","u1","u2","hasHighS","normalizeS","toDERRawBytes","toDERHex","toCompactRawBytes","toCompactHex","isProbPub","str","delta","ORDER_MASK","int2octets","defaultSigOpts","defaultVerOpts","getPublicKey","getSharedSecret","privateA","publicB","sign","privKey","k2sig","prepSig","some","extraEntropy","ent","h1int","seedArgs","kBytes","ik","normS","isBiggerThanHalfOrder","drbg","n$","C","verify","signature","publicKey","_sig","format","isHex","isObj","sg","derError","is","isValidPrivateKey","randomPrivateKey","PS","Us","precompute","msgs","O6","a1","b1","a2","POW_2_128","c2","esm_sha256","JQ"],"sourceRoot":""}