@tatchi-xyz/sdk 0.21.0 → 0.31.0

package/dist/esm/server/node_modules/.pnpm/@noble_curves@2.0.1/node_modules/@noble/curves/abstract/curve.js

@@ -1,4 +1,246 @@
+import { bitMask } from "../utils.js";
+import { Field, FpInvertBatch, validateField } from "./modular.js";
+
 //#region ../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/curve.js
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+function negateCt(condition, item) {
+	const neg = item.negate();
+	return condition ? neg : item;
+}
+/**
+* Takes a bunch of Projective Points but executes only one
+* inversion on all of them. Inversion is very slow operation,
+* so this improves performance massively.
+* Optimization: converts a list of projective points to a list of identical points with Z=1.
+*/
+function normalizeZ(c, points) {
+	const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));
+	return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));
+}
+function validateW(W, bits) {
+	if (!Number.isSafeInteger(W) || W <= 0 || W > bits) throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
+}
+function calcWOpts(W, scalarBits) {
+	validateW(W, scalarBits);
+	const windows = Math.ceil(scalarBits / W) + 1;
+	const windowSize = 2 ** (W - 1);
+	const maxNumber = 2 ** W;
+	const mask = bitMask(W);
+	const shiftBy = BigInt(W);
+	return {
+		windows,
+		windowSize,
+		mask,
+		maxNumber,
+		shiftBy
+	};
+}
+function calcOffsets(n, window, wOpts) {
+	const { windowSize, mask, maxNumber, shiftBy } = wOpts;
+	let wbits = Number(n & mask);
+	let nextN = n >> shiftBy;
+	if (wbits > windowSize) {
+		wbits -= maxNumber;
+		nextN += _1n;
+	}
+	const offsetStart = window * windowSize;
+	const offset = offsetStart + Math.abs(wbits) - 1;
+	const isZero = wbits === 0;
+	const isNeg = wbits < 0;
+	const isNegF = window % 2 !== 0;
+	const offsetF = offsetStart;
+	return {
+		nextN,
+		offset,
+		isZero,
+		isNeg,
+		isNegF,
+		offsetF
+	};
+}
+const pointPrecomputes = /* @__PURE__ */ new WeakMap();
+const pointWindowSizes = /* @__PURE__ */ new WeakMap();
+function getW(P) {
+	return pointWindowSizes.get(P) || 1;
+}
+function assert0(n) {
+	if (n !== _0n) throw new Error("invalid wNAF");
+}
+/**
+* Elliptic curve multiplication of Point by scalar. Fragile.
+* Table generation takes **30MB of ram and 10ms on high-end CPU**,
+* but may take much longer on slow devices. Actual generation will happen on
+* first call of `multiply()`. By default, `BASE` point is precomputed.
+*
+* Scalars should always be less than curve order: this should be checked inside of a curve itself.
+* Creates precomputation tables for fast multiplication:
+* - private scalar is split by fixed size windows of W bits
+* - every window point is collected from window's table & added to accumulator
+* - since windows are different, same point inside tables won't be accessed more than once per calc
+* - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)
+* - +1 window is neccessary for wNAF
+* - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication
+*
+* @todo Research returning 2d JS array of windows, instead of a single window.
+* This would allow windows to be in different memory locations
+*/
+var wNAF = class {
+	BASE;
+	ZERO;
+	Fn;
+	bits;
+	constructor(Point, bits) {
+		this.BASE = Point.BASE;
+		this.ZERO = Point.ZERO;
+		this.Fn = Point.Fn;
+		this.bits = bits;
+	}
+	_unsafeLadder(elm, n, p = this.ZERO) {
+		let d = elm;
+		while (n > _0n) {
+			if (n & _1n) p = p.add(d);
+			d = d.double();
+			n >>= _1n;
+		}
+		return p;
+	}
+	/**
+	* Creates a wNAF precomputation window. Used for caching.
+	* Default window size is set by `utils.precompute()` and is equal to 8.
+	* Number of precomputed points depends on the curve size:
+	* 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+	* - 𝑊 is the window size
+	* - 𝑛 is the bitlength of the curve order.
+	* For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+	* @param point Point instance
+	* @param W window size
+	* @returns precomputed point tables flattened to a single array
+	*/
+	precomputeWindow(point, W) {
+		const { windows, windowSize } = calcWOpts(W, this.bits);
+		const points = [];
+		let p = point;
+		let base = p;
+		for (let window = 0; window < windows; window++) {
+			base = p;
+			points.push(base);
+			for (let i = 1; i < windowSize; i++) {
+				base = base.add(p);
+				points.push(base);
+			}
+			p = base.double();
+		}
+		return points;
+	}
+	/**
+	* Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+	* More compact implementation:
+	* https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+	* @returns real and fake (for const-time) points
+	*/
+	wNAF(W, precomputes, n) {
+		if (!this.Fn.isValid(n)) throw new Error("invalid scalar");
+		let p = this.ZERO;
+		let f = this.BASE;
+		const wo = calcWOpts(W, this.bits);
+		for (let window = 0; window < wo.windows; window++) {
+			const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
+			n = nextN;
+			if (isZero) f = f.add(negateCt(isNegF, precomputes[offsetF]));
+			else p = p.add(negateCt(isNeg, precomputes[offset]));
+		}
+		assert0(n);
+		return {
+			p,
+			f
+		};
+	}
+	/**
+	* Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+	* @param acc accumulator point to add result of multiplication
+	* @returns point
+	*/
+	wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
+		const wo = calcWOpts(W, this.bits);
+		for (let window = 0; window < wo.windows; window++) {
+			if (n === _0n) break;
+			const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
+			n = nextN;
+			if (isZero) continue;
+			else {
+				const item = precomputes[offset];
+				acc = acc.add(isNeg ? item.negate() : item);
+			}
+		}
+		assert0(n);
+		return acc;
+	}
+	getPrecomputes(W, point, transform) {
+		let comp = pointPrecomputes.get(point);
+		if (!comp) {
+			comp = this.precomputeWindow(point, W);
+			if (W !== 1) {
+				if (typeof transform === "function") comp = transform(comp);
+				pointPrecomputes.set(point, comp);
+			}
+		}
+		return comp;
+	}
+	cached(point, scalar, transform) {
+		const W = getW(point);
+		return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+	}
+	unsafe(point, scalar, transform, prev) {
+		const W = getW(point);
+		if (W === 1) return this._unsafeLadder(point, scalar, prev);
+		return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+	}
+	createCache(P, W) {
+		validateW(W, this.bits);
+		pointWindowSizes.set(P, W);
+		pointPrecomputes.delete(P);
+	}
+	hasCache(elm) {
+		return getW(elm) !== 1;
+	}
+};
+function createField(order, field, isLE) {
+	if (field) {
+		if (field.ORDER !== order) throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+		validateField(field);
+		return field;
+	} else return Field(order, { isLE });
+}
+/** Validates CURVE opts and creates fields */
+function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
+	if (FpFnLE === void 0) FpFnLE = type === "edwards";
+	if (!CURVE || typeof CURVE !== "object") throw new Error(`expected valid ${type} CURVE object`);
+	for (const p of [
+		"p",
+		"n",
+		"h"
+	]) {
+		const val = CURVE[p];
+		if (!(typeof val === "bigint" && val > _0n)) throw new Error(`CURVE.${p} must be positive bigint`);
+	}
+	const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);
+	const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);
+	const _b = type === "weierstrass" ? "b" : "d";
+	const params = [
+		"Gx",
+		"Gy",
+		"a",
+		_b
+	];
+	for (const p of params) if (!Fp.isValid(CURVE[p])) throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);
+	CURVE = Object.freeze(Object.assign({}, CURVE));
+	return {
+		CURVE,
+		Fp,
+		Fn
+	};
+}
 function createKeygen(randomSecretKey, getPublicKey) {
 	return function keygen(seed) {
 		const secretKey = randomSecretKey(seed);
@@ -10,5 +252,5 @@ function createKeygen(randomSecretKey, getPublicKey) {
 }
 
 //#endregion
-export { createKeygen };
+export { createCurveFields, createKeygen, normalizeZ, wNAF };
 //# sourceMappingURL=curve.js.map

package/dist/esm/server/node_modules/.pnpm/@noble_curves@2.0.1/node_modules/@noble/curves/abstract/curve.js.map

@@ -1 +1 @@
-{"version":3,"file":"curve.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/curve.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 { bitLen, bitMask } from \"../utils.js\";\nimport { Field, FpInvertBatch, validateField } from \"./modular.js\";\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function negateCt(condition, item) {\n    const neg = item.negate();\n    return condition ? neg : item;\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 */\nexport function normalizeZ(c, points) {\n    const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));\n    return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));\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, scalarBits) {\n    validateW(W, scalarBits);\n    const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero\n    const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero\n    const maxNumber = 2 ** W; // W=8 256\n    const mask = bitMask(W); // W=8 255 == mask 0b11111111\n    const shiftBy = BigInt(W); // W=8 8\n    return { windows, windowSize, mask, maxNumber, shiftBy };\n}\nfunction calcOffsets(n, window, wOpts) {\n    const { windowSize, mask, maxNumber, shiftBy } = wOpts;\n    let wbits = Number(n & mask); // extract W bits.\n    let nextN = n >> shiftBy; // shift number by W bits.\n    // What actually happens here:\n    // const highestBit = Number(mask ^ (mask >> 1n));\n    // let wbits2 = wbits - 1; // skip zero\n    // if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);\n    // split if bits > max: +224 => 256-32\n    if (wbits > windowSize) {\n        // we skip zero, which means instead of `>= size-1`, we do `> size`\n        wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.\n        nextN += _1n; // +256 (carry)\n    }\n    const offsetStart = window * windowSize;\n    const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero\n    const isZero = wbits === 0; // is current window slice a 0?\n    const isNeg = wbits < 0; // is current window slice negative?\n    const isNegF = window % 2 !== 0; // fake random statement for noise\n    const offsetF = offsetStart; // fake offset for noise\n    return { nextN, offset, isZero, isNeg, isNegF, offsetF };\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.\n// Allows to make points frozen / immutable.\nconst pointPrecomputes = new WeakMap();\nconst pointWindowSizes = new WeakMap();\nfunction getW(P) {\n    // To disable precomputes:\n    // return 1;\n    return pointWindowSizes.get(P) || 1;\n}\nfunction assert0(n) {\n    if (n !== _0n)\n        throw new Error('invalid wNAF');\n}\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Table generation takes **30MB of ram and 10ms on high-end CPU**,\n * but may take much longer on slow devices. Actual generation will happen on\n * first call of `multiply()`. By default, `BASE` point is precomputed.\n *\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 class wNAF {\n    BASE;\n    ZERO;\n    Fn;\n    bits;\n    // Parametrized with a given Point class (not individual point)\n    constructor(Point, bits) {\n        this.BASE = Point.BASE;\n        this.ZERO = Point.ZERO;\n        this.Fn = Point.Fn;\n        this.bits = bits;\n    }\n    // non-const time multiplication ladder\n    _unsafeLadder(elm, n, p = this.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 point Point instance\n     * @param W window size\n     * @returns precomputed point tables flattened to a single array\n     */\n    precomputeWindow(point, W) {\n        const { windows, windowSize } = calcWOpts(W, this.bits);\n        const points = [];\n        let p = point;\n        let base = p;\n        for (let window = 0; window < windows; window++) {\n            base = p;\n            points.push(base);\n            // i=1, bc we skip 0\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     * More compact implementation:\n     * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541\n     * @returns real and fake (for const-time) points\n     */\n    wNAF(W, precomputes, n) {\n        // Scalar should be smaller than field order\n        if (!this.Fn.isValid(n))\n            throw new Error('invalid scalar');\n        // Accumulators\n        let p = this.ZERO;\n        let f = this.BASE;\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        const wo = calcWOpts(W, this.bits);\n        for (let window = 0; window < wo.windows; window++) {\n            // (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise\n            const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);\n            n = nextN;\n            if (isZero) {\n                // bits are 0: add garbage to fake point\n                // Important part for const-time getPublicKey: add random \"noise\" point to f.\n                f = f.add(negateCt(isNegF, precomputes[offsetF]));\n            }\n            else {\n                // bits are 1: add to result point\n                p = p.add(negateCt(isNeg, precomputes[offset]));\n            }\n        }\n        assert0(n);\n        // Return both real and fake points: JIT won't eliminate f.\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 acc accumulator point to add result of multiplication\n     * @returns point\n     */\n    wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {\n        const wo = calcWOpts(W, this.bits);\n        for (let window = 0; window < wo.windows; window++) {\n            if (n === _0n)\n                break; // Early-exit, skip 0 value\n            const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);\n            n = nextN;\n            if (isZero) {\n                // Window bits are 0: skip processing.\n                // Move to next window.\n                continue;\n            }\n            else {\n                const item = precomputes[offset];\n                acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM\n            }\n        }\n        assert0(n);\n        return acc;\n    }\n    getPrecomputes(W, point, transform) {\n        // Calculate precomputes on a first run, reuse them after\n        let comp = pointPrecomputes.get(point);\n        if (!comp) {\n            comp = this.precomputeWindow(point, W);\n            if (W !== 1) {\n                // Doing transform outside of if brings 15% perf hit\n                if (typeof transform === 'function')\n                    comp = transform(comp);\n                pointPrecomputes.set(point, comp);\n            }\n        }\n        return comp;\n    }\n    cached(point, scalar, transform) {\n        const W = getW(point);\n        return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);\n    }\n    unsafe(point, scalar, transform, prev) {\n        const W = getW(point);\n        if (W === 1)\n            return this._unsafeLadder(point, scalar, prev); // For W=1 ladder is ~x2 faster\n        return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, 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    createCache(P, W) {\n        validateW(W, this.bits);\n        pointWindowSizes.set(P, W);\n        pointPrecomputes.delete(P);\n    }\n    hasCache(elm) {\n        return getW(elm) !== 1;\n    }\n}\n/**\n * Endomorphism-specific multiplication for Koblitz curves.\n * Cost: 128 dbl, 0-256 adds.\n */\nexport function mulEndoUnsafe(Point, point, k1, k2) {\n    let acc = point;\n    let p1 = Point.ZERO;\n    let p2 = Point.ZERO;\n    while (k1 > _0n || k2 > _0n) {\n        if (k1 & _1n)\n            p1 = p1.add(acc);\n        if (k2 & _1n)\n            p2 = p2.add(acc);\n        acc = acc.double();\n        k1 >>= _1n;\n        k2 >>= _1n;\n    }\n    return { p1, p2 };\n}\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster than 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 secret keys / bigints)\n */\nexport function pippenger(c, 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    const fieldN = c.Fn;\n    validateMSMPoints(points, c);\n    validateMSMScalars(scalars, fieldN);\n    const plength = points.length;\n    const slength = scalars.length;\n    if (plength !== slength)\n        throw new Error('arrays of points and scalars must have equal length');\n    // if (plength === 0) throw new Error('array must be of length >= 2');\n    const zero = c.ZERO;\n    const wbits = bitLen(BigInt(plength));\n    let windowSize = 1; // bits\n    if (wbits > 12)\n        windowSize = wbits - 3;\n    else if (wbits > 4)\n        windowSize = wbits - 2;\n    else if (wbits > 0)\n        windowSize = 2;\n    const MASK = bitMask(windowSize);\n    const buckets = new Array(Number(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 < slength; j++) {\n            const scalar = scalars[j];\n            const wbits = Number((scalar >> BigInt(i)) & 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, 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    const fieldN = c.Fn;\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 = bitMask(windowSize);\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}\nfunction createField(order, field, isLE) {\n    if (field) {\n        if (field.ORDER !== order)\n            throw new Error('Field.ORDER must match order: Fp == p, Fn == n');\n        validateField(field);\n        return field;\n    }\n    else {\n        return Field(order, { isLE });\n    }\n}\n/** Validates CURVE opts and creates fields */\nexport function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {\n    if (FpFnLE === undefined)\n        FpFnLE = type === 'edwards';\n    if (!CURVE || typeof CURVE !== 'object')\n        throw new Error(`expected valid ${type} CURVE object`);\n    for (const p of ['p', 'n', 'h']) {\n        const val = CURVE[p];\n        if (!(typeof val === 'bigint' && val > _0n))\n            throw new Error(`CURVE.${p} must be positive bigint`);\n    }\n    const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);\n    const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);\n    const _b = type === 'weierstrass' ? 'b' : 'd';\n    const params = ['Gx', 'Gy', 'a', _b];\n    for (const p of params) {\n        // @ts-ignore\n        if (!Fp.isValid(CURVE[p]))\n            throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);\n    }\n    CURVE = Object.freeze(Object.assign({}, CURVE));\n    return { CURVE, Fp, Fn };\n}\nexport function createKeygen(randomSecretKey, getPublicKey) {\n    return function keygen(seed) {\n        const secretKey = randomSecretKey(seed);\n        return { secretKey, publicKey: getPublicKey(secretKey) };\n    };\n}\n//# sourceMappingURL=curve.js.map"],"x_google_ignoreList":[0],"mappings":";AAkcA,SAAgB,aAAa,iBAAiB,cAAc;AACxD,QAAO,SAAS,OAAO,MAAM;EACzB,MAAM,YAAY,gBAAgB;AAClC,SAAO;GAAE;GAAW,WAAW,aAAa"}
+{"version":3,"file":"curve.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/curve.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 { bitLen, bitMask } from \"../utils.js\";\nimport { Field, FpInvertBatch, validateField } from \"./modular.js\";\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function negateCt(condition, item) {\n    const neg = item.negate();\n    return condition ? neg : item;\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 */\nexport function normalizeZ(c, points) {\n    const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));\n    return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));\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, scalarBits) {\n    validateW(W, scalarBits);\n    const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero\n    const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero\n    const maxNumber = 2 ** W; // W=8 256\n    const mask = bitMask(W); // W=8 255 == mask 0b11111111\n    const shiftBy = BigInt(W); // W=8 8\n    return { windows, windowSize, mask, maxNumber, shiftBy };\n}\nfunction calcOffsets(n, window, wOpts) {\n    const { windowSize, mask, maxNumber, shiftBy } = wOpts;\n    let wbits = Number(n & mask); // extract W bits.\n    let nextN = n >> shiftBy; // shift number by W bits.\n    // What actually happens here:\n    // const highestBit = Number(mask ^ (mask >> 1n));\n    // let wbits2 = wbits - 1; // skip zero\n    // if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);\n    // split if bits > max: +224 => 256-32\n    if (wbits > windowSize) {\n        // we skip zero, which means instead of `>= size-1`, we do `> size`\n        wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.\n        nextN += _1n; // +256 (carry)\n    }\n    const offsetStart = window * windowSize;\n    const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero\n    const isZero = wbits === 0; // is current window slice a 0?\n    const isNeg = wbits < 0; // is current window slice negative?\n    const isNegF = window % 2 !== 0; // fake random statement for noise\n    const offsetF = offsetStart; // fake offset for noise\n    return { nextN, offset, isZero, isNeg, isNegF, offsetF };\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.\n// Allows to make points frozen / immutable.\nconst pointPrecomputes = new WeakMap();\nconst pointWindowSizes = new WeakMap();\nfunction getW(P) {\n    // To disable precomputes:\n    // return 1;\n    return pointWindowSizes.get(P) || 1;\n}\nfunction assert0(n) {\n    if (n !== _0n)\n        throw new Error('invalid wNAF');\n}\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Table generation takes **30MB of ram and 10ms on high-end CPU**,\n * but may take much longer on slow devices. Actual generation will happen on\n * first call of `multiply()`. By default, `BASE` point is precomputed.\n *\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 class wNAF {\n    BASE;\n    ZERO;\n    Fn;\n    bits;\n    // Parametrized with a given Point class (not individual point)\n    constructor(Point, bits) {\n        this.BASE = Point.BASE;\n        this.ZERO = Point.ZERO;\n        this.Fn = Point.Fn;\n        this.bits = bits;\n    }\n    // non-const time multiplication ladder\n    _unsafeLadder(elm, n, p = this.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 point Point instance\n     * @param W window size\n     * @returns precomputed point tables flattened to a single array\n     */\n    precomputeWindow(point, W) {\n        const { windows, windowSize } = calcWOpts(W, this.bits);\n        const points = [];\n        let p = point;\n        let base = p;\n        for (let window = 0; window < windows; window++) {\n            base = p;\n            points.push(base);\n            // i=1, bc we skip 0\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     * More compact implementation:\n     * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541\n     * @returns real and fake (for const-time) points\n     */\n    wNAF(W, precomputes, n) {\n        // Scalar should be smaller than field order\n        if (!this.Fn.isValid(n))\n            throw new Error('invalid scalar');\n        // Accumulators\n        let p = this.ZERO;\n        let f = this.BASE;\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        const wo = calcWOpts(W, this.bits);\n        for (let window = 0; window < wo.windows; window++) {\n            // (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise\n            const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);\n            n = nextN;\n            if (isZero) {\n                // bits are 0: add garbage to fake point\n                // Important part for const-time getPublicKey: add random \"noise\" point to f.\n                f = f.add(negateCt(isNegF, precomputes[offsetF]));\n            }\n            else {\n                // bits are 1: add to result point\n                p = p.add(negateCt(isNeg, precomputes[offset]));\n            }\n        }\n        assert0(n);\n        // Return both real and fake points: JIT won't eliminate f.\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 acc accumulator point to add result of multiplication\n     * @returns point\n     */\n    wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {\n        const wo = calcWOpts(W, this.bits);\n        for (let window = 0; window < wo.windows; window++) {\n            if (n === _0n)\n                break; // Early-exit, skip 0 value\n            const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);\n            n = nextN;\n            if (isZero) {\n                // Window bits are 0: skip processing.\n                // Move to next window.\n                continue;\n            }\n            else {\n                const item = precomputes[offset];\n                acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM\n            }\n        }\n        assert0(n);\n        return acc;\n    }\n    getPrecomputes(W, point, transform) {\n        // Calculate precomputes on a first run, reuse them after\n        let comp = pointPrecomputes.get(point);\n        if (!comp) {\n            comp = this.precomputeWindow(point, W);\n            if (W !== 1) {\n                // Doing transform outside of if brings 15% perf hit\n                if (typeof transform === 'function')\n                    comp = transform(comp);\n                pointPrecomputes.set(point, comp);\n            }\n        }\n        return comp;\n    }\n    cached(point, scalar, transform) {\n        const W = getW(point);\n        return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);\n    }\n    unsafe(point, scalar, transform, prev) {\n        const W = getW(point);\n        if (W === 1)\n            return this._unsafeLadder(point, scalar, prev); // For W=1 ladder is ~x2 faster\n        return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, 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    createCache(P, W) {\n        validateW(W, this.bits);\n        pointWindowSizes.set(P, W);\n        pointPrecomputes.delete(P);\n    }\n    hasCache(elm) {\n        return getW(elm) !== 1;\n    }\n}\n/**\n * Endomorphism-specific multiplication for Koblitz curves.\n * Cost: 128 dbl, 0-256 adds.\n */\nexport function mulEndoUnsafe(Point, point, k1, k2) {\n    let acc = point;\n    let p1 = Point.ZERO;\n    let p2 = Point.ZERO;\n    while (k1 > _0n || k2 > _0n) {\n        if (k1 & _1n)\n            p1 = p1.add(acc);\n        if (k2 & _1n)\n            p2 = p2.add(acc);\n        acc = acc.double();\n        k1 >>= _1n;\n        k2 >>= _1n;\n    }\n    return { p1, p2 };\n}\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster than 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 secret keys / bigints)\n */\nexport function pippenger(c, 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    const fieldN = c.Fn;\n    validateMSMPoints(points, c);\n    validateMSMScalars(scalars, fieldN);\n    const plength = points.length;\n    const slength = scalars.length;\n    if (plength !== slength)\n        throw new Error('arrays of points and scalars must have equal length');\n    // if (plength === 0) throw new Error('array must be of length >= 2');\n    const zero = c.ZERO;\n    const wbits = bitLen(BigInt(plength));\n    let windowSize = 1; // bits\n    if (wbits > 12)\n        windowSize = wbits - 3;\n    else if (wbits > 4)\n        windowSize = wbits - 2;\n    else if (wbits > 0)\n        windowSize = 2;\n    const MASK = bitMask(windowSize);\n    const buckets = new Array(Number(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 < slength; j++) {\n            const scalar = scalars[j];\n            const wbits = Number((scalar >> BigInt(i)) & 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, 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    const fieldN = c.Fn;\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 = bitMask(windowSize);\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}\nfunction createField(order, field, isLE) {\n    if (field) {\n        if (field.ORDER !== order)\n            throw new Error('Field.ORDER must match order: Fp == p, Fn == n');\n        validateField(field);\n        return field;\n    }\n    else {\n        return Field(order, { isLE });\n    }\n}\n/** Validates CURVE opts and creates fields */\nexport function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {\n    if (FpFnLE === undefined)\n        FpFnLE = type === 'edwards';\n    if (!CURVE || typeof CURVE !== 'object')\n        throw new Error(`expected valid ${type} CURVE object`);\n    for (const p of ['p', 'n', 'h']) {\n        const val = CURVE[p];\n        if (!(typeof val === 'bigint' && val > _0n))\n            throw new Error(`CURVE.${p} must be positive bigint`);\n    }\n    const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);\n    const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);\n    const _b = type === 'weierstrass' ? 'b' : 'd';\n    const params = ['Gx', 'Gy', 'a', _b];\n    for (const p of params) {\n        // @ts-ignore\n        if (!Fp.isValid(CURVE[p]))\n            throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);\n    }\n    CURVE = Object.freeze(Object.assign({}, CURVE));\n    return { CURVE, Fp, Fn };\n}\nexport function createKeygen(randomSecretKey, getPublicKey) {\n    return function keygen(seed) {\n        const secretKey = randomSecretKey(seed);\n        return { secretKey, publicKey: getPublicKey(secretKey) };\n    };\n}\n//# sourceMappingURL=curve.js.map"],"x_google_ignoreList":[0],"mappings":"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"}