@noble/curves - npm Package Compare versions

Comparing version 2.2.0 to 2.3.0

abstract/der.d.ts

+/**
+ * ASN.1 DER (Distinguished Encoding Rules) helpers for ECDSA signatures.
+ * Only implements the tiny subset needed for `SEQUENCE(INTEGER r, INTEGER s)`.
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import { type TArg, type TRet } from '../utils.ts';
+/**
+ * @param m - Error message.
+ * @example
+ * Throw a DER-specific error when signature parsing encounters invalid bytes.
+ *
+ * ```ts
+ * new DERErr('bad der');
+ * ```
+ */
+export declare class DERErr extends Error {
+    constructor(m?: string);
+}
+/** DER helper namespace used by ECDSA signature parsing and encoding. */
+export type IDER = {
+    /**
+     * DER-specific error constructor.
+     * @param m - Error message.
+     * @returns DER-specific error instance.
+     */
+    Err: typeof DERErr;
+    /** Low-level tag-length-value helpers used by DER encoders. */
+    _tlv: {
+        /**
+         * Encode one TLV record.
+         * @param tag - ASN.1 tag byte.
+         * @param data - Hex-encoded value payload.
+         * @returns Encoded TLV string.
+         */
+        encode: (tag: number, data: string) => string;
+        /**
+         * Decode one TLV record and return the value plus leftover bytes.
+         * @param tag - Expected ASN.1 tag byte.
+         * @param data - Remaining DER bytes.
+         * @returns Parsed value plus leftover bytes.
+         */
+        decode(tag: number, data: TArg<Uint8Array>): TRet<{
+            v: Uint8Array;
+            l: Uint8Array;
+        }>;
+    };
+    /** Positive-integer DER helpers used by ECDSA signature encoding. */
+    _int: {
+        /**
+         * Encode one positive bigint as a DER INTEGER.
+         * @param num - Positive integer to encode.
+         * @returns Encoded DER INTEGER.
+         */
+        encode(num: bigint): string;
+        /**
+         * Decode one DER INTEGER into a bigint.
+         * @param data - DER INTEGER bytes.
+         * @returns Decoded bigint.
+         */
+        decode(data: TArg<Uint8Array>): bigint;
+    };
+    /**
+     * Parse a DER signature into `{ r, s }`.
+     * @param bytes - DER signature bytes.
+     * @returns Parsed signature components.
+     */
+    toSig(bytes: TArg<Uint8Array>): {
+        r: bigint;
+        s: bigint;
+    };
+    /**
+     * Encode `{ r, s }` as a DER signature.
+     * @param sig - Signature components.
+     * @returns DER-encoded signature hex.
+     */
+    hexFromSig(sig: {
+        r: bigint;
+        s: bigint;
+    }): string;
+};
+/**
+ * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:
+ *
+ *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]
+ *
+ * Docs: {@link https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/ | Let's Encrypt ASN.1 guide} and
+ * {@link https://luca.ntop.org/Teaching/Appunti/asn1.html | Luca Deri's ASN.1 notes}.
+ * @example
+ * ASN.1 DER encoding utilities.
+ *
+ * ```ts
+ * const der = DER.hexFromSig({ r: 1n, s: 2n });
+ * ```
+ */
+export declare const DER: IDER;

abstract/der.js

+/**
+ * ASN.1 DER (Distinguished Encoding Rules) helpers for ECDSA signatures.
+ * Only implements the tiny subset needed for `SEQUENCE(INTEGER r, INTEGER s)`.
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import { abignumber, abytes, asafenumber, astring, bytesToNumberBE, numberToHexUnpadded, validateObject, } from "../utils.js";
+const _0n = /* @__PURE__ */ BigInt(0);
+/**
+ * @param m - Error message.
+ * @example
+ * Throw a DER-specific error when signature parsing encounters invalid bytes.
+ *
+ * ```ts
+ * new DERErr('bad der');
+ * ```
+ */
+export class DERErr extends Error {
+    constructor(m = '') {
+        super(m);
+    }
+}
+// Plain const so the freezes can live inside the pure initializer of the `DER` export below:
+// bare top-level `Object.freeze(...)` calls would defeat tree-shaking for every importer.
+const _DER = {
+    // asn.1 DER encoding utils
+    Err: DERErr,
+    // Basic building block is TLV (Tag-Length-Value)
+    _tlv: {
+        encode: (tag, data) => {
+            const { Err: E } = _DER;
+            asafenumber(tag, 'tag');
+            if (tag < 0 || tag > 255)
+                throw new E('tlv.encode: wrong tag');
+            astring(data, 'data');
+            // Internal helper: callers hand this already-validated hex payload, so we only enforce
+            // byte alignment here instead of re-validating every nibble.
+            if (data.length & 1)
+                throw new E('tlv.encode: unpadded data');
+            const dataLen = data.length / 2;
+            const len = numberToHexUnpadded(dataLen);
+            if ((len.length / 2) & 0b1000_0000)
+                throw new E('tlv.encode: long form length too big');
+            // length of length with long form flag
+            const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 0b1000_0000) : '';
+            const t = numberToHexUnpadded(tag);
+            return t + lenLen + len + data;
+        },
+        // v - value, l - left bytes (unparsed)
+        decode(tag, data) {
+            const { Err: E } = _DER;
+            data = abytes(data, undefined, 'DER data');
+            let pos = 0;
+            if (tag < 0 || tag > 255)
+                throw new E('tlv.decode: wrong tag');
+            if (data.length < 2 || data[pos++] !== tag)
+                throw new E('tlv.decode: wrong tlv');
+            const first = data[pos++];
+            // First bit of first length byte is the short/long form flag.
+            const isLong = !!(first & 0b1000_0000);
+            let length = 0;
+            if (!isLong)
+                length = first;
+            else {
+                // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]
+                const lenLen = first & 0b0111_1111;
+                if (!lenLen)
+                    throw new E('tlv.decode(long): indefinite length not supported');
+                // This would overflow u32 in JS.
+                if (lenLen > 4)
+                    throw new E('tlv.decode(long): byte length is too big');
+                const lengthBytes = data.subarray(pos, pos + lenLen);
+                if (lengthBytes.length !== lenLen)
+                    throw new E('tlv.decode: length bytes not complete');
+                if (lengthBytes[0] === 0)
+                    throw new E('tlv.decode(long): zero leftmost byte');
+                for (const b of lengthBytes)
+                    length = (length << 8) | b;
+                pos += lenLen;
+                if (length < 128)
+                    throw new E('tlv.decode(long): not minimal encoding');
+            }
+            const v = data.subarray(pos, pos + length);
+            if (v.length !== length)
+                throw new E('tlv.decode: wrong value length');
+            return { v, l: data.subarray(pos + length) };
+        },
+    },
+    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+    // since we always use positive integers here. It must always be empty:
+    // - add zero byte if exists
+    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+    _int: {
+        encode(num) {
+            const { Err: E } = _DER;
+            abignumber(num);
+            if (num < _0n)
+                throw new E('integer: negative integers are not allowed');
+            let hex = numberToHexUnpadded(num);
+            // Pad with zero byte if negative flag is present
+            if (Number.parseInt(hex[0], 16) & 0b1000)
+                hex = '00' + hex;
+            if (hex.length & 1)
+                throw new E('unexpected DER parsing assertion: unpadded hex');
+            return hex;
+        },
+        decode(data) {
+            const { Err: E } = _DER;
+            if (data.length < 1)
+                throw new E('invalid signature integer: empty');
+            if (data[0] & 0b1000_0000)
+                throw new E('invalid signature integer: negative');
+            // Single-byte zero `00` is the canonical DER INTEGER encoding for zero.
+            if (data.length > 1 && data[0] === 0x00 && !(data[1] & 0b1000_0000))
+                throw new E('invalid signature integer: unnecessary leading zero');
+            return bytesToNumberBE(data);
+        },
+    },
+    toSig(bytes) {
+        // parse DER signature
+        const { Err: E, _int: int, _tlv: tlv } = _DER;
+        const data = abytes(bytes, undefined, 'signature');
+        const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);
+        if (seqLeftBytes.length)
+            throw new E('invalid signature: left bytes after parsing');
+        const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);
+        const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);
+        if (sLeftBytes.length)
+            throw new E('invalid signature: left bytes after parsing');
+        return { r: int.decode(rBytes), s: int.decode(sBytes) };
+    },
+    hexFromSig(sig) {
+        const { _tlv: tlv, _int: int } = _DER;
+        validateObject(sig, { r: 'bigint', s: 'bigint' }, {}, 'sig');
+        const rs = tlv.encode(0x02, int.encode(sig.r));
+        const ss = tlv.encode(0x02, int.encode(sig.s));
+        const seq = rs + ss;
+        return tlv.encode(0x30, seq);
+    },
+};
+/**
+ * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:
+ *
+ *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]
+ *
+ * Docs: {@link https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/ | Let's Encrypt ASN.1 guide} and
+ * {@link https://luca.ntop.org/Teaching/Appunti/asn1.html | Luca Deri's ASN.1 notes}.
+ * @example
+ * ASN.1 DER encoding utilities.
+ *
+ * ```ts
+ * const der = DER.hexFromSig({ r: 1n, s: 2n });
+ * ```
+ */
+export const DER = /* @__PURE__ */ (() => {
+    Object.freeze(_DER._tlv);
+    Object.freeze(_DER._int);
+    return Object.freeze(_DER);
+})();

src/abstract/der.ts

+/**
+ * ASN.1 DER (Distinguished Encoding Rules) helpers for ECDSA signatures.
+ * Only implements the tiny subset needed for `SEQUENCE(INTEGER r, INTEGER s)`.
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import {
+  abignumber,
+  abytes,
+  asafenumber,
+  astring,
+  bytesToNumberBE,
+  numberToHexUnpadded,
+  validateObject,
+  type TArg,
+  type TRet,
+} from '../utils.ts';
+
+const _0n = /* @__PURE__ */ BigInt(0);
+
+/**
+ * @param m - Error message.
+ * @example
+ * Throw a DER-specific error when signature parsing encounters invalid bytes.
+ *
+ * ```ts
+ * new DERErr('bad der');
+ * ```
+ */
+export class DERErr extends Error {
+  constructor(m = '') {
+    super(m);
+  }
+}
+/** DER helper namespace used by ECDSA signature parsing and encoding. */
+export type IDER = {
+  // asn.1 DER encoding utils
+  /**
+   * DER-specific error constructor.
+   * @param m - Error message.
+   * @returns DER-specific error instance.
+   */
+  Err: typeof DERErr;
+  // Basic building block is TLV (Tag-Length-Value)
+  /** Low-level tag-length-value helpers used by DER encoders. */
+  _tlv: {
+    /**
+     * Encode one TLV record.
+     * @param tag - ASN.1 tag byte.
+     * @param data - Hex-encoded value payload.
+     * @returns Encoded TLV string.
+     */
+    encode: (tag: number, data: string) => string;
+    // v - value, l - left bytes (unparsed)
+    /**
+     * Decode one TLV record and return the value plus leftover bytes.
+     * @param tag - Expected ASN.1 tag byte.
+     * @param data - Remaining DER bytes.
+     * @returns Parsed value plus leftover bytes.
+     */
+    decode(tag: number, data: TArg<Uint8Array>): TRet<{ v: Uint8Array; l: Uint8Array }>;
+  };
+  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+  // since we always use positive integers here. It must always be empty:
+  // - add zero byte if exists
+  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+  /** Positive-integer DER helpers used by ECDSA signature encoding. */
+  _int: {
+    /**
+     * Encode one positive bigint as a DER INTEGER.
+     * @param num - Positive integer to encode.
+     * @returns Encoded DER INTEGER.
+     */
+    encode(num: bigint): string;
+    /**
+     * Decode one DER INTEGER into a bigint.
+     * @param data - DER INTEGER bytes.
+     * @returns Decoded bigint.
+     */
+    decode(data: TArg<Uint8Array>): bigint;
+  };
+  /**
+   * Parse a DER signature into `{ r, s }`.
+   * @param bytes - DER signature bytes.
+   * @returns Parsed signature components.
+   */
+  toSig(bytes: TArg<Uint8Array>): { r: bigint; s: bigint };
+  /**
+   * Encode `{ r, s }` as a DER signature.
+   * @param sig - Signature components.
+   * @returns DER-encoded signature hex.
+   */
+  hexFromSig(sig: { r: bigint; s: bigint }): string;
+};
+// Plain const so the freezes can live inside the pure initializer of the `DER` export below:
+// bare top-level `Object.freeze(...)` calls would defeat tree-shaking for every importer.
+const _DER: IDER = {
+  // asn.1 DER encoding utils
+  Err: DERErr,
+  // Basic building block is TLV (Tag-Length-Value)
+  _tlv: {
+    encode: (tag: number, data: string): string => {
+      const { Err: E } = _DER;
+      asafenumber(tag, 'tag');
+      if (tag < 0 || tag > 255) throw new E('tlv.encode: wrong tag');
+      astring(data, 'data');
+      // Internal helper: callers hand this already-validated hex payload, so we only enforce
+      // byte alignment here instead of re-validating every nibble.
+      if (data.length & 1) throw new E('tlv.encode: unpadded data');
+      const dataLen = data.length / 2;
+      const len = numberToHexUnpadded(dataLen);
+      if ((len.length / 2) & 0b1000_0000) throw new E('tlv.encode: long form length too big');
+      // length of length with long form flag
+      const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 0b1000_0000) : '';
+      const t = numberToHexUnpadded(tag);
+      return t + lenLen + len + data;
+    },
+    // v - value, l - left bytes (unparsed)
+    decode(tag: number, data: TArg<Uint8Array>): TRet<{ v: Uint8Array; l: Uint8Array }> {
+      const { Err: E } = _DER;
+      data = abytes(data, undefined, 'DER data');
+      let pos = 0;
+      if (tag < 0 || tag > 255) throw new E('tlv.decode: wrong tag');
+      if (data.length < 2 || data[pos++] !== tag) throw new E('tlv.decode: wrong tlv');
+      const first = data[pos++];
+      // First bit of first length byte is the short/long form flag.
+      const isLong = !!(first & 0b1000_0000);
+      let length = 0;
+      if (!isLong) length = first;
+      else {
+        // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]
+        const lenLen = first & 0b0111_1111;
+        if (!lenLen) throw new E('tlv.decode(long): indefinite length not supported');
+        // This would overflow u32 in JS.
+        if (lenLen > 4) throw new E('tlv.decode(long): byte length is too big');
+        const lengthBytes = data.subarray(pos, pos + lenLen);
+        if (lengthBytes.length !== lenLen) throw new E('tlv.decode: length bytes not complete');
+        if (lengthBytes[0] === 0) throw new E('tlv.decode(long): zero leftmost byte');
+        for (const b of lengthBytes) length = (length << 8) | b;
+        pos += lenLen;
+        if (length < 128) throw new E('tlv.decode(long): not minimal encoding');
+      }
+      const v = data.subarray(pos, pos + length);
+      if (v.length !== length) throw new E('tlv.decode: wrong value length');
+      return { v, l: data.subarray(pos + length) } as TRet<{ v: Uint8Array; l: Uint8Array }>;
+    },
+  },
+  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+  // since we always use positive integers here. It must always be empty:
+  // - add zero byte if exists
+  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+  _int: {
+    encode(num: bigint): string {
+      const { Err: E } = _DER;
+      abignumber(num);
+      if (num < _0n) throw new E('integer: negative integers are not allowed');
+      let hex = numberToHexUnpadded(num);
+      // Pad with zero byte if negative flag is present
+      if (Number.parseInt(hex[0], 16) & 0b1000) hex = '00' + hex;
+      if (hex.length & 1) throw new E('unexpected DER parsing assertion: unpadded hex');
+      return hex;
+    },
+    decode(data: TArg<Uint8Array>): bigint {
+      const { Err: E } = _DER;
+      if (data.length < 1) throw new E('invalid signature integer: empty');
+      if (data[0] & 0b1000_0000) throw new E('invalid signature integer: negative');
+      // Single-byte zero `00` is the canonical DER INTEGER encoding for zero.
+      if (data.length > 1 && data[0] === 0x00 && !(data[1] & 0b1000_0000))
+        throw new E('invalid signature integer: unnecessary leading zero');
+      return bytesToNumberBE(data);
+    },
+  },
+  toSig(bytes: TArg<Uint8Array>): { r: bigint; s: bigint } {
+    // parse DER signature
+    const { Err: E, _int: int, _tlv: tlv } = _DER;
+    const data = abytes(bytes, undefined, 'signature');
+    const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);
+    if (seqLeftBytes.length) throw new E('invalid signature: left bytes after parsing');
+    const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);
+    const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);
+    if (sLeftBytes.length) throw new E('invalid signature: left bytes after parsing');
+    return { r: int.decode(rBytes), s: int.decode(sBytes) };
+  },
+  hexFromSig(sig: { r: bigint; s: bigint }): string {
+    const { _tlv: tlv, _int: int } = _DER;
+    validateObject(sig, { r: 'bigint', s: 'bigint' }, {}, 'sig');
+    const rs = tlv.encode(0x02, int.encode(sig.r));
+    const ss = tlv.encode(0x02, int.encode(sig.s));
+    const seq = rs + ss;
+    return tlv.encode(0x30, seq);
+  },
+};
+
+/**
+ * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:
+ *
+ *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]
+ *
+ * Docs: {@link https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/ | Let's Encrypt ASN.1 guide} and
+ * {@link https://luca.ntop.org/Teaching/Appunti/asn1.html | Luca Deri's ASN.1 notes}.
+ * @example
+ * ASN.1 DER encoding utilities.
+ *
+ * ```ts
+ * const der = DER.hexFromSig({ r: 1n, s: 2n });
+ * ```
+ */
+export const DER: IDER = /* @__PURE__ */ (() => {
+  Object.freeze(_DER._tlv);
+  Object.freeze(_DER._int);
+  return Object.freeze(_DER);
+})();

abstract/bls.d.ts

@@ -139,3 +139,3 @@ /**
      * Build Miller-loop precomputes for one G2 point.
-     * @param p - G2 point to precompute.
+     * @param p - Valid non-ZERO G2 point to precompute.
      * @returns Pairing precompute table.
@@ -192,3 +192,4 @@ */
      * Optional RNG override used by helper constructors.
-     * Receives the requested byte length and returns random bytes.
+     * @param len - Requested byte length.
+     * @returns Random bytes.
      */
@@ -277,3 +278,5 @@ randomBytes?: (len?: number) => TRet<Uint8Array>;
         ateLoopSize: bigint;
+        xNegative: boolean;
         twistType: BlsTwistType;
+        postPrecompute?: BlsPostPrecomputeFn;
     };
@@ -324,2 +327,4 @@ }
      * Verify one signature against one public key and hashed message.
+     * Malformed encoded signatures or keys may throw during point decoding; `false` means
+     * well-formed inputs failed the pairing equation.
      * @param signature - Signature point or encoded signature.
@@ -344,2 +349,4 @@ * @param message - Hashed message point.
      * Add many public keys into one aggregate point.
+     * Encoded inputs are decoded through `fromBytes()`; point instances are treated as already
+     * validated caller-owned objects to keep aggregation linear in additions.
      * @param publicKeys - Public keys to aggregate.
@@ -352,2 +359,4 @@ * @returns Aggregated public-key point. This is raw point addition and does not add proof of
      * Add many signatures into one aggregate point.
+     * Encoded inputs are decoded through `fromBytes()`; point instances are treated as already
+     * validated caller-owned objects to keep aggregation linear in additions.
      * @param signatures - Signatures to aggregate.
@@ -387,4 +396,5 @@ * @returns Aggregated signature point. This is raw point addition and does not change the proof
  * import { bn254 } from '@noble/curves/bn254.js';
- * // Pair a G1 point with a G2 point without the higher-level signer helpers.
- * const gt = bn254.pairing(bn254.G1.Point.BASE, bn254.G2.Point.BASE);
+ * // Rebuild the pairing-only helper from a concrete curve's public pieces.
+ * const pair = blsBasic(bn254.fields, bn254.G1.Point, bn254.G2.Point, bn254.params);
+ * const gt = pair.pairing(pair.G1.Point.BASE, pair.G2.Point.BASE);
  * ```
@@ -408,8 +418,17 @@ */
  * import { bls12_381 } from '@noble/curves/bls12-381.js';
- * const sigs = bls12_381.longSignatures;
- * // Use the full BLS helper set when you need hashing, keygen, signing, and verification.
- * const { secretKey, publicKey } = sigs.keygen();
- * const msg = sigs.hash(new TextEncoder().encode('hello noble'));
- * const sig = sigs.sign(msg, secretKey);
- * const isValid = sigs.verify(sig, msg, publicKey);
+ * // Rebuild a signer namespace from a concrete curve.
+ * // Applications usually import bls12_381 directly.
+ * const rebuilt = bls(
+ *   bls12_381.fields,
+ *   bls12_381.G1.Point,
+ *   bls12_381.G2.Point,
+ *   bls12_381.params,
+ *   {
+ *     hasherOpts: bls12_381.G2.defaults,
+ *     hasherOptsG1: bls12_381.G1.defaults,
+ *     hasherOptsG2: bls12_381.G2.defaults,
+ *   },
+ *   {}
+ * );
+ * const { secretKey, publicKey } = rebuilt.longSignatures.keygen();
  * ```
@@ -419,2 +438,1 @@ */
 export {};
-//# sourceMappingURL=bls.d.ts.map

abstract/bls.js

@@ -18,3 +18,3 @@ /**
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { abytes, notImplemented, randomBytes } from "../utils.js";
+import { aarray, abytes, notImplemented, randomBytes, validateObject, } from "../utils.js";
 import {} from "./curve.js";
@@ -53,8 +53,105 @@ import { createHasher, } from "./hash-to-curve.js";
 function createBlsPairing(fields, G1, G2, params) {
-    const { Fr, Fp2, Fp12 } = fields;
+    validateObject(fields, { Fp: 'object', Fr: 'object', Fp2: 'object', Fp12: 'object' }, { Fp6: 'object' }, 'fields');
+    if (typeof G1 !== 'function')
+        throw new TypeError('"G1_Point" expected point constructor, got type=' + typeof G1);
+    if (typeof G2 !== 'function')
+        throw new TypeError('"G2_Point" expected point constructor, got type=' + typeof G2);
+    validateObject(params, { ateLoopSize: 'bigint', xNegative: 'boolean', twistType: 'string' }, { randomBytes: 'function', postPrecompute: 'function' }, 'params');
+    const { Fp, Fr, Fp2, Fp12 } = fields;
     const { twistType, ateLoopSize, xNegative, postPrecompute } = params;
+    const fp2 = (c0, c1) => ({ c0, c1 });
+    const fp2f = ({ c0, c1 }) => Object.freeze({ c0, c1 });
+    const add2 = (a, b) => fp2(Fp.add(a.c0, b.c0), Fp.add(a.c1, b.c1));
+    const sub2 = (a, b) => fp2(Fp.sub(a.c0, b.c0), Fp.sub(a.c1, b.c1));
+    const mul2 = (a, b) => {
+        const t0 = Fp.mul(a.c0, b.c0);
+        const t1 = Fp.mul(a.c1, b.c1);
+        return fp2(Fp.sub(t0, t1), Fp.sub(Fp.mul(Fp.add(a.c0, a.c1), Fp.add(b.c0, b.c1)), Fp.add(t0, t1)));
+    };
+    const mul2ByFp = (a, rhs) => fp2(Fp.mul(a.c0, rhs), Fp.mul(a.c1, rhs));
+    // Delegates to the tower's mulByNonresidue: it has fast paths for ξ = u+1 / ξ = a+u
+    // (adds/scalar-muls instead of a full Karatsuba Fp2 multiplication).
+    const mul2ByNonresidue = (a) => Fp2.mulByNonresidue(a);
+    const mul014ByLine = ({ c0: f0, c1: f1 }, o0, l1, l4, Px, Py) => {
+        const o1 = mul2ByFp(l1, Px);
+        const o4 = mul2ByFp(l4, Py);
+        const { c0: a0, c1: a1, c2: a2 } = f0;
+        const { c0: b0, c1: b1, c2: b2 } = f1;
+        // t0 = Fp6.mul01(f0, o0, o1)
+        const t0_0 = mul2(a0, o0);
+        const t0_1 = mul2(a1, o1);
+        const t0_c0 = add2(mul2ByNonresidue(sub2(mul2(add2(a1, a2), o1), t0_1)), t0_0);
+        const t0_c1 = sub2(sub2(mul2(add2(o0, o1), add2(a0, a1)), t0_0), t0_1);
+        const t0_c2 = add2(sub2(mul2(add2(a0, a2), o0), t0_0), t0_1);
+        // t1 = Fp6.mul1(f1, o4)
+        const t1_c0 = mul2ByNonresidue(mul2(b2, o4));
+        const t1_c1 = mul2(b0, o4);
+        const t1_c2 = mul2(b1, o4);
+        // t2 = Fp6.mul01(Fp6.add(f0, f1), o0, Fp2.add(o1, o4))
+        const s0 = add2(a0, b0);
+        const s1 = add2(a1, b1);
+        const s2 = add2(a2, b2);
+        const o14 = add2(o1, o4);
+        const t2_0 = mul2(s0, o0);
+        const t2_1 = mul2(s1, o14);
+        const t2_c0 = add2(mul2ByNonresidue(sub2(mul2(add2(s1, s2), o14), t2_1)), t2_0);
+        const t2_c1 = sub2(sub2(mul2(add2(o0, o14), add2(s0, s1)), t2_0), t2_1);
+        const t2_c2 = add2(sub2(mul2(add2(s0, s2), o0), t2_0), t2_1);
+        return Object.freeze({
+            c0: Object.freeze({
+                c0: fp2f(add2(mul2ByNonresidue(t1_c2), t0_c0)),
+                c1: fp2f(add2(t1_c0, t0_c1)),
+                c2: fp2f(add2(t1_c1, t0_c2)),
+            }),
+            c1: Object.freeze({
+                c0: fp2f(sub2(sub2(t2_c0, t0_c0), t1_c0)),
+                c1: fp2f(sub2(sub2(t2_c1, t0_c1), t1_c1)),
+                c2: fp2f(sub2(sub2(t2_c2, t0_c2), t1_c2)),
+            }),
+        });
+    };
+    // Like mul014ByLine, params are named after the sparse slot they end up in: l0 is scaled by
+    // Py into o0, l3 is scaled by Px into o3, o4 is used as-is.
+    const mul034ByLine = ({ c0: f0, c1: f1 }, l0, l3, o4, Px, Py) => {
+        const o0 = mul2ByFp(l0, Py);
+        const o3 = mul2ByFp(l3, Px);
+        const { c0: a0, c1: a1, c2: a2 } = f0;
+        const { c0: b0, c1: b1, c2: b2 } = f1;
+        // a = f0 * o0
+        const a_c0 = mul2(a0, o0);
+        const a_c1 = mul2(a1, o0);
+        const a_c2 = mul2(a2, o0);
+        // b = Fp6.mul01(f1, o3, o4)
+        const b0m = mul2(b0, o3);
+        const b1m = mul2(b1, o4);
+        const b_c0 = add2(mul2ByNonresidue(sub2(mul2(add2(b1, b2), o4), b1m)), b0m);
+        const b_c1 = sub2(sub2(mul2(add2(o3, o4), add2(b0, b1)), b0m), b1m);
+        const b_c2 = add2(sub2(mul2(add2(b0, b2), o3), b0m), b1m);
+        // e = Fp6.mul01(Fp6.add(f0, f1), Fp2.add(o0, o3), o4)
+        const s0 = add2(a0, b0);
+        const s1 = add2(a1, b1);
+        const s2 = add2(a2, b2);
+        const o03 = add2(o0, o3);
+        const e0m = mul2(s0, o03);
+        const e1m = mul2(s1, o4);
+        const e_c0 = add2(mul2ByNonresidue(sub2(mul2(add2(s1, s2), o4), e1m)), e0m);
+        const e_c1 = sub2(sub2(mul2(add2(o03, o4), add2(s0, s1)), e0m), e1m);
+        const e_c2 = add2(sub2(mul2(add2(s0, s2), o03), e0m), e1m);
+        return Object.freeze({
+            c0: Object.freeze({
+                c0: fp2f(add2(mul2ByNonresidue(b_c2), a_c0)),
+                c1: fp2f(add2(b_c0, a_c1)),
+                c2: fp2f(add2(b_c1, a_c2)),
+            }),
+            c1: Object.freeze({
+                c0: fp2f(sub2(sub2(e_c0, a_c0), b_c0)),
+                c1: fp2f(sub2(sub2(e_c1, a_c1), b_c1)),
+                c2: fp2f(sub2(sub2(e_c2, a_c2), b_c2)),
+            }),
+        });
+    };
     // Applies sparse multiplication as line function
     let lineFunction;
     if (twistType === 'multiplicative') {
-        lineFunction = (c0, c1, c2, f, Px, Py) => Fp12.mul014(f, c0, Fp2.mul(c1, Px), Fp2.mul(c2, Py));
+        lineFunction = (c0, c1, c2, f, Px, Py) => mul014ByLine(f, c0, c1, c2, Px, Py);
     }
@@ -64,3 +161,3 @@ else if (twistType === 'divisive') {
         // precompute calculations.
-        lineFunction = (c0, c1, c2, f, Px, Py) => Fp12.mul034(f, Fp2.mul(c2, Py), Fp2.mul(c1, Px), c0);
+        lineFunction = (c0, c1, c2, f, Px, Py) => mul034ByLine(f, c2, c1, c0, Px, Py);
     }
@@ -110,2 +207,4 @@ else
     const calcPairingPrecomputes = (point) => {
+        if (!(point instanceof G2))
+            throw new TypeError('"point" expected G2 point, got type=' + typeof point);
         const p = point;
@@ -132,2 +231,8 @@ const { x, y } = p.toAffine();
     function millerLoopBatch(pairs, withFinalExponent = false) {
+        aarray(pairs, 'pairs', (pair, title) => {
+            aarray(pair, title);
+            if (pair.length !== 3)
+                throw new TypeError(`"${title}" expected precompute tuple`);
+            aarray(pair[0], title + '[0]');
+        });
         let f12 = Fp12.ONE;
@@ -137,3 +242,5 @@ if (pairs.length) {
             for (let i = 0; i < ellLen; i++) {
-                f12 = Fp12.sqr(f12); // This allows us to do sqr only one time for all pairings
+                // sqr only one time for all pairings; skip sqr(ONE) at i=0
+                if (i !== 0)
+                    f12 = Fp12.sqr(f12);
                 // NOTE: we apply multiple pairings in parallel here
@@ -153,4 +260,12 @@ for (const [ell, Px, Py] of pairs) {
     function pairingBatch(pairs, withFinalExponent = true) {
+        aarray(pairs, 'pairs');
         const res = [];
-        for (const { g1, g2 } of pairs) {
+        for (let i = 0; i < pairs.length; i++) {
+            const pair = pairs[i];
+            validateObject(pair, { g1: 'object', g2: 'object' }, {}, 'pairs[' + i + ']');
+            const { g1, g2 } = pair;
+            if (!(g1 instanceof G1))
+                throw new TypeError('"pairs[' + i + '].g1" expected G1 point, got type=' + typeof g1);
+            if (!(g2 instanceof G2))
+                throw new TypeError('"pairs[' + i + '].g2" expected G2 point, got type=' + typeof g2);
             // Mathematically, a zero pairing term contributes GT.ONE. We still reject it here because
@@ -172,2 +287,6 @@ // this API mainly backs BLS verification, where ZERO inputs usually mean broken hash /
     function pairing(Q, P, withFinalExponent = true) {
+        if (!(Q instanceof G1))
+            throw new TypeError('"Q" expected G1 point, got type=' + typeof Q);
+        if (!(P instanceof G2))
+            throw new TypeError('"P" expected G2 point, got type=' + typeof P);
         return pairingBatch([{ g1: Q, g2: P }], withFinalExponent);
@@ -208,2 +327,3 @@ }
     }
+    const sigCoder = SignatureCoder;
     function normPub(point) {
@@ -213,3 +333,3 @@ return point instanceof PubPoint ? point : PubPoint.fromBytes(point);
     function normSig(point) {
-        return point instanceof SigPoint ? point : SigPoint.fromBytes(point);
+        return point instanceof SigPoint ? point : sigCoder.fromBytes(point);
     }
@@ -252,2 +372,3 @@ // Sign/verify here take points already hashed onto the signature subgroup.
             const sec = PubPoint.Fn.fromBytes(secretKey);
+            // BLS/BN point APIs allow infinity for compatibility; raw message bytes still fail amsg().
             amsg(message).assertValidity();
@@ -286,3 +407,3 @@ return message.multiply(sec);
             const sig = normSig(signature);
-            const nMessages = items.map((i) => i.message);
+            const nMessages = items.map((i) => amsg(i.message));
             const nPublicKeys = items.map((i) => normPub(i.publicKey));
@@ -335,6 +456,7 @@ // NOTE: this works only for exact same object
             abytes(messageBytes);
-            const opts = DST ? { DST } : undefined;
+            // Only omitted DST uses the default; explicit empty DST must reach normDST validation.
+            const opts = DST === undefined ? undefined : { DST };
             return hashToSigCurve(messageBytes, opts);
         },
-        Signature: Object.freeze({ ...SignatureCoder }),
+        Signature: Object.freeze({ ...sigCoder }),
     }) /*satisfies Signer */;
@@ -358,4 +480,5 @@ }
  * import { bn254 } from '@noble/curves/bn254.js';
- * // Pair a G1 point with a G2 point without the higher-level signer helpers.
- * const gt = bn254.pairing(bn254.G1.Point.BASE, bn254.G2.Point.BASE);
+ * // Rebuild the pairing-only helper from a concrete curve's public pieces.
+ * const pair = blsBasic(bn254.fields, bn254.G1.Point, bn254.G2.Point, bn254.params);
+ * const gt = pair.pairing(pair.G1.Point.BASE, pair.G2.Point.BASE);
  * ```
@@ -386,3 +509,5 @@ */
             ateLoopSize: params.ateLoopSize,
+            xNegative: params.xNegative,
             twistType: params.twistType,
+            postPrecompute: params.postPrecompute,
         }),
@@ -398,2 +523,3 @@ utils: Object.freeze({
     const base = blsBasic(fields, G1_Point, G2_Point, params);
+    validateObject(hasherParams, { hasherOpts: 'object', hasherOptsG1: 'object', hasherOptsG2: 'object' }, { mapToG1: 'function', mapToG2: 'function' }, 'hasherParams');
     // Missing map hooks intentionally fail closed via notImplemented on first hash use.
@@ -427,8 +553,17 @@ const G1Hasher = createHasher(G1_Point, hasherParams.mapToG1 === undefined ? notImplemented : hasherParams.mapToG1, {
  * import { bls12_381 } from '@noble/curves/bls12-381.js';
- * const sigs = bls12_381.longSignatures;
- * // Use the full BLS helper set when you need hashing, keygen, signing, and verification.
- * const { secretKey, publicKey } = sigs.keygen();
- * const msg = sigs.hash(new TextEncoder().encode('hello noble'));
- * const sig = sigs.sign(msg, secretKey);
- * const isValid = sigs.verify(sig, msg, publicKey);
+ * // Rebuild a signer namespace from a concrete curve.
+ * // Applications usually import bls12_381 directly.
+ * const rebuilt = bls(
+ *   bls12_381.fields,
+ *   bls12_381.G1.Point,
+ *   bls12_381.G2.Point,
+ *   bls12_381.params,
+ *   {
+ *     hasherOpts: bls12_381.G2.defaults,
+ *     hasherOptsG1: bls12_381.G1.defaults,
+ *     hasherOptsG2: bls12_381.G2.defaults,
+ *   },
+ *   {}
+ * );
+ * const { secretKey, publicKey } = rebuilt.longSignatures.keygen();
  * ```
@@ -449,2 +584,1 @@ */
 }
-//# sourceMappingURL=bls.js.map

abstract/curve.d.ts

 /**
  * Methods for elliptic curve multiplication by scalars.
- * Contains wNAF, pippenger.
+ * Contains wNAF-based ScalarMultiplier, pippenger.
  * @module
@@ -93,3 +93,4 @@ */
     /**
-     * Massively speeds up `p.multiply(n)` by using precompute tables (caching). See {@link wNAF}.
+     * Massively speeds up `p.multiply(n)` by using precompute tables (caching).
+     * See {@link ScalarMultiplier}.
      * Cache state lives in internal WeakMaps keyed by point identity, not on the point object.
@@ -200,20 +201,2 @@ * Repeating `precompute(...)` for the same point identity replaces the remembered window size
 /**
- * Computes both candidates first, but the final selection still branches on `condition`, so this
- * is not a strict constant-time CMOV primitive.
- * @param condition - Whether to negate the point.
- * @param item - Point-like value.
- * @returns Original or negated value.
- * @example
- * Keep the point or return its negation based on one boolean branch.
- *
- * ```ts
- * import { negateCt } from '@noble/curves/abstract/curve.js';
- * import { p256 } from '@noble/curves/nist.js';
- * const maybeNegated = negateCt(true, p256.Point.BASE);
- * ```
- */
-export declare function negateCt<T extends {
-    negate: () => T;
-}>(condition: boolean, item: T): T;
-/**
  * Takes a bunch of Projective Points but executes only one
@@ -237,21 +220,52 @@ * inversion on all of them. Inversion is very slow operation,
 export declare function normalizeZ<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(c: PC, points: P[]): P[];
+/** RNG interface used for scalar / nonce blinding. */
+export type RandomBytes = (bytesLength?: number) => TRet<Uint8Array>;
 /**
- * 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.
+ * Probes an RNG once, at construction time: returns `undefined` when it is unavailable —
+ * throws or returns malformed bytes — so callers can downgrade to their unblinded /
+ * deterministic constant-time fallback. Blinding is defense-in-depth (DPA/template
+ * hardening), not a correctness or key-secrecy requirement, so availability-based
+ * downgrade is acceptable.
  *
- * 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
+ * The downgrade decision is deliberately static. After a successful probe the RNG becomes
+ * part of the trusted contract: later misbehavior must fail closed in per-call validation
+ * (throw), never downgrade — a dynamic fallback would let a tampered RNG silently strip
+ * blinding on demand. A probe can only ever classify broken environments, not adversarial
+ * RNGs: a stateful RNG can always behave while probed and misbehave later.
+ * @param randomBytes - RNG to probe, or `undefined` when the environment provides none.
+ * @param length - Byte length requested from the probe call.
+ * @returns The RNG when the probe produced `length` valid bytes; `undefined` otherwise.
+ * @example
+ * Probe an RNG once before enabling scalar blinding.
  *
- * TODO: research returning a 2d JS array of windows instead of a single window.
- * This would allow windows to be in different memory locations.
+ * ```ts
+ * import { probeRandomBytes } from '@noble/curves/abstract/curve.js';
+ * import { randomBytes } from '@noble/hashes/utils.js';
+ * const rng = probeRandomBytes(randomBytes, 16);
+ * ```
+ */
+export declare function probeRandomBytes(randomBytes: TArg<RandomBytes | undefined>, length: number): TRet<RandomBytes | undefined>;
+/** Result of a constant-time multiply: real point `p`, fake accumulator `f` (discarded). */
+type MulResult<P> = {
+    p: P;
+    f: P;
+};
+/**
+ * Elliptic curve multiplication of Point by scalar.
+ * Routes between cached-table, fixed-window, and one-shot wNAF paths; entry points validate
+ * their own scalars (`mulCT`/`mulCTBlinded`: `1 <= s < Fn.ORDER`; `mulUnsafe`: up to the
+ * `Fn.ORDER^4` DoS cap via {@link mulAddUnsafe}).
+ * Table generation is expensive and happens on first call of `multiply()`
+ * (or eagerly via `precompute(W, false)`). By default, `BASE` point is precomputed.
+ *
+ * Cached algorithm is signed fixed-window wNAF:
+ * - table stores, for every window w, the multiples `[1..2^(W−1)]⋅2^(w⋅W)⋅P` — all doublings
+ *   are baked in, so a multiplication is exactly one table addition per window
+ * - window count is fixed (`ceil(bits/W) + 1`), so the point-operation count is scalar-independent
+ *   (basis of the constant-time path)
+ * - for a 256-bit curve and W=6: 44⋅32 = 1408 table points, 44 additions per multiply
+ * - secret scalars are additionally blinded (see {@link ScalarMultiplier.mulCTBlinded}), which
+ *   widens tables by 128 bits
  * @param Point - Point constructor.
- * @param bits - Scalar bit length.
+ * @param randomBytes - RNG used for scalar blinding; required by the blinded secret path.
  * @example
@@ -261,71 +275,94 @@ * Elliptic curve multiplication of Point by scalar.
  * ```ts
- * import { wNAF } from '@noble/curves/abstract/curve.js';
+ * import { ScalarMultiplier } from '@noble/curves/abstract/curve.js';
  * import { p256 } from '@noble/curves/nist.js';
- * const ladder = new wNAF(p256.Point, p256.Point.Fn.BITS);
+ * const mul = new ScalarMultiplier(p256.Point);
  * ```
  */
-export declare class wNAF<PC extends PC_ANY> {
+export declare class ScalarMultiplier<PC extends PC_ANY> {
+    private readonly Point;
     private readonly BASE;
     private readonly ZERO;
-    private readonly Fn;
+    private readonly randomBytes?;
+    private readonly wnafPrecomputes;
+    private baseCanBeBlinded;
     readonly bits: number;
-    constructor(Point: PC, bits: number);
-    _unsafeLadder(elm: PC_P<PC>, n: bigint, p?: PC_P<PC>): PC_P<PC>;
+    constructor(Point: PC, randomBytes?: RandomBytes);
     /**
-     * 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.
+     * Creates a signed fixed-window wNAF precomputation table: for every window w, the
+     * multiples `[1..2^(W−1)]⋅2^(w⋅W)⋅P`, flattened. All doublings are baked into the table,
+     * so cached multiplication is additions-only. `windows = ceil(bits/W) + 1`: the extra
+     * window absorbs the final carry of signed-digit recoding.
+     * For a 256-bit curve and W=6, the table is 44⋅32 = 1408 points.
      * @param point - Point instance
      * @param W - window size
-     * @returns precomputed point tables flattened to a single array
+     * @param bits - scalar bitlength the table must cover
      */
-    private precomputeWindow;
+    private buildWnafTable;
     /**
-     * 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
+     * Implements ec multiplication using precomputed signed fixed-window wNAF tables.
+     * Constant-time: fixed window count with one table addition per window — zero digits feed
+     * the fake accumulator — and no doublings; the lookup scans the whole window slice.
+     * Scalar bounds are validated by the public entry points ({@link ScalarMultiplier.mulCT},
+     * {@link ScalarMultiplier.mulCTBlinded}, {@link ScalarMultiplier.mulUnsafe});
+     * signedWindowDigits throws if `n` exceeds the table.
      * @returns real and fake (for const-time) points
      */
-    private wNAF;
+    private wnafCachedCT;
+    private getWnafPrecomputes;
+    private assertPoint;
+    private validateMulInput;
+    private runCT;
+    mulCT(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>): MulResult<PC_P<PC>>;
+    mulCTBlinded(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>): MulResult<PC_P<PC>>;
     /**
-     * Implements unsafe EC multiplication using precomputed tables
-     * and w-ary non-adjacent form.
-     * @param acc - accumulator point to add result of multiplication
-     * @returns point
+     * Constant-time multiplication `n*point` for an un-precomputed point, via a small fixed window.
+     * A cached wNAF table only pays off when reused; a flat 2^FW_WINDOW table (`size-1` adds) is
+     * far cheaper to build for a single use. The point-operation sequence is independent of `n`:
+     * build the table, then per window exactly FW_WINDOW doublings, a data-oblivious scan over
+     * every table entry, and one addition (adds the identity when the window digit is 0 — never
+     * skipped).
+     *
+     * `n` must be `< 2^bits`. Assumes complete addition (adding the identity costs the same as any
+     * add), which holds for the Weierstrass/Edwards point types used here. The table is left in
+     * projective form (no normalizeZ): normalizing this small a table costs more than the
+     * mixed-add savings it would buy for a single multiply.
+     * @returns real point `p`; `f` duplicates it only to match {@link wnafCachedCT}'s return shape
+     * (this path needs no fake accumulator — its op-count is already scalar-independent).
      */
-    private wNAFUnsafe;
-    private getPrecomputes;
-    cached(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>): {
-        p: PC_P<PC>;
-        f: PC_P<PC>;
-    };
-    unsafe(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>, prev?: PC_P<PC>): PC_P<PC>;
-    createCache(P: PC_P<PC>, W: number): void;
-    hasCache(elm: PC_P<PC>): boolean;
+    private fixedWindowCT;
+    private shouldBlind;
+    mulSecret(point: PC_P<PC>, scalar: bigint, cofactor: bigint, transform?: Mapper<PC_P<PC>>): MulResult<PC_P<PC>>;
+    mulUnsafe(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>): PC_P<PC>;
+    setWindowSize(point: PC_P<PC>, W: number): void;
+    hasWindowSize(point: PC_P<PC>): boolean;
 }
 /**
- * Endomorphism-specific multiplication for Koblitz curves.
- * Cost: 128 dbl, 0-256 adds.
- * @param Point - Point constructor.
- * @param point - Input point.
- * @param k1 - First non-negative absolute scalar chunk.
- * @param k2 - Second non-negative absolute scalar chunk.
- * @returns Partial multiplication results.
+ * Combined multi-scalar multiplication `Σ scalars[i]⋅points[i]` via interleaved width-4 wNAF
+ * (Strauss–Shamir). Every input gets its own table of odd multiples `[1P, 3P, 5P, 7P]` and
+ * signed-digit recoding, but all walks share one doubling chain, so total cost is
+ * `~bits` doublings + `L⋅bits/5` additions instead of `L⋅bits` doublings for separate
+ * multiplications. Intended for the 2-4 point shapes of signature verification
+ * (`R = u1⋅G + u2⋅P`); use {@link pippenger} for larger batches.
+ *
+ * Not constant-time: only for public inputs. Scalars must satisfy `0 <= s < Fn.ORDER`;
+ * fold negative signs into the points before calling.
+ * @param c - Point constructor.
+ * @param points - Array of curve points.
+ * @param scalars - Array of non-negative scalars, same length as points.
+ * @param allowOversized - Replace the `s < Fn.ORDER` scalar check with a `Fn.ORDER^4` DoS cap.
+ *   Off by default. For scalars that must NOT be reduced mod ORDER: torsion checks
+ *   (`Fn.ORDER⋅P ≟ O`) and cofactor-clearing multiples. Walk length grows with `bitLen(s)`.
+ * @returns Combined multiplication result; identity for empty input.
+ * @throws If the point set or scalar set is invalid. {@link Error}
  * @example
- * Endomorphism-specific multiplication for Koblitz curves.
+ * Combined multi-scalar multiplication via Strauss–Shamir.
  *
  * ```ts
- * import { mulEndoUnsafe } from '@noble/curves/abstract/curve.js';
- * import { secp256k1 } from '@noble/curves/secp256k1.js';
- * const parts = mulEndoUnsafe(secp256k1.Point, secp256k1.Point.BASE, 3n, 5n);
+ * import { mulAddUnsafe } from '@noble/curves/abstract/curve.js';
+ * import { p256 } from '@noble/curves/nist.js';
+ * const G = p256.Point.BASE;
+ * const R = mulAddUnsafe(p256.Point, [G, G.double()], [2n, 3n]); // 2⋅G + 3⋅(2⋅G)
  * ```
  */
-export declare function mulEndoUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(Point: PC, point: P, k1: bigint, k2: bigint): {
-    p1: P;
-    p2: P;
-};
+export declare function mulAddUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(c: PC, points: P[], scalars: bigint[], allowOversized?: boolean): P;
 /**
@@ -335,3 +372,9 @@ * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
  * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.
- * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.
+ * Point-operation count is scalar-independent (for same L), even when 1 point + scalar, or when
+ * scalar = 0 — but bucket indices are scalar windows, so the memory-access pattern is
+ * scalar-dependent: do not rely on this for secret scalars.
+ *
+ * A repaired LFG bucket-set variant from ePrint 2024/750 was benchmarked on BLS12-381 G1
+ * against this implementation: ~1.4x faster at 2048 points and ~1.1-1.25x faster at
+ * 4096-32768 points, at the cost of extra recoding and multiplier-table complexity.
  * @param c - Curve Point constructor
@@ -353,20 +396,33 @@ * @param points - array of L curve points
 /**
- * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
+ * Interleaved wNAF multi-scalar multiplication (MSM, Pa + Qb + Rc + ...) over a FIXED set
+ * of points: each point gets a one-time table of odd multiples
+ * `[1P, 3P, ..., (2^(W−1)−1)P]`, and the returned closure evaluates MSMs against those
+ * tables. All scalars share one doubling chain (Straus 1964) — one doubling per scalar bit
+ * plus one signed table addition per nonzero width-W wNAF digit (density ~1/(W+1)) — the
+ * "interleaving" method of Möller, "Algorithms for multi-exponentiation" (SAC 2001).
+ *
+ * Table memory is `L⋅2^(W−2)` points, capped at ~2 GiB. Prefer this over {@link pippenger}
+ * when the same points are reused across many MSMs (fixed-base commitments etc.) and up to a
+ * few hundred points; prefer pippenger for one-shot MSMs or thousands of points, where
+ * bucketing beats per-point tables.
+ *
+ * Not constant-time (zero digits are skipped): public inputs only.
  * @param c - Curve Point constructor
- * @param points - array of L curve points
- * @param windowSize - Precompute window size.
- * @returns Function which multiplies points with scalars. The closure accepts
- *   `scalars.length <= points.length`, and omitted trailing scalars are treated as zero.
+ * @param points - array of L curve points, captured by the returned closure
+ * @param windowSize - window width W in bits, from 2 to Fn.BITS; also capped so the
+ *   per-closure tables stay under ~2 GiB
+ * @returns Function which multiplies points with scalars. The closure accepts at most
+ *   `points.length` scalars, and omitted trailing scalars are treated as zero.
  * @throws If the point set or precompute window is invalid. {@link Error}
  * @example
- * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
+ * Interleaved wNAF multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
  *
  * ```ts
- * import { precomputeMSMUnsafe } from '@noble/curves/abstract/curve.js';
+ * import { interleavedMSMUnsafe } from '@noble/curves/abstract/curve.js';
  * import { p256 } from '@noble/curves/nist.js';
- * const msm = precomputeMSMUnsafe(p256.Point, [p256.Point.BASE], 4);
+ * const msm = interleavedMSMUnsafe(p256.Point, [p256.Point.BASE], 4);
  * const point = msm([3n]);
  * ```
  */
-export declare function precomputeMSMUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(c: PC, points: P[], windowSize: number): (scalars: bigint[]) => P;
+export declare function interleavedMSMUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(c: PC, points: P[], windowSize: number): (scalars: bigint[]) => P;
 /** Minimal curve parameters needed to construct a Weierstrass or Edwards curve. */
@@ -404,3 +460,3 @@ export type ValidCurveParams<T> = {
  * @param CURVE - Curve parameters.
- * @param curveOpts - Optional field overrides:
+ * @param curveOpts - Optional field overrides. See {@link FpFn}:
  *   - `Fp` (optional): Optional base-field override.
@@ -429,3 +485,3 @@ *   - `Fn` (optional): Optional scalar-field override.
 }>;
-type KeygenFn = (seed?: Uint8Array, isCompressed?: boolean) => {
+type KeygenFn = (seed?: Uint8Array) => {
     secretKey: Uint8Array;
@@ -450,2 +506,1 @@ publicKey: Uint8Array;
 export {};
-//# sourceMappingURL=curve.d.ts.map

abstract/curve.js

 /**
  * Methods for elliptic curve multiplication by scalars.
- * Contains wNAF, pippenger.
+ * Contains wNAF-based ScalarMultiplier, pippenger.
  * @module
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { bitLen, bitMask, validateObject } from "../utils.js";
+import { aarray, abool, afunction, aobject, bitLen, bitMask, bytesToNumberBE, inRange, isBytes, isPosBig, validateObject, } from "../utils.js";
 import { Field, FpInvertBatch, validateField } from "./modular.js";
 const _0n = /* @__PURE__ */ BigInt(0);
 const _1n = /* @__PURE__ */ BigInt(1);
+const _4n = /* @__PURE__ */ BigInt(4);
+const BLIND_BYTES = 16;
+const BLIND_BITS = 128;
+// Fixed-window width for the constant-time multiply of un-precomputed points (W===1).
+// A flat 2^FW_WINDOW table has a small, scalar-independent build cost that amortizes over a single
+// multiply, unlike the larger per-point wNAF tables that only pay off when cached.
+const FW_WINDOW = 5;
+// Precompute tables are capped at ~2 GiB of estimated heap. Rejecting larger windows up front
+// turns a typo'd window size into an immediate error instead of a multi-GB allocation (or an
+// effective hang) when the lazy table is built on first multiply.
+const TABLE_BYTES_MAX = /* @__PURE__ */ (() => 2 ** 31)();
 /**
@@ -29,17 +40,10 @@ * Validates the static surface of a point constructor.
     if (typeof pc !== 'function')
-        throw new TypeError('Point must be a constructor');
-    // validateObject only accepts plain objects, so copy the constructor statics into one bag first.
-    validateObject({
-        Fp: pc.Fp,
-        Fn: pc.Fn,
-        fromAffine: pc.fromAffine,
-        fromBytes: pc.fromBytes,
-        fromHex: pc.fromHex,
-    }, {
-        Fp: 'object',
-        Fn: 'object',
-        fromAffine: 'function',
-        fromBytes: 'function',
-        fromHex: 'function',
-    });
+        throw new TypeError('"Point" expected constructor, got type=' + typeof Point);
+    afunction(pc.fromAffine, 'Point.fromAffine');
+    afunction(pc.fromBytes, 'Point.fromBytes');
+    afunction(pc.fromHex, 'Point.fromHex');
+    // Generic helpers (ScalarMultiplier, normalizeZ, MSM) dereference BASE / ZERO:
+    // fail here with a typed error instead of an `undefined` access later.
+    aobject(pc.BASE, 'Point.BASE');
+    aobject(pc.ZERO, 'Point.ZERO');
     validateField(pc.Fp);
@@ -49,21 +53,2 @@ validateField(pc.Fn);
 /**
- * Computes both candidates first, but the final selection still branches on `condition`, so this
- * is not a strict constant-time CMOV primitive.
- * @param condition - Whether to negate the point.
- * @param item - Point-like value.
- * @returns Original or negated value.
- * @example
- * Keep the point or return its negation based on one boolean branch.
- *
- * ```ts
- * import { negateCt } from '@noble/curves/abstract/curve.js';
- * import { p256 } from '@noble/curves/nist.js';
- * const maybeNegated = negateCt(true, p256.Point.BASE);
- * ```
- */
-export function negateCt(condition, item) {
-    const neg = item.negate();
-    return condition ? neg : item;
-}
-/**
  * Takes a bunch of Projective Points but executes only one
@@ -87,43 +72,67 @@ * inversion on all of them. Inversion is very slow operation,
 export function normalizeZ(c, points) {
+    // Match MSM helpers: reject malformed public inputs before reading projective internals.
+    validatePointCons(c);
+    validateMSMPoints(points, c);
+    // Identity points (Z=0) rely on an implicit contract: FpInvertBatch without `passZero`
+    // yields `undefined` for zero inputs, and `toAffine(undefined)` falls back to its internal
+    // is0 handling instead of using the batch inverse.
     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 validateW(W, bits, min = 1) {
+    if (!Number.isSafeInteger(W) || W < min || W > bits)
+        throw new Error('invalid window size, expected [' + min + '..' + bits + '], got W=' + W);
 }
-function calcWOpts(W, scalarBits) {
-    validateW(W, scalarBits);
-    const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero
-    const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero
-    const maxNumber = 2 ** W; // W=8 256
-    const mask = bitMask(W); // W=8 255 == mask 0b11111111
-    const shiftBy = BigInt(W); // W=8 8
-    return { windows, windowSize, mask, maxNumber, shiftBy };
+// Rough per-point heap estimate for the {@link TABLE_BYTES_MAX} cap: up to 4 projective/extended
+// coordinates of Fp.BYTES each, plus bigint/object overhead. Callers pass the point count of the
+// largest table the checked parameters can produce.
+function validateTableBytes(numPoints, fpBytes) {
+    const bytes = numPoints * (4 * fpBytes + 128);
+    if (bytes > TABLE_BYTES_MAX)
+        throw new Error('invalid window size: table would need ~' +
+            Math.ceil(bytes / 2 ** 20) +
+            ' MiB, max ' +
+            TABLE_BYTES_MAX / 2 ** 20 +
+            ' MiB');
 }
-function calcOffsets(n, window, wOpts) {
-    const { windowSize, mask, maxNumber, shiftBy } = wOpts;
-    let wbits = Number(n & mask); // extract W bits.
-    let nextN = n >> shiftBy; // shift number by W bits.
-    // What actually happens here:
-    // const highestBit = Number(mask ^ (mask >> 1n));
-    // let wbits2 = wbits - 1; // skip zero
-    // if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);
-    // split if bits > max: +224 => 256-32
-    if (wbits > windowSize) {
-        // we skip zero, which means instead of `>= size-1`, we do `> size`
-        wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.
-        nextN += _1n; // +256 (carry)
+/**
+ * Probes an RNG once, at construction time: returns `undefined` when it is unavailable —
+ * throws or returns malformed bytes — so callers can downgrade to their unblinded /
+ * deterministic constant-time fallback. Blinding is defense-in-depth (DPA/template
+ * hardening), not a correctness or key-secrecy requirement, so availability-based
+ * downgrade is acceptable.
+ *
+ * The downgrade decision is deliberately static. After a successful probe the RNG becomes
+ * part of the trusted contract: later misbehavior must fail closed in per-call validation
+ * (throw), never downgrade — a dynamic fallback would let a tampered RNG silently strip
+ * blinding on demand. A probe can only ever classify broken environments, not adversarial
+ * RNGs: a stateful RNG can always behave while probed and misbehave later.
+ * @param randomBytes - RNG to probe, or `undefined` when the environment provides none.
+ * @param length - Byte length requested from the probe call.
+ * @returns The RNG when the probe produced `length` valid bytes; `undefined` otherwise.
+ * @example
+ * Probe an RNG once before enabling scalar blinding.
+ *
+ * ```ts
+ * import { probeRandomBytes } from '@noble/curves/abstract/curve.js';
+ * import { randomBytes } from '@noble/hashes/utils.js';
+ * const rng = probeRandomBytes(randomBytes, 16);
+ * ```
+ */
+export function probeRandomBytes(randomBytes, length) {
+    if (randomBytes === undefined)
+        return undefined;
+    afunction(randomBytes, 'randomBytes');
+    try {
+        const probe = randomBytes(length);
+        if (!isBytes(probe) || probe.length !== length)
+            return undefined;
     }
-    const offsetStart = window * windowSize;
-    const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero; ignore when isZero
-    const isZero = wbits === 0; // is current window slice a 0?
-    const isNeg = wbits < 0; // is current window slice negative?
-    const isNegF = window % 2 !== 0; // fake branch noise only
-    const offsetF = offsetStart; // fake branch noise only
-    return { nextN, offset, isZero, isNeg, isNegF, offsetF };
+    catch {
+        return undefined;
+    }
+    return randomBytes;
 }
 function validateMSMPoints(points, c) {
-    if (!Array.isArray(points))
-        throw new Error('array expected');
+    aarray(points, 'points');
     points.forEach((p, i) => {
@@ -134,46 +143,114 @@ if (!(p instanceof c))
 }
-function validateMSMScalars(scalars, field) {
+// Default bound is field membership (0 <= s < field.ORDER); a `maxScalar` override widens it
+// to 0 <= s < maxScalar for callers that accept oversized scalars.
+function validateMSMScalars(scalars, field, maxScalar) {
     if (!Array.isArray(scalars))
         throw new Error('array of scalars expected');
     scalars.forEach((s, i) => {
-        if (!field.isValid(s))
+        const ok = maxScalar === undefined ? field.isValid(s) : isPosBig(s) && s < maxScalar;
+        if (!ok)
             throw new Error('invalid scalar at index ' + i);
     });
 }
-// Since points in different groups cannot be equal (different object constructor),
-// we can have single place to store precomputes.
-// Allows to make points frozen / immutable.
-const pointPrecomputes = new WeakMap();
 const pointWindowSizes = new WeakMap();
-function getW(P) {
-    // To disable precomputes:
-    // return 1;
-    // `1` is also the uncached sentinel: use the ladder / non-precomputed path.
+function getWindowSize(P) {
+    // `1` is the uncached sentinel: use the non-precomputed (wNAF / fixed-window) path.
     return pointWindowSizes.get(P) || 1;
 }
-function assert0(n) {
-    // Internal invariant: a non-zero remainder here means the wNAF window decomposition or loop
-    // count is inconsistent, not that the original caller provided a bad scalar.
+/** Table of odd multiples [1P, 3P, ..., (2⋅size−1)P]; width-W wNAF uses size = 2^(W−2). */
+function oddMultiples(p, size) {
+    const dbl = p.double();
+    const t = [p];
+    for (let j = 1; j < size; j++)
+        t.push(t[j - 1].add(dbl));
+    return t;
+}
+/**
+ * Width-W wNAF signed-digit recoding (W >= 2), LSB-first: digits are 0 or odd with
+ * |digit| < 2^(W−1); nonzero density ~1/(W+1) (a nonzero digit is followed by W−1 zeros).
+ */
+function wnafDigits(n, W) {
+    const size = 2 ** W;
+    const half = size / 2;
+    const mask = BigInt(size - 1);
+    const d = [];
+    while (n > _0n) {
+        let w = 0;
+        if (n & _1n) {
+            w = Number(n & mask); // n mod 2^W, odd
+            if (w >= half)
+                w -= size; // signed residue
+            n -= BigInt(w); // n - w ≡ 0 mod 2^W: next W−1 digits are zero
+        }
+        d.push(w);
+        n >>= _1n;
+    }
+    return d;
+}
+/**
+ * Fixed-position signed-window recoding for precomputed wNAF: `n = Σ digits[w]⋅2^(w⋅W)` with
+ * digits in `[−2^(W−1)+1, 2^(W−1)]`. Digit count is fixed by `windows` (callers reserve one
+ * extra window for the final carry), so recoding length does not depend on the scalar.
+ */
+function signedWindowDigits(n, W, windows) {
+    const size = 2 ** W;
+    const half = size / 2;
+    const mask = BigInt(size - 1);
+    const shiftBy = BigInt(W);
+    const d = [];
+    for (let w = 0; w < windows; w++) {
+        let v = Number(n & mask);
+        n >>= shiftBy;
+        if (v > half) {
+            v -= size; // negative digit, carry into the next window
+            n += _1n;
+        }
+        d.push(v);
+    }
+    // Internal invariant: leftover bits mean the window count did not cover the scalar.
     if (n !== _0n)
-        throw new Error('invalid wNAF');
+        throw new Error('invalid wnaf');
+    return d;
 }
 /**
- * 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.
+ * Shared vartime walk over per-scalar wNAF digit streams: one doubling of a single shared
+ * accumulator per bit position of the longest recoding, one signed table addition per
+ * nonzero digit. `tables[i]` must hold the odd multiples of the i-th point.
+ */
+function wnafWalk(zero, tables, digits) {
+    let max = 0;
+    for (const d of digits)
+        max = Math.max(max, d.length);
+    let acc = zero;
+    for (let bit = max - 1; bit >= 0; bit--) {
+        if (bit !== max - 1)
+            acc = acc.double();
+        for (let i = 0; i < digits.length; i++) {
+            const w = digits[i][bit]; // reads past shorter recodings yield undefined, skipped below
+            if (w) {
+                const item = tables[i][(Math.abs(w) - 1) >> 1];
+                acc = acc.add(w < 0 ? item.negate() : item);
+            }
+        }
+    }
+    return acc;
+}
+/**
+ * Elliptic curve multiplication of Point by scalar.
+ * Routes between cached-table, fixed-window, and one-shot wNAF paths; entry points validate
+ * their own scalars (`mulCT`/`mulCTBlinded`: `1 <= s < Fn.ORDER`; `mulUnsafe`: up to the
+ * `Fn.ORDER^4` DoS cap via {@link mulAddUnsafe}).
+ * Table generation is expensive and happens on first call of `multiply()`
+ * (or eagerly via `precompute(W, false)`). 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 a 2d JS array of windows instead of a single window.
- * This would allow windows to be in different memory locations.
+ * Cached algorithm is signed fixed-window wNAF:
+ * - table stores, for every window w, the multiples `[1..2^(W−1)]⋅2^(w⋅W)⋅P` — all doublings
+ *   are baked in, so a multiplication is exactly one table addition per window
+ * - window count is fixed (`ceil(bits/W) + 1`), so the point-operation count is scalar-independent
+ *   (basis of the constant-time path)
+ * - for a 256-bit curve and W=6: 44⋅32 = 1408 table points, 44 additions per multiply
+ * - secret scalars are additionally blinded (see {@link ScalarMultiplier.mulCTBlinded}), which
+ *   widens tables by 128 bits
  * @param Point - Point constructor.
- * @param bits - Scalar bit length.
+ * @param randomBytes - RNG used for scalar blinding; required by the blinded secret path.
  * @example
@@ -183,192 +260,294 @@ * Elliptic curve multiplication of Point by scalar.
  * ```ts
- * import { wNAF } from '@noble/curves/abstract/curve.js';
+ * import { ScalarMultiplier } from '@noble/curves/abstract/curve.js';
  * import { p256 } from '@noble/curves/nist.js';
- * const ladder = new wNAF(p256.Point, p256.Point.Fn.BITS);
+ * const mul = new ScalarMultiplier(p256.Point);
  * ```
  */
-export class wNAF {
+export class ScalarMultiplier {
+    Point;
     BASE;
     ZERO;
-    Fn;
+    randomBytes;
+    wnafPrecomputes = new WeakMap();
+    baseCanBeBlinded;
     bits;
     // Parametrized with a given Point class (not individual point)
-    constructor(Point, bits) {
+    constructor(Point, randomBytes) {
+        validatePointCons(Point);
+        // Probe the RNG once (see {@link probeRandomBytes}): in environments without working
+        // randomness (e.g. no WebCrypto), shouldBlind() then routes secret multiplication to the
+        // unblinded constant-time path instead of throwing on every multiply(). The shape of
+        // returned bytes is still validated on every blinded call, where breakage fails closed.
+        this.randomBytes = probeRandomBytes(randomBytes, BLIND_BYTES);
+        this.Point = Point;
         this.BASE = Point.BASE;
         this.ZERO = Point.ZERO;
-        this.Fn = Point.Fn;
-        this.bits = bits;
+        this.bits = Point.Fn.BITS;
     }
-    // non-const time multiplication ladder
-    _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.
+     * Creates a signed fixed-window wNAF precomputation table: for every window w, the
+     * multiples `[1..2^(W−1)]⋅2^(w⋅W)⋅P`, flattened. All doublings are baked into the table,
+     * so cached multiplication is additions-only. `windows = ceil(bits/W) + 1`: the extra
+     * window absorbs the final carry of signed-digit recoding.
+     * For a 256-bit curve and W=6, the table is 44⋅32 = 1408 points.
      * @param point - Point instance
      * @param W - window size
-     * @returns precomputed point tables flattened to a single array
+     * @param bits - scalar bitlength the table must cover
      */
-    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);
-            // i=1, bc we skip 0
-            for (let i = 1; i < windowSize; i++) {
-                base = base.add(p);
-                points.push(base);
+    buildWnafTable(point, W, bits) {
+        // W needs no re-validation: its only source is setWindowSize(), which enforces
+        // 1 <= W <= Fn.BITS <= bits (the blinded path only ever widens bits) and caps the
+        // resulting table at ~2 GiB (sized against the wider blinded layout).
+        const windows = Math.ceil(bits / W) + 1;
+        const half = 2 ** (W - 1);
+        const comp = [];
+        let base = point;
+        for (let w = 0; w < windows; w++) {
+            let acc = base;
+            for (let i = 0; i < half; i++) {
+                comp.push(acc);
+                acc = acc.add(base);
             }
-            p = base.double();
+            base = comp[comp.length - 1].double(); // 2⋅(2^(W−1)⋅base) = next window's base
         }
-        return points;
+        return { W, bits, windows, comp };
     }
     /**
-     * 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
+     * Implements ec multiplication using precomputed signed fixed-window wNAF tables.
+     * Constant-time: fixed window count with one table addition per window — zero digits feed
+     * the fake accumulator — and no doublings; the lookup scans the whole window slice.
+     * Scalar bounds are validated by the public entry points ({@link ScalarMultiplier.mulCT},
+     * {@link ScalarMultiplier.mulCTBlinded}, {@link ScalarMultiplier.mulUnsafe});
+     * signedWindowDigits throws if `n` exceeds the table.
      * @returns real and fake (for const-time) points
      */
-    wNAF(W, precomputes, n) {
-        // Scalar should be smaller than field order
-        if (!this.Fn.isValid(n))
-            throw new Error('invalid scalar');
-        // Accumulators
+    wnafCachedCT(precomputes, n) {
+        const { W, windows, comp } = precomputes;
+        const half = 2 ** (W - 1);
+        const digits = signedWindowDigits(n, W, windows);
         let p = this.ZERO;
         let f = this.BASE;
-        // This code was first written with assumption that 'f' and 'p' will never be infinity point:
-        // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,
-        // there is negate now: it is possible that negated element from low value
-        // would be the same as high element, which will create carry into next window.
-        // It's not obvious how this can fail, but still worth investigating later.
-        const wo = calcWOpts(W, this.bits);
-        for (let window = 0; window < wo.windows; window++) {
-            // (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise
-            const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
-            n = nextN;
-            if (isZero) {
-                // bits are 0: add garbage to fake point
-                // Important part for const-time getPublicKey: add random "noise" point to f.
-                f = f.add(negateCt(isNegF, precomputes[offsetF]));
-            }
-            else {
-                // bits are 1: add to result point
-                p = p.add(negateCt(isNeg, precomputes[offset]));
-            }
+        for (let w = 0; w < windows; w++) {
+            const digit = digits[w];
+            const start = w * half;
+            // Data-oblivious select: touch every entry of the window before the digit branch.
+            const idx = Math.abs(digit) - 1; // -1 for zero digits: matches nothing, `sel` unused
+            let sel = comp[start];
+            for (let i = 1; i < half; i++)
+                sel = i === idx ? comp[start + i] : sel;
+            const neg = sel.negate(); // compute both signs; the digit only picks one
+            if (digit === 0)
+                f = f.add(comp[start]);
+            else
+                p = p.add(digit < 0 ? neg : sel);
         }
-        assert0(n);
-        // Return both real and fake points so JIT keeps the noise path alive.
-        // Known caveat: negate/carry interactions can still drive `f` to infinity even when `p` is not,
-        // which weakens the noise path and leaves this only "less const-time" by about one bigint mul.
         return { p, f };
     }
-    /**
-     * Implements unsafe EC 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; // Early-exit, skip 0 value
-            const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
-            n = nextN;
-            if (isZero) {
-                // Window bits are 0: skip processing.
-                // Move to next window.
-                continue;
-            }
-            else {
-                const item = precomputes[offset];
-                acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM
-            }
-        }
-        assert0(n);
-        return acc;
-    }
-    getPrecomputes(W, point, transform) {
-        // Cache key is only point identity plus the remembered window size; callers must not reuse the
-        // same point with incompatible `transform(...)` layouts and expect a separate cache entry.
-        let comp = pointPrecomputes.get(point);
+    // Cache key is point identity plus (W, bits); at most two entries exist per point (public-width
+    // `Fn.BITS` and blinded `Fn.BITS + BLIND_BITS`). Callers must not reuse the same point with
+    // incompatible `transform(...)` layouts and expect a separate cache entry.
+    getWnafPrecomputes(W, point, bits, transform) {
+        let entries = this.wnafPrecomputes.get(point);
+        let comp = entries?.find((entry) => entry.W === W && entry.bits === bits);
         if (!comp) {
-            comp = this.precomputeWindow(point, W);
-            if (W !== 1) {
-                // Doing transform outside of if brings 15% perf hit
-                if (typeof transform === 'function')
-                    comp = transform(comp);
-                pointPrecomputes.set(point, comp);
+            comp = this.buildWnafTable(point, W, bits);
+            if (typeof transform === 'function')
+                comp = { ...comp, comp: transform(comp.comp) };
+            if (!entries) {
+                entries = [];
+                this.wnafPrecomputes.set(point, entries);
             }
+            entries.push(comp);
         }
         return comp;
     }
-    cached(point, scalar, transform) {
-        const W = getW(point);
-        return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+    assertPoint(point) {
+        if (!(point instanceof this.Point))
+            throw new TypeError('"point" expected Point instance, got type=' + typeof point);
     }
-    unsafe(point, scalar, transform, prev) {
-        const W = getW(point);
+    // Shared prologue of the constant-time entry points. Rejects scalar 0: in key/signature-style
+    // callers a zero scalar means broken upstream plumbing, and concrete Points already reject it.
+    // Uses inRange instead of Fn.isValidNot0: validateField() only certifies the arithmetic subset.
+    validateMulInput(point, scalar) {
+        this.assertPoint(point);
+        if (!inRange(scalar, _1n, this.Point.Fn.ORDER))
+            throw new Error('invalid scalar');
+    }
+    // Constant-time dispatch shared by mulCT / mulCTBlinded. Un-precomputed points (W===1, e.g.
+    // ECDH peer keys) skip building a throwaway cached table in favor of a small fixed-window
+    // multiply. `n` must be < 2^bits.
+    runCT(point, n, bits, transform) {
+        const W = getWindowSize(point);
         if (W === 1)
-            return this._unsafeLadder(point, scalar, prev); // For W=1 ladder is ~x2 faster
-        return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+            return this.fixedWindowCT(point, n, bits);
+        return this.wnafCachedCT(this.getWnafPrecomputes(W, point, bits, transform), n);
     }
-    // We calculate precomputes for elliptic curve point multiplication
-    // using windowed method. This specifies window size and
-    // stores precomputed values. Usually only base point would be precomputed.
-    createCache(P, W) {
+    mulCT(point, scalar, transform) {
+        this.validateMulInput(point, scalar);
+        return this.runCT(point, scalar, this.bits, transform);
+    }
+    mulCTBlinded(point, scalar, transform) {
+        this.validateMulInput(point, scalar);
+        // Blinding computes n = scalar + blind*Fn.ORDER, then n*P via a constant-time multiply. This
+        // equals scalar*P only when Fn.ORDER*P == O; callers guarantee that via shouldBlind() (always
+        // for cofactor-1 curves; for cofactored curves only BASE, and only after checking BASE*n == O).
+        // Fail before building the (large) precompute table if randomness is unavailable.
+        if (this.randomBytes === undefined)
+            throw new Error('randomBytes is required for scalar blinding');
+        const bits = this.Point.Fn.BITS + BLIND_BITS;
+        const blind = this.randomBytes(BLIND_BYTES);
+        if (!isBytes(blind) || blind.length !== BLIND_BYTES)
+            throw new Error('randomBytes returned invalid byte array');
+        // Force the top two bits of the 128-bit blind to 10xxxxxx, so blind is in [2^127, 1.5*2^127):
+        // * `| 0x80` (bit 127 = 1) is the load-bearing part: it guarantees blind >= 2^127, so the blind
+        //   is always a full-width, nonzero factor and the scalar is masked even with a degenerate RNG.
+        // * `& 0x3f` (bit 126 = 0) is a safety margin: it caps blind < 1.5*2^127, keeping
+        //   blind*Fn.ORDER + scalar < 0.75*2^(nBits+128), i.e. ~half a window below the 2^(nBits+128)
+        //   ceiling. Not strictly required for the bound (see below), but it reserves headroom so the
+        //   guarantee does not rest on the tight `Fn.ORDER < 2^Fn.BITS` fact and the final carry window
+        //   only ever holds a small carry, never a full digit.
+        blind[0] = (blind[0] & 0x3f) | 0x80;
+        // Even at the extreme (blind < 2^128, scalar < Fn.ORDER < 2^nBits): n <= 2^128*Fn.ORDER - 1 <
+        // 2^(nBits+128), so n stays below 2^bits and within the blinded table's
+        // window count. Both cached CT kernels run a fixed number of windows/rows with one point-add
+        // each, so the add count is independent of scalar (constant-time).
+        const n = scalar + bytesToNumberBE(blind) * this.Point.Fn.ORDER;
+        return this.runCT(point, n, bits, transform);
+    }
+    /**
+     * Constant-time multiplication `n*point` for an un-precomputed point, via a small fixed window.
+     * A cached wNAF table only pays off when reused; a flat 2^FW_WINDOW table (`size-1` adds) is
+     * far cheaper to build for a single use. The point-operation sequence is independent of `n`:
+     * build the table, then per window exactly FW_WINDOW doublings, a data-oblivious scan over
+     * every table entry, and one addition (adds the identity when the window digit is 0 — never
+     * skipped).
+     *
+     * `n` must be `< 2^bits`. Assumes complete addition (adding the identity costs the same as any
+     * add), which holds for the Weierstrass/Edwards point types used here. The table is left in
+     * projective form (no normalizeZ): normalizing this small a table costs more than the
+     * mixed-add savings it would buy for a single multiply.
+     * @returns real point `p`; `f` duplicates it only to match {@link wnafCachedCT}'s return shape
+     * (this path needs no fake accumulator — its op-count is already scalar-independent).
+     */
+    fixedWindowCT(point, n, bits) {
+        const W = FW_WINDOW;
+        const size = 1 << W;
+        const mask = bitMask(W);
+        // Flat table [O, point, 2*point, ..., (size-1)*point].
+        const table = new Array(size);
+        table[0] = this.ZERO;
+        for (let i = 1; i < size; i++)
+            table[i] = table[i - 1].add(point);
+        // Horner MSB->LSB. windows*W >= bits and n < 2^bits, so every bit of n is consumed.
+        const windows = Math.ceil(bits / W);
+        let acc = this.ZERO;
+        for (let window = windows - 1; window >= 0; window--) {
+            // W doublings per window; skipped for the first (topmost) window, where acc is still the
+            // identity. The skip is scalar-independent: it depends only on the loop index.
+            if (window !== windows - 1)
+                for (let d = 0; d < W; d++)
+                    acc = acc.double();
+            const digit = Number((n >> BigInt(window * W)) & mask);
+            // Data-oblivious select: touch every entry, same as wnafCachedCT.
+            let sel = table[0];
+            for (let i = 1; i < size; i++)
+                sel = i === digit ? table[i] : sel;
+            acc = acc.add(sel); // one add per window, even for digit 0
+        }
+        return { p: acc, f: acc };
+    }
+    shouldBlind(point, cofactor) {
+        // No usable RNG (probed in the constructor): blinding is impossible, use the plain CT path.
+        if (this.randomBytes === undefined)
+            return false;
+        if (cofactor === _1n)
+            return true;
+        if (point !== this.BASE)
+            return false;
+        if (this.baseCanBeBlinded === undefined)
+            this.baseCanBeBlinded = this.mulUnsafe(this.BASE, this.Point.Fn.ORDER).is0();
+        return this.baseCanBeBlinded;
+    }
+    mulSecret(point, scalar, cofactor, transform) {
+        return this.shouldBlind(point, cofactor)
+            ? this.mulCTBlinded(point, scalar, transform)
+            : this.mulCT(point, scalar, transform);
+    }
+    mulUnsafe(point, scalar, transform) {
+        this.assertPoint(point);
+        if (!isPosBig(scalar))
+            throw new Error('invalid scalar');
+        const W = getWindowSize(point);
+        // W === 1 (un-precomputed): one-shot width-4 wNAF via {@link mulAddUnsafe} with L=1 —
+        // a cached table would be thrown away after one use. `allowOversized` swaps the
+        // `s < Fn.ORDER` check for mulAddUnsafe's `Fn.ORDER^4` DoS cap.
+        //
+        // Oversized scalar could happen when:
+        // a) user passes large scalar on their own (rare)
+        // b) `assertValidity()` calls `isTorsionFree()`, which multiplies point by `Fn.ORDER`
+        if (W === 1 || scalar >= this.Point.Fn.ORDER)
+            return mulAddUnsafe(this.Point, [point], [scalar], true);
+        // Precomputed points reuse the CT kernel (fake accumulator discarded): with W=6 only
+        // ~1/64 of window-adds are skippable, so a dedicated vartime kernel saved just ~6% on
+        // this path while doubling the cached-table code surface.
+        const precomputes = this.getWnafPrecomputes(W, point, this.bits, transform);
+        return this.wnafCachedCT(precomputes, scalar).p;
+    }
+    // Remembers the window size used for precomputed wNAF multiplication of the given point
+    // and drops any previously built tables. Usually only the base point is precomputed.
+    // W=1 resets the point to the un-precomputed (table-less) paths.
+    // W is additionally capped so tables stay under ~2 GiB ({@link TABLE_BYTES_MAX}).
+    setWindowSize(point, W) {
+        this.assertPoint(point);
         validateW(W, this.bits);
-        pointWindowSizes.set(P, W);
-        pointPrecomputes.delete(P);
+        // Size against the widest table this W can produce: the blinded path adds BLIND_BITS.
+        const windows = Math.ceil((this.bits + BLIND_BITS) / W) + 1;
+        validateTableBytes(windows * 2 ** (W - 1), this.Point.Fp.BYTES);
+        pointWindowSizes.set(point, W);
+        this.wnafPrecomputes.delete(point);
     }
-    hasCache(elm) {
-        return getW(elm) !== 1;
+    // True when a window size is set: tables themselves are built lazily on first multiply.
+    hasWindowSize(point) {
+        return getWindowSize(point) !== 1;
     }
 }
 /**
- * Endomorphism-specific multiplication for Koblitz curves.
- * Cost: 128 dbl, 0-256 adds.
- * @param Point - Point constructor.
- * @param point - Input point.
- * @param k1 - First non-negative absolute scalar chunk.
- * @param k2 - Second non-negative absolute scalar chunk.
- * @returns Partial multiplication results.
+ * Combined multi-scalar multiplication `Σ scalars[i]⋅points[i]` via interleaved width-4 wNAF
+ * (Strauss–Shamir). Every input gets its own table of odd multiples `[1P, 3P, 5P, 7P]` and
+ * signed-digit recoding, but all walks share one doubling chain, so total cost is
+ * `~bits` doublings + `L⋅bits/5` additions instead of `L⋅bits` doublings for separate
+ * multiplications. Intended for the 2-4 point shapes of signature verification
+ * (`R = u1⋅G + u2⋅P`); use {@link pippenger} for larger batches.
+ *
+ * Not constant-time: only for public inputs. Scalars must satisfy `0 <= s < Fn.ORDER`;
+ * fold negative signs into the points before calling.
+ * @param c - Point constructor.
+ * @param points - Array of curve points.
+ * @param scalars - Array of non-negative scalars, same length as points.
+ * @param allowOversized - Replace the `s < Fn.ORDER` scalar check with a `Fn.ORDER^4` DoS cap.
+ *   Off by default. For scalars that must NOT be reduced mod ORDER: torsion checks
+ *   (`Fn.ORDER⋅P ≟ O`) and cofactor-clearing multiples. Walk length grows with `bitLen(s)`.
+ * @returns Combined multiplication result; identity for empty input.
+ * @throws If the point set or scalar set is invalid. {@link Error}
  * @example
- * Endomorphism-specific multiplication for Koblitz curves.
+ * Combined multi-scalar multiplication via Strauss–Shamir.
  *
  * ```ts
- * import { mulEndoUnsafe } from '@noble/curves/abstract/curve.js';
- * import { secp256k1 } from '@noble/curves/secp256k1.js';
- * const parts = mulEndoUnsafe(secp256k1.Point, secp256k1.Point.BASE, 3n, 5n);
+ * import { mulAddUnsafe } from '@noble/curves/abstract/curve.js';
+ * import { p256 } from '@noble/curves/nist.js';
+ * const G = p256.Point.BASE;
+ * const R = mulAddUnsafe(p256.Point, [G, G.double()], [2n, 3n]); // 2⋅G + 3⋅(2⋅G)
  * ```
  */
-export function mulEndoUnsafe(Point, point, k1, k2) {
-    let acc = point;
-    let p1 = Point.ZERO;
-    let p2 = Point.ZERO;
-    while (k1 > _0n || k2 > _0n) {
-        if (k1 & _1n)
-            p1 = p1.add(acc);
-        if (k2 & _1n)
-            p2 = p2.add(acc);
-        acc = acc.double();
-        k1 >>= _1n;
-        k2 >>= _1n;
-    }
-    return { p1, p2 };
+export function mulAddUnsafe(c, points, scalars, allowOversized = false) {
+    validatePointCons(c);
+    validateMSMPoints(points, c);
+    abool(allowOversized, 'allowOversized');
+    // Oversized cap is ORDER^4: hard bound to mitigate DoS, walk length grows with bitLen(s).
+    validateMSMScalars(scalars, c.Fn, allowOversized ? c.Fn.ORDER ** _4n : undefined);
+    if (points.length !== scalars.length)
+        throw new Error('arrays of points and scalars must have equal length');
+    const tables = points.map((p) => oddMultiples(p, 4));
+    const digits = scalars.map((n) => wnafDigits(n, 4));
+    return wnafWalk(c.ZERO, tables, digits);
 }
@@ -379,3 +558,9 @@ /**
  * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.
- * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.
+ * Point-operation count is scalar-independent (for same L), even when 1 point + scalar, or when
+ * scalar = 0 — but bucket indices are scalar windows, so the memory-access pattern is
+ * scalar-dependent: do not rely on this for secret scalars.
+ *
+ * A repaired LFG bucket-set variant from ePrint 2024/750 was benchmarked on BLS12-381 G1
+ * against this implementation: ~1.4x faster at 2048 points and ~1.1-1.25x faster at
+ * 4096-32768 points, at the cost of extra recoding and multiplier-table complexity.
  * @param c - Curve Point constructor
@@ -396,8 +581,4 @@ * @param points - array of L curve points
 export function pippenger(c, points, scalars) {
-    // If we split scalars by some window (let's say 8 bits), every chunk will only
-    // take 256 buckets even if there are 4096 scalars, also re-uses double.
-    // TODO:
-    // - https://eprint.iacr.org/2024/750.pdf
-    // - https://tches.iacr.org/index.php/TCHES/article/view/10287
     // 0 is accepted in scalars
+    validatePointCons(c);
     const fieldN = c.Fn;
@@ -410,4 +591,6 @@ validateMSMPoints(points, c);
         throw new Error('arrays of points and scalars must have equal length');
-    // if (plength === 0) throw new Error('array must be of length >= 2');
     const zero = c.ZERO;
+    // Without this, the window loop below would still run ~Fn.BITS doublings of ZERO.
+    if (plength === 0)
+        return zero;
     const wbits = bitLen(BigInt(plength));
@@ -446,90 +629,45 @@ let windowSize = 1; // bits
 /**
- * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
+ * Interleaved wNAF multi-scalar multiplication (MSM, Pa + Qb + Rc + ...) over a FIXED set
+ * of points: each point gets a one-time table of odd multiples
+ * `[1P, 3P, ..., (2^(W−1)−1)P]`, and the returned closure evaluates MSMs against those
+ * tables. All scalars share one doubling chain (Straus 1964) — one doubling per scalar bit
+ * plus one signed table addition per nonzero width-W wNAF digit (density ~1/(W+1)) — the
+ * "interleaving" method of Möller, "Algorithms for multi-exponentiation" (SAC 2001).
+ *
+ * Table memory is `L⋅2^(W−2)` points, capped at ~2 GiB. Prefer this over {@link pippenger}
+ * when the same points are reused across many MSMs (fixed-base commitments etc.) and up to a
+ * few hundred points; prefer pippenger for one-shot MSMs or thousands of points, where
+ * bucketing beats per-point tables.
+ *
+ * Not constant-time (zero digits are skipped): public inputs only.
  * @param c - Curve Point constructor
- * @param points - array of L curve points
- * @param windowSize - Precompute window size.
- * @returns Function which multiplies points with scalars. The closure accepts
- *   `scalars.length <= points.length`, and omitted trailing scalars are treated as zero.
+ * @param points - array of L curve points, captured by the returned closure
+ * @param windowSize - window width W in bits, from 2 to Fn.BITS; also capped so the
+ *   per-closure tables stay under ~2 GiB
+ * @returns Function which multiplies points with scalars. The closure accepts at most
+ *   `points.length` scalars, and omitted trailing scalars are treated as zero.
  * @throws If the point set or precompute window is invalid. {@link Error}
  * @example
- * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
+ * Interleaved wNAF multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
  *
  * ```ts
- * import { precomputeMSMUnsafe } from '@noble/curves/abstract/curve.js';
+ * import { interleavedMSMUnsafe } from '@noble/curves/abstract/curve.js';
  * import { p256 } from '@noble/curves/nist.js';
- * const msm = precomputeMSMUnsafe(p256.Point, [p256.Point.BASE], 4);
+ * const msm = interleavedMSMUnsafe(p256.Point, [p256.Point.BASE], 4);
  * const point = msm([3n]);
  * ```
  */
-export function precomputeMSMUnsafe(c, points, windowSize) {
-    /**
-     * Performance Analysis of Window-based Precomputation
-     *
-     * Base Case (256-bit scalar, 8-bit window):
-     * - Standard precomputation requires:
-     *   - 31 additions per scalar × 256 scalars = 7,936 ops
-     *   - Plus 255 summary additions = 8,191 total ops
-     *   Note: Summary additions can be optimized via accumulator
-     *
-     * Chunked Precomputation Analysis:
-     * - Using 32 chunks requires:
-     *   - 255 additions per chunk
-     *   - 256 doublings
-     *   - Total: (255 × 32) + 256 = 8,416 ops
-     *
-     * Memory Usage Comparison:
-     * Window Size | Standard Points | Chunked Points
-     * ------------|-----------------|---------------
-     *     4-bit   |     520         |      15
-     *     8-bit   |    4,224        |     255
-     *    10-bit   |   13,824        |   1,023
-     *    16-bit   |  557,056        |  65,535
-     *
-     * Key Advantages:
-     * 1. Enables larger window sizes due to reduced memory overhead
-     * 2. More efficient for smaller scalar counts:
-     *    - 16 chunks: (16 × 255) + 256 = 4,336 ops
-     *    - ~2x faster than standard 8,191 ops
-     *
-     * Limitations:
-     * - Not suitable for plain precomputes (requires 256 constant doublings)
-     * - Performance degrades with larger scalar counts:
-     *   - Optimal for ~256 scalars
-     *   - Less efficient for 4096+ scalars (Pippenger preferred)
-     */
+export function interleavedMSMUnsafe(c, points, windowSize) {
+    validatePointCons(c);
     const fieldN = c.Fn;
-    validateW(windowSize, fieldN.BITS);
+    // Signed odd digits need at least width 2 (W=2 is plain NAF with a single-entry table).
+    validateW(windowSize, fieldN.BITS, 2);
     validateMSMPoints(points, c);
-    const zero = c.ZERO;
-    const tableSize = 2 ** windowSize - 1; // table size (without zero)
-    const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item
-    const MASK = bitMask(windowSize);
-    const tables = points.map((p) => {
-        const res = [];
-        for (let i = 0, acc = p; i < tableSize; i++) {
-            res.push(acc);
-            acc = acc.add(p);
-        }
-        return res;
-    });
+    validateTableBytes(points.length * 2 ** (windowSize - 2), c.Fp.BYTES);
+    const tables = points.map((p) => oddMultiples(p, 2 ** (windowSize - 2)));
     return (scalars) => {
         validateMSMScalars(scalars, fieldN);
         if (scalars.length > points.length)
-            throw new Error('array of scalars must be smaller than array of points');
-        let res = zero;
-        for (let i = 0; i < chunks; i++) {
-            // No need to double if accumulator is still zero.
-            if (res !== zero)
-                for (let j = 0; j < windowSize; j++)
-                    res = res.double();
-            const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);
-            for (let j = 0; j < scalars.length; j++) {
-                const n = scalars[j];
-                const curr = Number((n >> shiftBy) & MASK);
-                if (!curr)
-                    continue; // skip zero scalars chunks
-                res = res.add(tables[j][curr - 1]);
-            }
-        }
-        return res;
+            throw new Error('array of scalars must not be larger than array of points');
+        return wnafWalk(c.ZERO, tables, scalars.map((n) => wnafDigits(n, windowSize)));
     };
@@ -557,3 +695,3 @@ }
  * @param CURVE - Curve parameters.
- * @param curveOpts - Optional field overrides:
+ * @param curveOpts - Optional field overrides. See {@link FpFn}:
  *   - `Fp` (optional): Optional base-field override.
@@ -580,2 +718,4 @@ *   - `Fn` (optional): Optional scalar-field override.
 export function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
+    if (type !== 'weierstrass' && type !== 'edwards')
+        throw new Error('expected curve type "weierstrass" or "edwards"');
     if (FpFnLE === undefined)
@@ -585,5 +725,7 @@ FpFnLE = type === 'edwards';
         throw new Error(`expected valid ${type} CURVE object`);
+    // Validate before reading Fp/Fn so explicit null fails with an options-object error.
+    validateObject(curveOpts);
     for (const p of ['p', 'n', 'h']) {
         const val = CURVE[p];
-        if (!(typeof val === 'bigint' && val > _0n))
+        if (!(isPosBig(val) && val !== _0n))
             throw new Error(`CURVE.${p} must be positive bigint`);
@@ -623,2 +765,1 @@ }
 }
-//# sourceMappingURL=curve.js.map

abstract/edwards.d.ts

@@ -92,2 +92,4 @@ /**
     };
+    /** RNG override used for scalar blinding. */
+    randomBytes: (bytesLength?: number) => TRet<Uint8Array>;
 }>;
@@ -111,2 +113,6 @@ /**
     mapToCurve: (scalar: bigint[]) => AffinePoint<bigint>;
+    /** Optional conversion from this Edwards curve to a birational/isogenous Montgomery curve. */
+    toMontgomery: (point: EdwardsPoint) => TRet<Uint8Array>;
+    /** Optional secret-key conversion for the same Montgomery curve as `toMontgomery`. */
+    toMontgomerySecret: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
     /** Optional prehash function used before signing or verifying messages. */
@@ -158,2 +164,4 @@ prehash: FHash;
      *   - `zip215` (optional): Whether to accept ZIP-215 encodings.
+     * @throws Malformed argument or option types may throw; `false` means well-formed inputs
+     *   failed verification. {@link Error}
      * @returns Whether the signature is valid.
@@ -180,2 +188,3 @@ */
          * Converts ed public key to x public key.
+         * Throws when the Edwards curve has no supported Montgomery conversion.
          *
@@ -200,2 +209,3 @@ * There is NO `fromMontgomery`:
          * Converts ed secret key to x secret key.
+         * Throws when the Edwards curve has no supported Montgomery conversion.
          * @example
@@ -232,3 +242,3 @@ * Converts ed secret key to x secret key.
  *   validation here adds about 10-15ms to heavyweight imports like ed448.
- *   The returned constructor also eagerly marks `Point.BASE` for W=8
+ *   The returned constructor also eagerly marks `Point.BASE` for W=6
  *   precompute caching. Some code paths still assume
@@ -326,2 +336,1 @@ *   `Fp.BYTES === Fn.BYTES`, so mismatched byte lengths are not fully audited here.
 export declare function eddsa(Point: EdwardsPointCons, cHash: TArg<FHash>, eddsaOpts?: TArg<EdDSAOpts>): EdDSA;
-//# sourceMappingURL=edwards.d.ts.map

abstract/edwards.js

@@ -9,7 +9,7 @@ /**
 import { abool, abytes, aInRange, asafenumber, bytesToHex, bytesToNumberLE, concatBytes, copyBytes, hexToBytes, isBytes, notImplemented, validateObject, randomBytes as wcRandomBytes, } from "../utils.js";
-import { createCurveFields, createKeygen, normalizeZ, wNAF, } from "./curve.js";
-import {} from "./modular.js";
+import { createCurveFields, createKeygen, normalizeZ, ScalarMultiplier, validatePointCons, } from "./curve.js";
+import { FpLegendre } from "./modular.js";
 // Be friendly to bad ECMAScript parsers by not using bigint literals
 // prettier-ignore
-const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _8n = /* @__PURE__ */ BigInt(8);
+const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _4n = /* @__PURE__ */ BigInt(4), _8n = /* @__PURE__ */ BigInt(8);
 // Affine Edwards-equation check only; this does not prove subgroup membership, canonical
@@ -32,3 +32,3 @@ // encoding, prime-order base-point requirements, or identity exclusion.
  *   validation here adds about 10-15ms to heavyweight imports like ed448.
- *   The returned constructor also eagerly marks `Point.BASE` for W=8
+ *   The returned constructor also eagerly marks `Point.BASE` for W=6
  *   precompute caching. Some code paths still assume
@@ -47,2 +47,3 @@ *   `Fp.BYTES === Fn.BYTES`, so mismatched byte lengths are not fully audited here.
 export function edwards(params, extraOpts = {}) {
+    validateObject(extraOpts, {}, {}, 'extraOpts');
     const opts = extraOpts;
@@ -53,9 +54,20 @@ const validated = createCurveFields('edwards', params, opts, opts.FpFnLE);
     const { h: cofactor } = CURVE;
-    validateObject(opts, {}, { uvRatio: 'function' });
-    // Important:
-    // There are some places where Fp.BYTES is used instead of nByteLength.
-    // So far, everything has been tested with curves of Fp.BYTES == nByteLength.
-    // TODO: test and find curves which behave otherwise.
-    const MASK = _2n << (BigInt(Fn.BYTES * 8) - _1n);
-    const modP = (n) => Fp.create(n); // Function overrides
+    // The unified add-2008-hwcd formulas (see EdwardsPoint.add/double) are complete —
+    // exception-free for every input pair — only when a is a square and d a non-square in Fp
+    // (Bernstein–Birkner–Joye–Lange–Peters, "Twisted Edwards curves", thm 3.3). The constant-time
+    // kernels in curve.ts assume completeness, so an incomplete curve could silently produce
+    // wrong results on exceptional inputs. Fail construction instead.
+    if (FpLegendre(Fp, CURVE.a) !== 1)
+        throw new Error('edwards: CURVE.a must be a square in Fp for complete addition formulas');
+    if (FpLegendre(Fp, CURVE.d) !== -1)
+        throw new Error('edwards: CURVE.d must be a non-square in Fp for complete addition formulas');
+    validateObject(opts, {}, { uvRatio: 'function', randomBytes: 'function' });
+    const randomBytes = opts.randomBytes === undefined ? wcRandomBytes : opts.randomBytes;
+    // Coordinate and ZIP-215 bounds follow the base-field byte container, not scalar bytes.
+    const MASK = _2n << (BigInt(Fp.BYTES * 8) - _1n);
+    function isOdd(n) {
+        if (!Fp.isOdd)
+            throw new Error('Field does not have .isOdd()');
+        return Fp.isOdd(n);
+    }
     // sqrt(u/v)
@@ -76,2 +88,8 @@ const uvRatio = opts.uvRatio === undefined
         throw new Error('bad curve params: generator point');
+    // Multiplication by param `a` sits on the double() / add() hot paths. For the common twists
+    // a=-1 (ed25519, jubjub) and a=1 (ed448) the full field multiplication is replaced with
+    // negation / identity. Selection depends only on public curve constants.
+    const mulA = Fp.eql(CURVE.a, Fp.neg(Fp.ONE)) ? (x) => Fp.neg(x)
+        : Fp.eql(CURVE.a, Fp.ONE) ? (x) => x
+            : (x) => Fp.mul(CURVE.a, x); // prettier-ignore
     /**
@@ -93,9 +111,5 @@ * Asserts coordinate is valid: 0 <= n < MASK.
     class Point {
-        // base / generator point
-        static BASE = new Point(CURVE.Gx, CURVE.Gy, _1n, modP(CURVE.Gx * CURVE.Gy));
-        // zero / infinity / identity point
-        static ZERO = new Point(_0n, _1n, _1n, _0n); // 0, 1, 1, 0
-        // math field
+        static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE, Fp.mul(CURVE.Gx, CURVE.Gy));
+        static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ONE, Fp.ZERO);
         static Fp = Fp;
-        // scalar field
         static Fn = Fn;
@@ -127,3 +141,3 @@ X;
             acoord('y', y);
-            return new Point(x, y, _1n, modP(x * y));
+            return new Point(x, y, Fp.ONE, Fp.mul(x, y));
         }
@@ -148,15 +162,15 @@ // Uses algo from RFC8032 5.1.3.
             // ax²+y²=1+dx²y² => y²-1=dx²y²-ax² => y²-1=x²(dy²-a) => x²=(y²-1)/(dy²-a)
-            const y2 = modP(y * y); // denominator is always non-0 mod p.
-            const u = modP(y2 - _1n); // u = y² - 1
-            const v = modP(d * y2 - a); // v = d y² + 1.
+            const y2 = Fp.sqr(y); // denominator is always non-0 mod p.
+            const u = Fp.sub(y2, Fp.ONE); // u = y² - 1
+            const v = Fp.sub(Fp.mulN(d, y2), a); // v = d y² - a.
             let { isValid, value: x } = uvRatio(u, v); // √(u/v)
             if (!isValid)
                 throw new Error('bad point: invalid y coordinate');
-            const isXOdd = (x & _1n) === _1n; // There are 2 square roots. Use x_0 bit to select proper
+            const isXOdd = isOdd(x); // There are 2 square roots. Use x_0 bit to select proper
             const isLastByteOdd = (lastByte & 0x80) !== 0; // x_0, last bit
-            if (!zip215 && x === _0n && isLastByteOdd)
+            if (!zip215 && Fp.is0(x) && isLastByteOdd)
                 // if x=0 and x_0 = 1, fail
                 throw new Error('bad point: x=0 and x_0=1');
             if (isLastByteOdd !== isXOdd)
-                x = modP(-x); // if x_0 != x mod 2, set x = p-x
+                x = Fp.neg(x); // if x_0 != x mod 2, set x = p-x
             return Point.fromAffine({ x, y });
@@ -173,4 +187,4 @@ }
         }
-        precompute(windowSize = 8, isLazy = true) {
-            wnaf.createCache(this, windowSize);
+        precompute(windowSize = 6, isLazy = true) {
+            wnaf.setWindowSize(this, windowSize);
             if (!isLazy)
@@ -193,15 +207,15 @@ this.multiply(_2n); // random number
             const { X, Y, Z, T } = p;
-            const X2 = modP(X * X); // X²
-            const Y2 = modP(Y * Y); // Y²
-            const Z2 = modP(Z * Z); // Z²
-            const Z4 = modP(Z2 * Z2); // Z⁴
-            const aX2 = modP(X2 * a); // aX²
-            const left = modP(Z2 * modP(aX2 + Y2)); // (aX² + Y²)Z²
-            const right = modP(Z4 + modP(d * modP(X2 * Y2))); // Z⁴ + dX²Y²
-            if (left !== right)
+            const X2 = Fp.sqr(X); // X²
+            const Y2 = Fp.sqr(Y); // Y²
+            const Z2 = Fp.sqr(Z); // Z²
+            const Z4 = Fp.sqr(Z2); // Z⁴
+            const aX2 = Fp.mul(X2, a); // aX²
+            const left = Fp.mul(Fp.add(aX2, Y2), Z2); // (aX² + Y²)Z²
+            const right = Fp.add(Z4, Fp.mul(d, Fp.mul(X2, Y2))); // Z⁴ + dX²Y²
+            if (!Fp.eql(left, right))
                 throw new Error('bad point: equation left != right (1)');
             // In Extended coordinates we also have T, which is x*y=T/Z: check X*Y == Z*T
-            const XY = modP(X * Y);
-            const ZT = modP(Z * T);
-            if (XY !== ZT)
+            const XY = Fp.mul(X, Y);
+            const ZT = Fp.mul(Z, T);
+            if (!Fp.eql(XY, ZT))
                 throw new Error('bad point: equation left != right (2)');
@@ -214,7 +228,7 @@ }
             const { X: X2, Y: Y2, Z: Z2 } = other;
-            const X1Z2 = modP(X1 * Z2);
-            const X2Z1 = modP(X2 * Z1);
-            const Y1Z2 = modP(Y1 * Z2);
-            const Y2Z1 = modP(Y2 * Z1);
-            return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+            const X1Z2 = Fp.mul(X1, Z2);
+            const X2Z1 = Fp.mul(X2, Z1);
+            const Y1Z2 = Fp.mul(Y1, Z2);
+            const Y2Z1 = Fp.mul(Y2, Z1);
+            return Fp.eql(X1Z2, X2Z1) && Fp.eql(Y1Z2, Y2Z1);
         }
@@ -226,3 +240,3 @@ is0() {
             // Flips point sign to a negative one (-x, y in affine coords)
-            return new Point(modP(-this.X), this.Y, this.Z, modP(-this.T));
+            return new Point(Fp.neg(this.X), this.Y, this.Z, Fp.neg(this.T));
         }
@@ -233,17 +247,16 @@ // Fast algo for doubling Extended Point.
         double() {
-            const { a } = CURVE;
             const { X: X1, Y: Y1, Z: Z1 } = this;
-            const A = modP(X1 * X1); // A = X12
-            const B = modP(Y1 * Y1); // B = Y12
-            const C = modP(_2n * modP(Z1 * Z1)); // C = 2*Z12
-            const D = modP(a * A); // D = a*A
-            const x1y1 = X1 + Y1;
-            const E = modP(modP(x1y1 * x1y1) - A - B); // E = (X1+Y1)2-A-B
-            const G = D + B; // G = D+B
-            const F = G - C; // F = G-C
-            const H = D - B; // H = D-B
-            const X3 = modP(E * F); // X3 = E*F
-            const Y3 = modP(G * H); // Y3 = G*H
-            const T3 = modP(E * H); // T3 = E*H
-            const Z3 = modP(F * G); // Z3 = F*G
+            const A = Fp.sqr(X1); // A = X12
+            const B = Fp.sqr(Y1); // B = Y12
+            const C = Fp.mul(Fp.sqr(Z1), _2n); // C = 2*Z12
+            const D = mulA(A); // D = a*A
+            const x1y1 = Fp.addN(X1, Y1);
+            const E = Fp.sub(Fp.subN(Fp.sqr(x1y1), A), B); // E = (X1+Y1)2-A-B
+            const G = Fp.addN(D, B); // G = D+B
+            const F = Fp.subN(G, C); // F = G-C
+            const H = Fp.subN(D, B); // H = D-B
+            const X3 = Fp.mul(E, F); // X3 = E*F
+            const Y3 = Fp.mul(G, H); // Y3 = G*H
+            const T3 = Fp.mul(E, H); // T3 = E*H
+            const Z3 = Fp.mul(F, G); // Z3 = F*G
             return new Point(X3, Y3, Z3, T3);
@@ -256,17 +269,18 @@ }
             aedpoint(other);
-            const { a, d } = CURVE;
+            const { d } = CURVE;
             const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
             const { X: X2, Y: Y2, Z: Z2, T: T2 } = other;
-            const A = modP(X1 * X2); // A = X1*X2
-            const B = modP(Y1 * Y2); // B = Y1*Y2
-            const C = modP(T1 * d * T2); // C = T1*d*T2
-            const D = modP(Z1 * Z2); // D = Z1*Z2
-            const E = modP((X1 + Y1) * (X2 + Y2) - A - B); // E = (X1+Y1)*(X2+Y2)-A-B
-            const F = D - C; // F = D-C
-            const G = D + C; // G = D+C
-            const H = modP(B - a * A); // H = B-a*A
-            const X3 = modP(E * F); // X3 = E*F
-            const Y3 = modP(G * H); // Y3 = G*H
-            const T3 = modP(E * H); // T3 = E*H
-            const Z3 = modP(F * G); // Z3 = F*G
+            const A = Fp.mul(X1, X2); // A = X1*X2
+            const B = Fp.mul(Y1, Y2); // B = Y1*Y2
+            const C = Fp.mul(Fp.mulN(T1, d), T2); // C = T1*d*T2
+            const D = Fp.mul(Z1, Z2); // D = Z1*Z2
+            // E = (X1+Y1)*(X2+Y2)-A-B
+            const E = Fp.sub(Fp.subN(Fp.mulN(Fp.addN(X1, Y1), Fp.addN(X2, Y2)), A), B);
+            const F = Fp.subN(D, C); // F = D-C
+            const G = Fp.addN(D, C); // G = D+C
+            const H = Fp.sub(B, mulA(A)); // H = B-a*A
+            const X3 = Fp.mul(E, F); // X3 = E*F
+            const Y3 = Fp.mul(G, H); // Y3 = G*H
+            const T3 = Fp.mul(E, H); // T3 = E*H
+            const Z3 = Fp.mul(F, G); // Z3 = F*G
             return new Point(X3, Y3, Z3, T3);
@@ -288,4 +302,4 @@ }
                 throw new RangeError('invalid scalar: expected 1 <= sc < curve.n');
-            const { p, f } = wnaf.cached(this, scalar, (p) => normalizeZ(Point, p));
-            return normalizeZ(Point, [p, f])[0];
+            const { p, f } = wnaf.mulSecret(this, scalar, cofactor, normalize);
+            return normalize([p, f])[0];
         }
@@ -305,3 +319,3 @@ // Non-constant-time multiplication. Uses double-and-add algorithm.
                 return this;
-            return wnaf.unsafe(this, scalar, (p) => normalizeZ(Point, p));
+            return wnaf.mulUnsafe(this, scalar, normalize);
         }
@@ -318,3 +332,3 @@ // Checks if point is of small order.
         isTorsionFree() {
-            return wnaf.unsafe(this, CURVE.n).is0();
+            return wnaf.mulUnsafe(this, CURVE.n).is0();
         }
@@ -326,12 +340,14 @@ // Converts Extended point to default (x, y) coordinates.
             let iz = invertedZ;
+            if (iz != null && typeof iz !== 'bigint')
+                throw new TypeError('"invertedZ" expected bigint, got type=' + typeof iz);
             const { X, Y, Z } = p;
             const is0 = p.is0();
             if (iz == null)
-                iz = is0 ? _8n : Fp.inv(Z); // 8 was chosen arbitrarily
-            const x = modP(X * iz);
-            const y = modP(Y * iz);
+                iz = is0 ? Fp.create(_8n) : Fp.inv(Z);
+            const x = Fp.mul(X, iz);
+            const y = Fp.mul(Y, iz);
             const zz = Fp.mul(Z, iz);
             if (is0)
-                return { x: _0n, y: _1n };
-            if (zz !== _1n)
+                return { x: Fp.ZERO, y: Fp.ONE };
+            if (!Fp.eql(zz, Fp.ONE))
                 throw new Error('invZ was invalid');
@@ -343,2 +359,9 @@ return { x, y };
                 return this;
+            // 2.8-3.8x speed-up vs naive
+            if (cofactor === _2n)
+                return this.double();
+            if (cofactor === _4n)
+                return this.double().double();
+            if (cofactor === _8n)
+                return this.double().double().double();
             return this.multiplyUnsafe(cofactor);
@@ -352,3 +375,3 @@ }
             // When compressing, it's enough to store y and use the last byte to encode sign of x
-            bytes[bytes.length - 1] |= x & _1n ? 0x80 : 0;
+            bytes[bytes.length - 1] |= isOdd(x) ? 0x80 : 0;
             return bytes;
@@ -363,3 +386,2 @@ }
     }
-    const wnaf = new wNAF(Point, Fn.BITS);
     // Keep constructor work cheap: subgroup/generator validation belongs to the caller's curve
@@ -374,6 +396,8 @@ // parameters, and doing the extra checks here adds about 10-15ms to heavy module imports.
     // }
-    // Tiny toy curves can have scalar fields narrower than 8 bits. Skip the
-    // eager W=8 cache there instead of rejecting an otherwise valid constructor.
-    if (Fn.BITS >= 8)
-        Point.BASE.precompute(8); // Enable precomputes. Slows down first publicKey computation by 20ms.
+    const normalize = (points) => normalizeZ(Point, points);
+    const wnaf = new ScalarMultiplier(Point, randomBytes);
+    // Enable W=6 wNAF precomputes. Slows down first publicKey computation.
+    // Disable for tiny toy curves, with scalar fields < 6 bits.
+    if (wnaf.bits >= 6)
+        Point.BASE.precompute(6);
     Object.freeze(Point.prototype);
@@ -509,2 +533,3 @@ Object.freeze(Point);
 export function eddsa(Point, cHash, eddsaOpts = {}) {
+    validatePointCons(Point);
     if (typeof cHash !== 'function')
@@ -521,2 +546,4 @@ throw new Error('"hash" function param is required');
         mapToCurve: 'function',
+        toMontgomery: 'function',
+        toMontgomerySecret: 'function',
     });
@@ -535,2 +562,4 @@ const { prehash } = opts;
     const randomBytes = opts.randomBytes === undefined ? wcRandomBytes : opts.randomBytes;
+    const toMontgomery = opts.toMontgomery;
+    const toMontgomerySecret = opts.toMontgomerySecret;
     const adjustScalarBytes = opts.adjustScalarBytes === undefined
@@ -584,2 +613,3 @@ ? (bytes) => bytes
     function sign(msg, secretKey, options = {}) {
+        validateObject(options, {}, {}, 'options');
         msg = abytes(msg, undefined, 'message');
@@ -612,2 +642,4 @@ if (prehash)
     function verify(sig, msg, publicKey, options = verifyOpts) {
+        // Validate before destructuring so explicit null follows the standard options error.
+        validateObject(options);
         // Preserve the wrapper-selected default for `{}` / `{ zip215: undefined }`, not just omitted opts.
@@ -683,25 +715,12 @@ const { context } = options;
         isValidPublicKey,
-        /**
-         * Converts ed public key to x public key. Uses formula:
-         * - ed25519:
-         *   - `(u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x)`
-         *   - `(x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1))`
-         * - ed448:
-         *   - `(u, v) = ((y-1)/(y+1), sqrt(156324)*u/x)`
-         *   - `(x, y) = (sqrt(156324)*u/v, (1+u)/(1-u))`
-         */
+        /** Converts an Edwards public key to a companion Montgomery public key. */
         toMontgomery(publicKey) {
-            const { y } = Point.fromBytes(publicKey);
-            const size = lengths.publicKey;
-            const is25519 = size === 32;
-            if (!is25519 && size !== 57)
-                throw new Error('only defined for 25519 and 448');
-            const u = is25519 ? Fp.div(_1n + y, _1n - y) : Fp.div(y - _1n, y + _1n);
-            return Fp.toBytes(u);
+            if (toMontgomery === undefined)
+                throw new Error('Montgomery conversion is not supported for this curve');
+            return toMontgomery(Point.fromBytes(publicKey));
         },
         toMontgomerySecret(secretKey) {
-            const size = lengths.secretKey;
-            abytes(secretKey, size);
-            const hashed = hash(secretKey.subarray(0, size));
-            return adjustScalarBytes(hashed).subarray(0, size);
+            if (toMontgomerySecret === undefined)
+                throw new Error('Montgomery conversion is not supported for this curve');
+            return toMontgomerySecret(secretKey);
         },
@@ -721,2 +740,1 @@ };
 }
-//# sourceMappingURL=edwards.js.map

abstract/fft.d.ts

@@ -6,4 +6,4 @@ /**
  */
-import type { TArg } from '../utils.ts';
-import type { IField } from './modular.ts';
+import { type TArg } from '../utils.ts';
+import { type IField } from './modular.ts';
 /** Array-like coefficient storage that can be mutated in place. */
@@ -38,3 +38,2 @@ export interface MutableArrayLike<T> {
  * @returns `true` when the value is a power of two.
- * @throws If `x` is not a valid unsigned 32-bit integer. {@link Error}
  * @example
@@ -77,3 +76,2 @@ * Validate that an FFT size is a power of two.
  * @returns Base-2 logarithm. For `n = 0`, the current implementation returns `-1`.
- * @throws If `n` is not a valid unsigned 32-bit integer. {@link Error}
  * @example
@@ -154,5 +152,5 @@ * Compute the radix-2 stage count for one transform size.
 /**
- * We limit roots up to 2**31, which is a lot: 2-billion polynomimal should be rare.
+ * We limit roots up to 2**31, which is a lot: 2-billion polynomial should be rare.
  * @param field - Field implementation.
- * @param generator - Optional generator override.
+ * @param generator - Optional trusted non-quadratic-residue override for callers that already know the field.
  * @returns Roots-of-unity cache.
@@ -233,3 +231,3 @@ * @example
  *
- * - DIT (Decimation-in-Time): Bottom-Up (leaves to root), Cool-Turkey
+ * - DIT (Decimation-in-Time): Bottom-Up (leaves to root), Cooley-Tukey
  * - DIF (Decimation-in-Frequency): Top-Down (root to leaves), Gentleman-Sande
@@ -246,4 +244,12 @@ *
  * Negacyclic NTT: Rq = Zq[x]/(x^n+1). butterfly_DIT+loop_DIF, at least for mlkem / mldsa
+ *
+ * `invertButterflies` indexes roots by a per-butterfly-group counter (`grp`): forward
+ * (`dit: false`) reads `roots[grp]` with grp = 1..; inverse (`dit: true`) reads `roots[N - grp]`
+ * with grp restarting at 1. With `skipStages: 0` one table serves both directions (ωᴺ = 1 makes
+ * the reversed walk self-inverse). With `skipStages > 0` the inverse walk starts at `N - 1`
+ * instead of continuing where the skipped stages would have left off, so the caller must supply
+ * a table shaped for that (ML-KEM: `ζ^BitRev7(i)` over all N=256 indices, whose aliased upper
+ * half is exactly the FIPS 203 inverse walk).
  * @param F - Field operations.
- * @param coreOpts - FFT configuration:
+ * @param coreOpts - FFT configuration. See {@link FFTCoreOpts}:
  *   - `N`: Transform size. Must be a power of two.
@@ -445,2 +451,1 @@ *   - `roots`: Stage roots for the selected transform size.
 export declare function poly<T, P extends PolyStorage<T>>(field: TArg<IField<T>>, roots: RootsOfUnity, create: CreatePolyFn<P, T>, fft?: FFTMethods<T>, length?: number): PolyFn<P, T>;
-//# sourceMappingURL=fft.d.ts.map

abstract/fft.js

@@ -1,5 +0,14 @@
-function checkU32(n) {
+/**
+ * Experimental implementation of NTT / FFT (Fast Fourier Transform) over finite fields.
+ * API may change at any time. The code has not been audited. Feature requests are welcome.
+ * @module
+ */
+import { aarray, validateObject } from "../utils.js";
+import { validateField } from "./modular.js";
+function checkU32(n, title = 'n') {
     // 0xff_ff_ff_ff
+    if (typeof n !== 'number')
+        throw new TypeError(`wrong u32 integer "${title}": expected number, got type=${typeof n}`);
     if (!Number.isSafeInteger(n) || n < 0 || n > 0xffffffff)
-        throw new Error('wrong u32 integer:' + n);
+        throw new RangeError(`wrong u32 integer "${title}": expected 0..4294967295, got ${n}`);
     return n;
@@ -11,3 +20,2 @@ }
  * @returns `true` when the value is a power of two.
- * @throws If `x` is not a valid unsigned 32-bit integer. {@link Error}
  * @example
@@ -21,3 +29,3 @@ * Validate that an FFT size is a power of two.
 export function isPowerOfTwo(x) {
-    checkU32(x);
+    checkU32(x, 'x');
     return (x & (x - 1)) === 0 && x !== 0;
@@ -60,2 +68,4 @@ }
     checkU32(n);
+    if (typeof bits !== 'number')
+        throw new TypeError('"bits" expected number, got type=' + typeof bits);
     if (!Number.isSafeInteger(bits) || bits < 0 || bits > 32)
@@ -73,3 +83,2 @@ throw new Error(`expected integer 0 <= bits <= 32, got ${bits}`);
  * @returns Base-2 logarithm. For `n = 0`, the current implementation returns `-1`.
- * @throws If `n` is not a valid unsigned 32-bit integer. {@link Error}
  * @example
@@ -102,2 +111,6 @@ * Compute the radix-2 stage count for one transform size.
 export function bitReversalInplace(values) {
+    if (!values ||
+        typeof values !== 'object' ||
+        typeof values.length !== 'number')
+        throw new TypeError('"values" expected array-like, got type=' + typeof values);
     const n = values.length;
@@ -130,2 +143,3 @@ // Size-1 FFT is the identity, so bit-reversal must stay a no-op there instead of rejecting it.
 export function bitReversalPermutation(values) {
+    aarray(values, 'values');
     return bitReversalInplace(values.slice());
@@ -141,5 +155,5 @@ }
 /**
- * We limit roots up to 2**31, which is a lot: 2-billion polynomimal should be rare.
+ * We limit roots up to 2**31, which is a lot: 2-billion polynomial should be rare.
  * @param field - Field implementation.
- * @param generator - Optional generator override.
+ * @param generator - Optional trusted non-quadratic-residue override for callers that already know the field.
  * @returns Roots-of-unity cache.
@@ -157,2 +171,5 @@ * @example
 export function rootsOfUnity(field, generator) {
+    validateField(field);
+    if (generator !== undefined && typeof generator !== 'bigint')
+        throw new TypeError('"generator" expected bigint, got type=' + typeof generator);
     // Factor field.ORDER-1 as oddFactor * 2^powerOfTwo
@@ -173,3 +190,3 @@ let oddFactor = field.ORDER - _1n;
     const checkBits = (bits) => {
-        checkU32(bits);
+        checkU32(bits, 'bits');
         if (bits > 31 || bits > powerOfTwo)
@@ -184,5 +201,14 @@ throw new Error('rootsOfUnity: wrong bits ' + bits + ' powerOfTwo=' + powerOfTwo);
                 continue; // Skip if we've already computed roots for this power
+            const above = rootsCache[power + 1];
             const rootsAtPower = [];
-            for (let j = 0, cur = field.ONE; j < 2 ** power; j++, cur = field.mul(cur, omegas[power]))
-                rootsAtPower.push(cur);
+            if (above) {
+                // ω_{2^p} = ω_{2^{p+1}}², so the smaller table is the even-index stride of the bigger
+                // one: only the largest requested power pays for the multiplication chain.
+                for (let j = 0; j < 2 ** power; j++)
+                    rootsAtPower.push(above[2 * j]);
+            }
+            else {
+                for (let j = 0, cur = field.ONE; j < 2 ** power; j++, cur = field.mul(cur, omegas[power]))
+                    rootsAtPower.push(cur);
+            }
             rootsCache[power] = rootsAtPower;
@@ -196,3 +222,3 @@ }
     // NOTE: we use bits instead of power, because power = 2**bits,
-    // but power is not neccesary isPowerOfTwo(power)!
+    // but power is not necessarily isPowerOfTwo(power)!
     return {
@@ -219,3 +245,6 @@ info: { G, powerOfTwo, oddFactor },
             else {
-                const res = field.invertBatch(this.roots(b));
+                // ωᴺ = 1, so inv(ωᵏ) = ωᴺ⁻ᵏ: the inverse table is the reversed roots table.
+                // Value-identical to field.invertBatch(roots), but skips its 3N muls + inversion.
+                const r = this.roots(b);
+                const res = [r[0]].concat(r.slice(1).reverse());
                 inverseCache.set(b, res);
@@ -236,3 +265,3 @@ return res;
  *
- * - DIT (Decimation-in-Time): Bottom-Up (leaves to root), Cool-Turkey
+ * - DIT (Decimation-in-Time): Bottom-Up (leaves to root), Cooley-Tukey
  * - DIF (Decimation-in-Frequency): Top-Down (root to leaves), Gentleman-Sande
@@ -249,4 +278,12 @@ *
  * Negacyclic NTT: Rq = Zq[x]/(x^n+1). butterfly_DIT+loop_DIF, at least for mlkem / mldsa
+ *
+ * `invertButterflies` indexes roots by a per-butterfly-group counter (`grp`): forward
+ * (`dit: false`) reads `roots[grp]` with grp = 1..; inverse (`dit: true`) reads `roots[N - grp]`
+ * with grp restarting at 1. With `skipStages: 0` one table serves both directions (ωᴺ = 1 makes
+ * the reversed walk self-inverse). With `skipStages > 0` the inverse walk starts at `N - 1`
+ * instead of continuing where the skipped stages would have left off, so the caller must supply
+ * a table shaped for that (ML-KEM: `ζ^BitRev7(i)` over all N=256 indices, whose aliased upper
+ * half is exactly the FIPS 203 inverse walk).
  * @param F - Field operations.
- * @param coreOpts - FFT configuration:
+ * @param coreOpts - FFT configuration. See {@link FFTCoreOpts}:
  *   - `N`: Transform size. Must be a power of two.
@@ -273,6 +310,13 @@ *   - `roots`: Stage roots for the selected transform size.
 export const FFTCore = (F, coreOpts) => {
+    validateObject(coreOpts, { N: 'number', roots: 'object', dit: 'boolean' }, { invertButterflies: 'boolean', skipStages: 'number', brp: 'boolean' }, 'coreOpts');
     const { N, roots, dit, invertButterflies = false, skipStages = 0, brp = true } = coreOpts;
+    checkU32(N, 'coreOpts.N');
     const bits = log2(N);
     if (!isPowerOfTwo(N))
         throw new Error('FFT: Polynomial size should be power of two');
+    checkU32(skipStages, 'coreOpts.skipStages');
+    const maxSkipStages = bits === 0 ? 0 : bits - 1;
+    // Skipping every stage leaves only boundary layout changes, not a valid FFT loop shape.
+    if (skipStages > maxSkipStages)
+        throw new Error(`FFT: wrong skipStages: expected 0 <= skipStages <= ${maxSkipStages}`);
     // Wrong-sized root tables can stay in-bounds for some loop shapes and silently compute nonsense.
@@ -282,3 +326,2 @@ if (roots.length !== N)
     const isDit = dit !== invertButterflies;
-    isDit;
     return (values) => {
@@ -345,13 +388,29 @@ if (values.length !== N)
 export function FFT(roots, opts) {
-    const getLoop = (N, roots, brpInput = false, brpOutput = false) => {
+    // Loops are cached per (size, direction, brp flags): FFTCore construction validates options
+    // and allocates closures, which costs more than a small transform itself. The cached loop
+    // closes over the root table active at first use; `roots.clear()` rebuilds value-identical
+    // tables, so a stale reference stays correct.
+    const loops = new Map();
+    const getLoop = (N, rootsTable, key) => {
+        const cached = loops.get(key);
+        if (cached)
+            return cached;
+        const brpInput = !!(key & 2);
+        const brpOutput = !!(key & 1);
+        let loop;
         if (brpInput && brpOutput) {
             // we cannot optimize this case, but lets support it anyway
-            return (values) => FFTCore(opts, { N, roots, dit: false, brp: false })(bitReversalInplace(values));
+            const core = FFTCore(opts, { N, roots: rootsTable, dit: false, brp: false });
+            loop = (values) => core(bitReversalInplace(values));
         }
-        if (brpInput)
-            return FFTCore(opts, { N, roots, dit: true, brp: false });
-        if (brpOutput)
-            return FFTCore(opts, { N, roots, dit: false, brp: false });
-        return FFTCore(opts, { N, roots, dit: true, brp: true }); // all natural
+        else if (brpInput)
+            loop = FFTCore(opts, { N, roots: rootsTable, dit: true, brp: false });
+        else if (brpOutput)
+            loop = FFTCore(opts, { N, roots: rootsTable, dit: false, brp: false });
+        else
+            loop = FFTCore(opts, { N, roots: rootsTable, dit: true, brp: true }); // all natural
+        loops.set(key, loop);
+        return loop;
     };
+    const loopKey = (bits, isInverse, brpInput, brpOutput) => (bits << 3) | (isInverse ? 4 : 0) | (brpInput ? 2 : 0) | (brpOutput ? 1 : 0);
     return {
@@ -363,3 +422,4 @@ direct(values, brpInput = false, brpOutput = false) {
             const bits = log2(N);
-            return getLoop(N, roots.roots(bits), brpInput, brpOutput)(values.slice());
+            const key = loopKey(bits, false, brpInput, brpOutput);
+            return getLoop(N, roots.roots(bits), key)(values.slice());
         },
@@ -371,3 +431,4 @@ inverse(values, brpInput = false, brpOutput = false) {
             const bits = log2(N);
-            const res = getLoop(N, roots.inverse(bits), brpInput, brpOutput)(values.slice());
+            const key = loopKey(bits, true, brpInput, brpOutput);
+            const res = getLoop(N, roots.inverse(bits), key)(values.slice());
             const ivm = opts.inv(BigInt(values.length)); // scale
@@ -385,2 +446,3 @@ // we can get brp output if we use dif instead of dit!
 export function poly(field, roots, create, fft, length) {
+    validateField(field);
     const F = field;
@@ -401,12 +463,14 @@ const _create = create ||
     };
-    const checkLength = (...lst) => {
-        if (!lst.length)
-            return 0;
-        for (const i of lst)
-            if (!isPoly(i))
-                throw new Error('poly: not polynomial: ' + i);
-        const L = lst[0].length;
-        for (let i = 1; i < lst.length; i++)
-            if (lst[i].length !== L)
-                throw new Error(`poly: mismatched lengths ${L} vs ${lst[i].length}`);
+    const checkPoly = (title, value) => {
+        if (!isPoly(value))
+            throw new TypeError(`"${title}" expected polynomial, got type=${typeof value}`);
+    };
+    const checkLength = (a, b) => {
+        checkPoly('a', a);
+        const L = a.length;
+        if (b !== undefined) {
+            checkPoly('b', b);
+            if (b.length !== L)
+                throw new Error(`poly: mismatched lengths ${L} vs ${b.length}`);
+        }
         if (length !== undefined && L !== length)
@@ -416,5 +480,7 @@ throw new Error(`poly: expected fixed length ${length}, got ${L}`);
     };
-    function findOmegaIndex(x, n, brp = false) {
-        const bits = log2(n);
-        const omega = brp ? roots.brp(bits) : roots.roots(bits);
+    function findOmegaIndex(x, n, brp = false, weights) {
+        if (!isPowerOfTwo(n))
+            throw new Error('poly.lagrange: expected power of two length, got ' + n);
+        // Explicit weights define the interpolation domain, including the Kronecker-δ shortcut.
+        const omega = weights || (brp ? roots.brp(log2(n)) : roots.roots(log2(n)));
         for (let i = 0; i < n; i++)
@@ -497,2 +563,4 @@ if (F.eql(x, omega[i]))
         convolve(a, b) {
+            checkPoly('a', a);
+            checkPoly('b', b);
             const len = nextPowerOfTwo(a.length + b.length - 1);
@@ -502,3 +570,8 @@ return this.mul(this.extend(a, len), this.extend(b, len));
         shift(p, factor) {
-            const out = _create(checkLength(p));
+            checkPoly('p', p);
+            const out = _create(p.length);
+            if (length !== undefined && p.length !== length)
+                throw new Error(`poly: expected fixed length ${length}, got ${p.length}`);
+            if (!p.length)
+                return out;
             out[0] = p[0];
@@ -546,2 +619,4 @@ for (let i = 1, power = F.ONE; i < p.length; i++) {
             basis: (x, n, brp = false, weights) => {
+                if (!isPowerOfTwo(n))
+                    throw new Error('poly.lagrange: expected power of two length, got ' + n);
                 const bits = log2(n);
@@ -551,3 +626,3 @@ const cache = weights || (brp ? roots.brp(bits) : roots.roots(bits)); // [ω⁰, ω¹, ..., ωⁿ⁻¹]
                 // Fast Kronecker-δ shortcut
-                const idx = findOmegaIndex(x, n, brp);
+                const idx = findOmegaIndex(x, n, brp, weights);
                 if (idx !== -1) {
@@ -581,3 +656,5 @@ out[idx] = F.ONE;
         vanishing(roots) {
-            checkLength(roots);
+            checkPoly('roots', roots);
+            if (length !== undefined && roots.length !== length)
+                throw new Error(`poly: expected fixed length ${length}, got ${roots.length}`);
             const out = _create(roots.length + 1, F.ZERO);
@@ -595,2 +672,1 @@ out[0] = F.ONE;
 }
-//# sourceMappingURL=fft.js.map

abstract/frost.d.ts

@@ -5,101 +5,265 @@ import { randomBytes, type TArg, type TRet } from '../utils.ts';
 import { type IField } from './modular.ts';
+/** Cryptographically secure random byte generator. */
 export type RNG = typeof randomBytes;
+/** Serialized participant identifier. Identifiers are hex to make comparison easier. */
 export type Identifier = string;
+/** Serialized point commitment. */
 export type Commitment = Uint8Array;
+/** Serialized scalar coefficient. */
 export type Coefficient = Uint8Array;
+/** Serialized Schnorr signature. */
 export type Signature = Uint8Array;
+/** Threshold participant counts. */
 export type Signers = {
+    /** Minimum number of signers required to produce a signature. */
     min: number;
+    /** Maximum number of participants in the key set. */
     max: number;
 };
+/** Serialized secret key bytes. */
 export type SecretKey = Uint8Array;
+/** Byte array alias used by FROST public packages. */
 export type Bytes = Uint8Array;
 type Point = Uint8Array;
+/** Public DKG round-1 broadcast plus proof of knowledge. */
 export type DKG_Round1 = {
+    /** Sender identifier. */
     identifier: Identifier;
+    /** VSS commitment points. */
     commitment: TRet<Commitment[]>;
+    /** Signature proving knowledge of the sender's secret coefficient. */
     proofOfKnowledge: TRet<Signature>;
 };
+/** Public DKG round-2 recipient share package. */
 export type DKG_Round2 = {
+    /** Sender identifier. */
     identifier: Identifier;
+    /** Signing share for one receiver. */
     signingShare: TRet<Bytes>;
 };
+/** Internal mutable DKG state package. */
 export type DKG_Secret = {
+    /** Local participant identifier as a scalar. */
     identifier: bigint;
+    /** Local secret polynomial coefficients while DKG is in progress. */
     coefficients?: bigint[];
+    /** Local VSS commitment points. */
     commitment: TRet<Point[]>;
+    /** Threshold participant counts. */
     signers: Signers;
+    /** Cached round2 packages from the first successful round2 call. */
+    round2Cache?: Record<Identifier, DKG_Round2>;
+    /** Current DKG state-machine step. */
     step?: 1 | 2 | 3;
 };
+/** Shared public FROST package for one key set. */
 export type FrostPublic = {
+    /** Threshold participant counts. */
     signers: Signers;
+    /** Serialized commitment points; `commitments[0]` is the group public key. */
     commitments: TRet<Bytes[]>;
+    /** Map from participant identifier to serialized verifying-share point. */
     verifyingShares: TRet<Record<Identifier, Bytes>>;
 };
+/** Secret FROST share for one participant. */
 export type FrostSecret = {
+    /** Participant identifier. */
     identifier: Identifier;
+    /** Serialized scalar signing share. */
     signingShare: TRet<Bytes>;
 };
+/** Combined public and secret FROST packages for one participant. */
 export type Key = {
+    /** Shared public package. */
     public: FrostPublic;
+    /** Participant secret package. */
     secret: FrostSecret;
 };
+/** Trusted-dealer output containing public data and all participant shares. */
 export type DealerShares = {
+    /** Shared public package. */
     public: FrostPublic;
+    /** Map from participant identifier to its secret share. */
     secretShares: Record<Identifier, FrostSecret>;
 };
+/** Private nonce scalars used once during signing. */
 export type Nonces = {
+    /** Serialized hiding nonce scalar. */
     hiding: TRet<Bytes>;
+    /** Serialized binding nonce scalar. */
     binding: TRet<Bytes>;
 };
+/** Public nonce commitments broadcast for one signing attempt. */
 export type NonceCommitments = {
+    /** Participant identifier. */
     identifier: Identifier;
+    /** Serialized hiding nonce point. */
     hiding: TRet<Bytes>;
+    /** Serialized binding nonce point. */
     binding: TRet<Bytes>;
 };
+/** Generated nonce package containing private nonces and public commitments. */
 export type GenNonce = {
+    /** Private nonce scalars. */
     nonces: Nonces;
+    /** Public nonce commitments. */
     commitments: NonceCommitments;
 };
+/** Point interface required by the generic FROST implementation. */
 export interface FROSTPoint<T extends CurvePoint<any, T>> extends CurvePoint<any, T> {
+    /**
+     * Adds another point.
+     * @param rhs - Point to add.
+     * @returns Point sum.
+     */
     add(rhs: T): T;
+    /**
+     * Multiplies by a scalar.
+     * @param rhs - Scalar multiplier.
+     * @returns Scalar multiplication result.
+     */
     multiply(rhs: bigint): T;
+    /**
+     * Compares two points.
+     * @param rhs - Point to compare.
+     * @returns Whether points are equal.
+     */
     equals(rhs: T): boolean;
+    /**
+     * Serializes a point.
+     * @param compressed - Whether to use compressed encoding.
+     * @returns Encoded point bytes.
+     */
     toBytes(compressed?: boolean): Bytes;
+    /**
+     * Clears the point cofactor.
+     * @returns Cofactor-cleared point.
+     */
     clearCofactor(): T;
 }
+/** Point constructor surface required by FROST. */
 export interface FROSTPointConstructor<T extends FROSTPoint<T>> extends CurvePointCons<T> {
+    /**
+     * Parses a point from bytes.
+     * @param a - Encoded point bytes.
+     * @returns Parsed point.
+     */
     fromBytes(a: Bytes): T;
+    /** Scalar field used by the point group. */
     Fn: IField<bigint>;
 }
+/** Construction options for a concrete FROST ciphersuite. */
 export type FrostOpts<P extends FROSTPoint<P>> = {
+    /** Ciphersuite name. */
     readonly name: string;
+    /** Point constructor for the signing group. */
     readonly Point: FROSTPointConstructor<P>;
+    /** Optional scalar-field override. */
     readonly Fn?: IField<bigint>;
-    /** Optional suite hook that tightens canonical decoding with subgroup / identity checks. */
+    /**
+     * Optional suite hook that tightens canonical decoding with subgroup / identity checks.
+     * @param p - Point to validate.
+     */
     readonly validatePoint?: (p: P) => void;
-    /** Optional public-key parser. Implementations MUST preserve the same subgroup / identity policy
-     * as `validatePoint`, because this bypasses generic canonical decoding in `parsePoint()`. */
+    /**
+     * Optional public-key parser. Implementations MUST preserve the same subgroup / identity policy
+     * as `validatePoint`, because this bypasses generic canonical decoding in `parsePoint()`.
+     * @param bytes - Encoded public key.
+     * @returns Parsed public point.
+     */
     readonly parsePublicKey?: (bytes: TArg<Uint8Array>) => P;
+    /**
+     * Hash function used by the suite.
+     * @param msg - Message bytes to hash.
+     * @returns Hash output bytes.
+     */
     readonly hash: (msg: TArg<Uint8Array>) => TRet<Uint8Array>;
-    /** Custom scalar hash hook. Implementations MUST treat `msg` and `options` as read-only. */
+    /**
+     * Custom scalar hash hook. Implementations MUST treat `msg` and `options` as read-only.
+     * @param msg - Message bytes to hash.
+     * @param options - Hash-to-curve options. See {@link H2CDSTOpts}.
+     * @returns Scalar field element.
+     */
     readonly hashToScalar?: (msg: TArg<Uint8Array>, options?: TArg<H2CDSTOpts>) => bigint;
+    /**
+     * Optional scalar adjustment hook.
+     * @param n - Scalar to adjust.
+     * @returns Adjusted scalar.
+     */
     readonly adjustScalar?: (n: bigint) => bigint;
+    /**
+     * Optional point adjustment hook.
+     * @param n - Point to adjust.
+     * @returns Adjusted point.
+     */
     readonly adjustPoint?: (n: P) => P;
+    /**
+     * Optional challenge override.
+     * @param R - Group commitment point.
+     * @param PK - Group public key point.
+     * @param msg - Message bytes.
+     * @returns Challenge scalar.
+     */
     readonly challenge?: (R: P, PK: P, msg: TArg<Uint8Array>) => bigint;
-    readonly adjustNonces?: (PK: P, nonces: TArg<Nonces>) => TRet<Nonces>;
+    /**
+     * Optional nonce-package adjustment hook.
+     * @param R - Group commitment point for the current signing session.
+     * @param nonces - Nonce package.
+     * @returns Adjusted nonce package.
+     */
+    readonly adjustNonces?: (R: P, nonces: TArg<Nonces>) => TRet<Nonces>;
+    /**
+     * Optional secret-package adjustment hook.
+     * @param secret - Secret package.
+     * @param pub - Public package.
+     * @returns Adjusted secret package.
+     */
     readonly adjustSecret?: (secret: TArg<FrostSecret>, pub: TArg<FrostPublic>) => TRet<FrostSecret>;
+    /**
+     * Optional public-package adjustment hook.
+     * @param pub - Public package.
+     * @returns Adjusted public package.
+     */
     readonly adjustPublic?: (pub: TArg<FrostPublic>) => TRet<FrostPublic>;
+    /**
+     * Optional group commitment-share adjustment hook.
+     * @param GC - Group commitment.
+     * @param GCShare - Participant commitment share.
+     * @returns Adjusted group commitment share.
+     */
     readonly adjustGroupCommitmentShare?: (GC: P, GCShare: P) => P;
+    /** Optional transaction encoder / decoder adjustment. */
     readonly adjustTx?: {
+        /**
+         * Encode transaction bytes before signing.
+         * @param tx - Transaction bytes.
+         * @returns Encoded transaction bytes.
+         */
         readonly encode: (tx: TArg<Uint8Array>) => TRet<Uint8Array>;
+        /**
+         * Decode transaction bytes after verification.
+         * @param tx - Encoded transaction bytes.
+         * @returns Decoded transaction bytes.
+         */
         readonly decode: (tx: TArg<Uint8Array>) => TRet<Uint8Array>;
     };
+    /**
+     * Optional DKG output adjustment hook.
+     * @param k - DKG key package.
+     * @returns Adjusted DKG key package.
+     */
     readonly adjustDKG?: (k: TArg<Key>) => TRet<Key>;
+    /** Prefix for RFC 9591 H1. */
     readonly H1?: string;
+    /** Prefix for RFC 9591 H2. */
     readonly H2?: string;
+    /** Prefix for RFC 9591 H3. */
     readonly H3?: string;
+    /** Prefix for RFC 9591 H4. */
     readonly H4?: string;
+    /** Prefix for RFC 9591 H5. */
     readonly H5?: string;
+    /** Prefix for DKG hashing. */
     readonly HDKG?: string;
+    /** Prefix for identifier derivation. */
     readonly HID?: string;
@@ -109,8 +273,6 @@ };
  * FROST: Threshold Protocol for Two‑Round Schnorr Signatures
- * from [RFC 9591](https://datatracker.ietf.org/doc/rfc9591/).
+ * from {@link https://datatracker.ietf.org/doc/rfc9591/ | RFC 9591}.
  */
 export type FROST = {
-    /**
-     * Methods to construct participant identifiers.
-     */
+    /** Methods to construct participant identifiers. */
     Identifier: {
@@ -264,5 +426,3 @@ /**
     combineSecret(shares: TArg<FrostSecret[]>, signers: Signers): TRet<Uint8Array>;
-    /**
-     * Low-level helper utilities (field arithmetic and polynomial tools).
-     */
+    /** Low-level helper utilities (field arithmetic and polynomial tools). */
     utils: {
@@ -294,4 +454,20 @@ /**
 };
+/**
+ * Builds a FROST ciphersuite API from concrete curve and hash hooks.
+ * @param opts - Ciphersuite construction options. See {@link FrostOpts}.
+ * @returns FROST API bound to the supplied ciphersuite.
+ * @example
+ * Create a suite from a curve-specific option object.
+ * ```ts
+ * import { createFROST } from '@noble/curves/abstract/frost.js';
+ * import { ed25519 } from '@noble/curves/ed25519.js';
+ * import { sha512 } from '@noble/hashes/sha2.js';
+ * const frost = createFROST({
+ *   name: 'FROST-ED25519-SHA512-v1',
+ *   Point: ed25519.Point,
+ *   hash: sha512,
+ * });
+ * ```
+ */
 export declare function createFROST<P extends FROSTPoint<P>>(opts: FrostOpts<P>): TRet<FROST>;
 export {};
-//# sourceMappingURL=frost.d.ts.map

abstract/frost.js

 /**
  * FROST: Flexible Round-Optimized Schnorr Threshold Protocol for Two-Round Schnorr Signatures.
  *
- * See [RFC 9591](https://datatracker.ietf.org/doc/rfc9591/) and [frost.zfnd.org](https://frost.zfnd.org).
+ * See {@link https://datatracker.ietf.org/doc/rfc9591/ | RFC 9591} and
+ * {@link https://frost.zfnd.org | frost.zfnd.org}.
  * @module
  */
 import { utf8ToBytes } from '@noble/hashes/utils.js';
-import { bytesToHex, bytesToNumberBE, bytesToNumberLE, concatBytes, hexToBytes, randomBytes, validateObject, } from "../utils.js";
-import { pippenger, validatePointCons } from "./curve.js";
+import { aarray, abytes, asafenumber, astring, bytesToHex, bytesToNumberBE, bytesToNumberLE, concatBytes, hexToBytes, randomBytes, validateObject, } from "../utils.js";
+import { mulAddUnsafe, validatePointCons } from "./curve.js";
 import { poly } from "./fft.js";
@@ -15,5 +16,6 @@ import {} from "./hash-to-curve.js";
 // PrivKey = id, signingShare, commitment
-const validateSigners = (signers) => {
-    if (!Number.isSafeInteger(signers.min) || !Number.isSafeInteger(signers.max))
-        throw new Error('Wrong signers info: min=' + signers.min + ' max=' + signers.max);
+const validateSigners = (signers, title = 'signers') => {
+    validateObject(signers, { min: 'number', max: 'number' }, {}, title);
+    asafenumber(signers.min, title + '.min');
+    asafenumber(signers.max, title + '.max');
     // Compatibility with frost-rs intentionally narrows RFC 9591's positive-nonzero threshold rule
@@ -39,2 +41,19 @@ // to `min >= 2`, even though the RFC text itself allows `MIN_PARTICIPANTS = 1`.
 }
+/**
+ * Builds a FROST ciphersuite API from concrete curve and hash hooks.
+ * @param opts - Ciphersuite construction options. See {@link FrostOpts}.
+ * @returns FROST API bound to the supplied ciphersuite.
+ * @example
+ * Create a suite from a curve-specific option object.
+ * ```ts
+ * import { createFROST } from '@noble/curves/abstract/frost.js';
+ * import { ed25519 } from '@noble/curves/ed25519.js';
+ * import { sha512 } from '@noble/hashes/sha2.js';
+ * const frost = createFROST({
+ *   name: 'FROST-ED25519-SHA512-v1',
+ *   Point: ed25519.Point,
+ *   hash: sha512,
+ * });
+ * ```
+ */
 export function createFROST(opts) {
@@ -89,2 +108,4 @@ validateObject(opts, {
     const randomScalar = (rng = randomBytes) => {
+        if (typeof rng !== 'function')
+            throw new TypeError('"rng" expected function, got type=' + typeof rng);
         // Intentional divergence from RFC 9591 §4.1 / §5.1: the RFC nonce_generate helper outputs a
@@ -125,3 +146,4 @@ // Scalar in [0, p-1], but round-one commit publishes ScalarBaseMult(nonce) values and §3.1
     const serializeIdentifier = (id) => bytesToHex(Fn.toBytes(validateIdentifier(id)));
-    const parseIdentifier = (id) => {
+    const parseIdentifier = (id, title = 'identifier') => {
+        astring(id, title);
         const n = validateIdentifier(Fn.fromBytes(hexToBytes(id)));
@@ -146,3 +168,8 @@ // Keep string-keyed maps stable by accepting only the canonical serialized form.
             // We don't know size of point, but we know size of scalar
-            const R = parsePoint(sig.subarray(0, -Fn.BYTES));
+            const Rbytes = sig.subarray(0, -Fn.BYTES);
+            const R = parsePoint(Rbytes);
+            // RFC 9591 Section 3.1 SerializeElement is canonical: a signature must not verify under an
+            // alternative point encoding (e.g. re-encoding a weierstrass R uncompressed as 65 bytes).
+            if (serializePoint(R).length !== Rbytes.length)
+                throw new Error('invalid signature encoding');
             const z = Fn.fromBytes(sig.subarray(-Fn.BYTES));
@@ -181,3 +208,5 @@ return { R, z };
     const Poly = poly(Fn, noRoots);
-    const msm = (points, scalars) => pippenger(Point, points, scalars);
+    // Variable-time MSM over public inputs only (VSS / nonce commitments, binding factors).
+    // Interleaved wNAF beats pippenger ~3x at FROST-sized inputs (n <= dozens of signers).
+    const msm = (points, scalars) => mulAddUnsafe(Point, points, scalars);
     // Internal stuff uses bigints & Points, external Uint8Arrays
@@ -219,2 +248,8 @@ const polynomialEvaluate = (x, coeffs) => {
         validateSigners(signers);
+        if (secret !== undefined)
+            abytes(secret, Fn.BYTES, 'secret');
+        if (coeffs !== undefined)
+            aarray(coeffs, 'coeffs');
+        if (typeof rng !== 'function')
+            throw new TypeError('"rng" expected function, got type=' + typeof rng);
         // Dealer/DKG polynomial sampling reuses the same hardened scalar derivation as round-one
@@ -253,4 +288,4 @@ // nonces: overriding `rng` only swaps the entropy source, not the non-zero `1..n-1` policy.
             const c = this.challenge(id, phi, R);
-            // R === z*G - phi*c
-            if (!R.equals(Point.BASE.multiply(z).subtract(phi.multiply(c))))
+            // R === z*G - phi*c. All inputs are public: variable-time multiplication is safe here.
+            if (!R.equals(Point.BASE.multiplyUnsafe(z).subtract(phi.multiplyUnsafe(c))))
                 throw new Error('invalid proof of knowledge');
@@ -277,5 +312,6 @@ },
                 R = opts.adjustPoint(R);
+            // Signature, message and public key are all public: variable-time is safe on this path.
             const c = this.challenge(R, PK, msg);
-            const zB = Point.BASE.multiply(z); // z*G
-            const cA = PK.multiply(c); // c*PK
+            const zB = Point.BASE.multiplyUnsafe(z); // z*G
+            const cA = PK.multiplyUnsafe(c); // c*PK
             let check = zB.subtract(cA).subtract(R); // zB - cA - R
@@ -306,4 +342,3 @@ // No clearCoffactor on ristretto
         derive(s) {
-            if (typeof s !== 'string')
-                throw new Error('wrong identifier string: ' + s);
+            astring(s, 's');
             // Derived identifiers may land anywhere in the scalar field; they are not restricted to
@@ -336,2 +371,5 @@ // sequential `1..max_signers` values.
         }
+        // Hiding commitments all carry scalar 1, so add them directly and keep only the
+        // binding commitments in the MSM: same result, half the MSM size.
+        let hidingSum = Point.ZERO;
         const points = [];
@@ -342,6 +380,7 @@ const scalars = [];
                 throw new Error('infinity commitment');
-            points.push(hC, bC);
-            scalars.push(Fn.ONE, bindingFactors[i]);
+            hidingSum = hidingSum.add(hC);
+            points.push(bC);
+            scalars.push(bindingFactors[i]);
         }
-        const groupCommitment = msm(points, scalars); //  GC += hC + bC*bindingFactor
+        const groupCommitment = hidingSum.add(msm(points, scalars)); //  GC += hC + bC*bindingFactor
         const identifiers = CL.map((i) => i[1]);
@@ -368,4 +407,4 @@ return { identifiers, groupCommitment, bindingFactors };
             round1: (id, signers, secret, rng = randomBytes) => {
+                const idNum = parseIdentifier(id, 'id');
                 validateSigners(signers);
-                const idNum = parseIdentifier(id);
                 const { coefficients, commitment } = generateSecretPolynomial(signers, secret, undefined, rng);
@@ -391,2 +430,5 @@ const proofOfKnowledge = ProofOfKnowledge.compute(idNum, coefficients, commitment, rng);
             round2: (secret, others) => {
+                validateObject(secret, { identifier: 'bigint', commitment: 'object', signers: 'object' }, { coefficients: 'object', round2Cache: 'object', step: 'number' }, 'secret');
+                validateSigners(secret.signers, 'secret.signers');
+                aarray(others, 'others');
                 if (others.length !== secret.signers.max - 1)
@@ -396,2 +438,4 @@ throw new Error('wrong number of round1 packages');
                     throw new Error('round3 package used in round2');
+                if (secret.round2Cache !== undefined)
+                    return secret.round2Cache;
                 const res = {};
@@ -415,2 +459,3 @@ for (const p of others) {
                 }
+                secret.round2Cache = res;
                 secret.step = 2;
@@ -420,2 +465,6 @@ return res;
             round3: (secret, round1, round2) => {
+                validateObject(secret, { identifier: 'bigint', commitment: 'object', signers: 'object' }, { coefficients: 'object', round2Cache: 'object', step: 'number' }, 'secret');
+                validateSigners(secret.signers, 'secret.signers');
+                aarray(round1, 'round1');
+                aarray(round2, 'round2');
                 // DKG is outside RFC 9591's signing flow; callers are expected to reuse the same
@@ -498,2 +547,3 @@ // remote round1 packages already accepted in round2, like frost-rs documents.
                 delete secret.coefficients;
+                delete secret.round2Cache;
                 secret.step = 3;
@@ -503,2 +553,3 @@ return res;
             clean(secret) {
+                validateObject(secret, { identifier: 'bigint', commitment: 'object', signers: 'object' }, { coefficients: 'object', round2Cache: 'object', step: 'number' }, 'secret');
                 // Instead of replacing secret bigint with another (zero?), we subtract it from itself
@@ -513,2 +564,3 @@ // in the hope that JIT will modify it inplace, instead of creating new value.
                 // for (const c of secret.commitment) c.fill(0);
+                delete secret.round2Cache;
                 secret.step = 3;
@@ -528,3 +580,4 @@ },
             else {
-                if (!Array.isArray(identifiers) || identifiers.length !== signers.max)
+                aarray(identifiers, 'identifiers');
+                if (identifiers.length !== signers.max)
                     throw new Error('identifiers should be array of ' + signers.max);
@@ -562,2 +615,11 @@ }
         validateSecret(secret, pub) {
+            validateObject(secret, { identifier: 'string', signingShare: 'object' }, {}, 'secret');
+            abytes(secret.signingShare, Fn.BYTES, 'secret.signingShare');
+            validateObject(pub, {
+                signers: 'object',
+                commitments: 'object',
+                verifyingShares: 'object',
+            }, {}, 'pub');
+            validateSigners(pub.signers, 'pub.signers');
+            aarray(pub.commitments, 'pub.commitments');
             const id = parseIdentifier(secret.identifier);
@@ -576,2 +638,6 @@ const commitment = pub.commitments.map(parsePoint);
         commit(secret, rng = randomBytes) {
+            validateObject(secret, { identifier: 'string', signingShare: 'object' }, {}, 'secret');
+            abytes(secret.signingShare, Fn.BYTES, 'secret.signingShare');
+            if (typeof rng !== 'function')
+                throw new TypeError('"rng" expected function, got type=' + typeof rng);
             const secretScalar = Fn.fromBytes(secret.signingShare);
@@ -586,2 +652,16 @@ const hiding = generateNonce(secretScalar, rng);
         signShare(secret, pub, nonces, commitmentList, msg) {
+            validateObject(secret, { identifier: 'string', signingShare: 'object' }, {}, 'secret');
+            abytes(secret.signingShare, Fn.BYTES, 'secret.signingShare');
+            validateObject(pub, {
+                signers: 'object',
+                commitments: 'object',
+                verifyingShares: 'object',
+            }, {}, 'pub');
+            validateSigners(pub.signers, 'pub.signers');
+            aarray(pub.commitments, 'pub.commitments');
+            validateObject(nonces, { hiding: 'object', binding: 'object' }, {}, 'nonces');
+            abytes(nonces.hiding, Fn.BYTES, 'nonces.hiding');
+            abytes(nonces.binding, Fn.BYTES, 'nonces.binding');
+            aarray(commitmentList, 'commitmentList');
+            abytes(msg, undefined, 'msg');
             validateCommitmentsNum(pub.signers, commitmentList.length);
@@ -627,2 +707,13 @@ const hidingNonce0 = Fn.fromBytes(nonces.hiding);
         verifyShare(pub, commitmentList, msg, identifier, sigShare) {
+            validateObject(pub, {
+                signers: 'object',
+                commitments: 'object',
+                verifyingShares: 'object',
+            }, {}, 'pub');
+            validateSigners(pub.signers, 'pub.signers');
+            aarray(pub.commitments, 'pub.commitments');
+            aarray(commitmentList, 'commitmentList');
+            abytes(msg, undefined, 'msg');
+            parseIdentifier(identifier);
+            abytes(sigShare, Fn.BYTES, 'sigShare');
             if (opts.adjustPublic)
@@ -637,9 +728,10 @@ pub = opts.adjustPublic(pub);
             const { lambda, challenge, bindingFactor, groupCommitment } = prepareShare(pub.commitments[0], commitmentList, msg, identifier);
+            // Signature shares, commitments and verifying shares are public: vartime is safe here.
             // hC + bC * bF
-            let commShare = hidingNonceCommitment.add(bindingNonceCommitment.multiply(bindingFactor));
+            let commShare = hidingNonceCommitment.add(bindingNonceCommitment.multiplyUnsafe(bindingFactor));
             if (opts.adjustGroupCommitmentShare)
                 commShare = opts.adjustGroupCommitmentShare(groupCommitment, commShare);
-            const l = Point.BASE.multiply(Fn.fromBytes(sigShare)); // sigShare*G
+            const l = Point.BASE.multiplyUnsafe(Fn.fromBytes(sigShare)); // sigShare*G
             // commShare + PK * (challenge * lambda)
-            const r = commShare.add(PK.multiply(Fn.mul(challenge, lambda)));
+            const r = commShare.add(PK.multiplyUnsafe(Fn.mul(challenge, lambda)));
             return l.equals(r);
@@ -649,2 +741,14 @@ },
         aggregate(pub, commitmentList, msg, sigShares) {
+            validateObject(pub, {
+                signers: 'object',
+                commitments: 'object',
+                verifyingShares: 'object',
+            }, {}, 'pub');
+            validateSigners(pub.signers, 'pub.signers');
+            aarray(pub.commitments, 'pub.commitments');
+            aarray(commitmentList, 'commitmentList');
+            abytes(msg, undefined, 'msg');
+            validateObject(sigShares, {}, {}, 'sigShares');
+            // verifyShare() applies adjustPublic too, so keep the original package for attribution.
+            const rawPub = pub;
             if (opts.adjustPublic)
@@ -659,2 +763,9 @@ pub = opts.adjustPublic(pub);
             const ids = commitmentList.map((i) => i.identifier);
+            const seen = new Set();
+            for (const id of ids) {
+                // `sigShares` is identifier-keyed, so duplicate commitments would reuse one share twice.
+                if (seen.has(id))
+                    throw new AggErr('aggregation failed', []);
+                seen.add(id);
+            }
             if (ids.length !== Object.keys(sigShares).length)
@@ -675,3 +786,3 @@ throw new AggErr('aggregation failed', []);
                 for (const id of ids) {
-                    if (!this.verifyShare(pub, commitmentList, msg, id, sigShares[id]))
+                    if (!this.verifyShare(rawPub, commitmentList, msg, id, sigShares[id]))
                         cheaters.push(id);
@@ -699,4 +810,5 @@ }
         combineSecret(shares, signers) {
+            aarray(shares, 'shares');
             validateSigners(signers);
-            if (!Array.isArray(shares) || shares.length < signers.min)
+            if (shares.length < signers.min || shares.length > signers.max)
                 throw new Error('wrong secret shares array');
@@ -734,2 +846,1 @@ const points = [];
 }
-//# sourceMappingURL=frost.js.map

abstract/hash-to-curve.d.ts

@@ -212,4 +212,4 @@ /**
  * @param mapToCurve - Map-to-curve function.
- * @param defaults - Default hash-to-curve options. This object is frozen in place and reused as
- *   the shared defaults bundle for the returned helpers.
+ * @param defaults - Default hash-to-curve options. A frozen detached snapshot is reused as the
+ *   shared defaults bundle for the returned helpers.
  * @returns Hash-to-curve helper namespace.
@@ -239,3 +239,55 @@ * @throws If the map-to-curve callback or default hash-to-curve options are invalid. {@link Error}
 }>): H2CHasher<PC>;
+/**
+ * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.
+ * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.
+ * b = True and y = sqrt(u / v) if (u / v) is square in F, and
+ * b = False and y = sqrt(Z * (u / v)) otherwise.
+ * RFC 9380 expects callers to provide `v != 0`; this helper does not enforce it.
+ * @param Fp - Field implementation.
+ * @param Z - Simplified SWU map parameter.
+ * @returns Square-root ratio helper.
+ * @example
+ * Build the square-root ratio helper used by SWU map implementations.
+ *
+ * ```ts
+ * import { SWUFpSqrtRatio } from '@noble/curves/abstract/hash-to-curve.js';
+ * import { Field } from '@noble/curves/abstract/modular.js';
+ * const Fp = Field(17n);
+ * const sqrtRatio = SWUFpSqrtRatio(Fp, 3n);
+ * const out = sqrtRatio(4n, 1n);
+ * ```
+ */
+export declare function SWUFpSqrtRatio<T>(Fp: TArg<IField<T>>, Z: T): (u: T, v: T) => {
+    isValid: boolean;
+    value: T;
+};
+/**
+ * Simplified Shallue-van de Woestijne-Ulas Method
+ * See {@link https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2 | RFC 9380 section 6.6.2}.
+ * @param Fp - Field implementation.
+ * @param opts - SWU parameters:
+ *   - `A`: Curve parameter `A`.
+ *   - `B`: Curve parameter `B`.
+ *   - `Z`: Simplified SWU map parameter.
+ * @returns Deterministic map-to-curve function.
+ * @throws If the SWU parameters are invalid or the field lacks the required helpers. {@link Error}
+ * @example
+ * Map one field element to a Weierstrass curve point with the SWU recipe.
+ *
+ * ```ts
+ * import { mapToCurveSimpleSWU } from '@noble/curves/abstract/hash-to-curve.js';
+ * import { Field } from '@noble/curves/abstract/modular.js';
+ * const Fp = Field(17n);
+ * const map = mapToCurveSimpleSWU(Fp, { A: 1n, B: 2n, Z: 3n });
+ * const point = map(5n);
+ * ```
+ */
+export declare function mapToCurveSimpleSWU<T>(Fp: TArg<IField<T>>, opts: {
+    A: T;
+    B: T;
+    Z: T;
+}): (u: T) => {
+    x: T;
+    y: T;
+};
 export {};
-//# sourceMappingURL=hash-to-curve.d.ts.map

abstract/hash-to-curve.js

@@ -1,3 +0,5 @@
-import { abytes, asafenumber, asciiToBytes, bytesToNumberBE, copyBytes, concatBytes, isBytes, validateObject, } from "../utils.js";
-import { FpInvertBatch, mod } from "./modular.js";
+import { aarray, abytes, asafenumber, asciiToBytes, bytesToNumberBE, concatBytes, copyBytes, isBytes, validateObject, } from "../utils.js";
+import { FpInvertBatch, FpIsSquare, mod, validateField } from "./modular.js";
+// prettier-ignore
+const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4);
 // Octet Stream to Integer. "spec" implementation of os2ip is 2.5x slower vs bytesToNumberBE.
@@ -64,2 +66,6 @@ const os2ip = bytesToNumberBE;
     asafenumber(lenInBytes);
+    if (typeof H !== 'function')
+        throw new Error('expand_message_xmd: expected hash function');
+    asafenumber(H.outputLen, 'hash.outputLen');
+    asafenumber(H.blockLen, 'hash.blockLen');
     DST = normDST(DST);
@@ -121,3 +127,12 @@ // https://www.rfc-editor.org/rfc/rfc9380#section-5.3.3
     asafenumber(lenInBytes);
+    asafenumber(k, 'k');
+    if (k < 0)
+        throw new Error('expand_message_xof: invalid k');
+    if (typeof H !== 'function')
+        throw new Error('expand_message_xof: expected XOF function');
+    if (typeof H.create !== 'function')
+        throw new Error('expand_message_xof: expected XOF create');
     DST = normDST(DST);
+    if (lenInBytes < 0 || lenInBytes > 65535)
+        throw new Error('expand_message_xof: invalid lenInBytes');
     // https://www.rfc-editor.org/rfc/rfc9380#section-5.3.3
@@ -129,4 +144,6 @@ // RFC 9380 §5.3.3: DST = H("H2C-OVERSIZE-DST-" || a_very_long_DST, ceil(2 * k / 8)).
     }
-    if (lenInBytes > 65535 || DST.length > 255)
-        throw new Error('expand_message_xof: invalid lenInBytes');
+    // Oversize DSTs are compressed above; fail closed if a custom XOF still returns one
+    // (possible when k > 1020 makes the compression dkLen itself exceed 255 bytes).
+    if (DST.length > 255)
+        throw new Error('expand_message_xof: invalid DST');
     return (H.create({ dkLen: lenInBytes })
@@ -175,4 +192,9 @@ .update(msg)
     asafenumber(count);
-    // RFC 9380 §5.2 defines hash_to_field over a list of one or more field elements and requires
+    asafenumber(m, 'm');
+    asafenumber(k, 'k');
+    // RFC 9380 §5.2 defines hash_to_field over a list of one or more field elements and an integer
     // extension degree `m >= 1`; rejecting here avoids degenerate `[]` / `[[]]` helper outputs.
+    // The RFC also treats `p` as a finite-field characteristic; bad values degenerate log2/mod.
+    if (p <= BigInt(1))
+        throw new Error('hash_to_field: expected valid field characteristic');
     if (count < 1)
@@ -182,2 +204,4 @@ throw new Error('hash_to_field: expected count >= 1');
         throw new Error('hash_to_field: expected m >= 1');
+    if (k < 0)
+        throw new Error('hash_to_field: invalid k');
     const log2p = p.toString(2).length;
@@ -194,3 +218,4 @@ const L = Math.ceil((log2p + k) / 8); // section 5.1 of ietf draft link above
     else if (expand === '_internal_pass') {
-        // for internal tests only
+        // for internal tests only: msg is used as the uniform bytes directly. Short msg is allowed
+        // on purpose (subarray() slices are short): zkcrypto map_scalar vectors feed empty okm.
         prb = msg;
@@ -229,8 +254,14 @@ }
 export function isogenyMap(field, map) {
+    validateField(field);
     // Make same order as in spec
-    const coeff = map.map((i) => Array.from(i).reverse());
+    aarray(map, 'map');
+    const coeff = map.map((i, row) => {
+        aarray(i, 'map[' + row + ']');
+        if (i.length < 1)
+            throw new Error('isogenyMap: expected non-empty coefficients');
+        return Array.from(i).reverse();
+    });
     return (x, y) => {
         const [xn, xd, yn, yd] = coeff.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
-        // RFC 9380 §6.6.3 / Appendix E: denominator-zero exceptional cases must
-        // return the identity on E.
+        const isZero = field.is0(xd) || field.is0(yd);
         // Shipped Weierstrass consumers encode that affine identity as all-zero
@@ -242,3 +273,5 @@ // coordinates, so `passZero=true` intentionally collapses zero
         y = field.mul(y, field.mul(yn, yd_inv)); // y * (yNum / yDev)
-        return { x, y };
+        // RFC 9380 §6.6.3: if the denominator of either isogeny rational function is
+        // zero, the exceptional case must return the identity point on E.
+        return isZero ? { x: field.ZERO, y: field.ZERO } : { x, y };
     };
@@ -256,4 +289,4 @@ }
  * @param mapToCurve - Map-to-curve function.
- * @param defaults - Default hash-to-curve options. This object is frozen in place and reused as
- *   the shared defaults bundle for the returned helpers.
+ * @param defaults - Default hash-to-curve options. A frozen detached snapshot is reused as the
+ *   shared defaults bundle for the returned helpers.
  * @returns Hash-to-curve helper namespace.
@@ -283,2 +316,3 @@ * @throws If the map-to-curve callback or default hash-to-curve options are invalid. {@link Error}
         throw new Error('mapToCurve() must be defined');
+    validateObject(defaults);
     // `Point` is intentionally not shape-validated eagerly here: point constructors vary across
@@ -299,2 +333,6 @@ // curve families, so this helper only checks the hooks it can validate cheaply. Misconfigured
     const safeDefaults = snapshot(defaults);
+    // Per-call options are H2CDSTOpts: only DST may be overridden. Copying just that key keeps
+    // off-type option objects from silently replacing suite parameters (p/m/k/hash/expand) at
+    // runtime — same pinning hashToScalar always did for p/m.
+    const dstOverride = (options) => options && options.DST !== undefined ? { DST: options.DST } : undefined;
     function map(num) {
@@ -318,3 +356,3 @@ return Point.fromAffine(mapToCurve(num));
         hashToCurve(msg, options) {
-            const opts = Object.assign({}, safeDefaults, options);
+            const opts = Object.assign({}, safeDefaults, dstOverride(options));
             const u = hash_to_field(msg, 2, opts);
@@ -326,4 +364,4 @@ const u0 = map(u[0]);
         encodeToCurve(msg, options) {
-            const optsDst = safeDefaults.encodeDST ? { DST: safeDefaults.encodeDST } : {};
-            const opts = Object.assign({}, safeDefaults, optsDst, options);
+            const optsDst = safeDefaults.encodeDST === undefined ? {} : { DST: safeDefaults.encodeDST };
+            const opts = Object.assign({}, safeDefaults, optsDst, dstOverride(options));
             const u = hash_to_field(msg, 1, opts);
@@ -343,2 +381,5 @@ const u0 = map(u[0]);
                 throw new Error('expected array of bigints');
+            // RFC 9380 represents one GF(p^m) element as exactly m base-field scalars.
+            if (scalars.length !== safeDefaults.m)
+                throw new Error(`expected array of ${safeDefaults.m} bigints`);
             for (const i of scalars)
@@ -355,3 +396,6 @@ if (typeof i !== 'bigint')
             const N = Point.Fn.ORDER;
-            const opts = Object.assign({}, safeDefaults, { p: N, m: 1, DST: _DST_scalar }, options);
+            const opts = Object.assign({}, safeDefaults, { DST: _DST_scalar }, dstOverride(options), {
+                p: N,
+                m: 1,
+            });
             return hash_to_field(msg, 1, opts)[0][0];
@@ -361,2 +405,180 @@ },
 }
-//# sourceMappingURL=hash-to-curve.js.map
+/**
+ * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.
+ * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.
+ * b = True and y = sqrt(u / v) if (u / v) is square in F, and
+ * b = False and y = sqrt(Z * (u / v)) otherwise.
+ * RFC 9380 expects callers to provide `v != 0`; this helper does not enforce it.
+ * @param Fp - Field implementation.
+ * @param Z - Simplified SWU map parameter.
+ * @returns Square-root ratio helper.
+ * @example
+ * Build the square-root ratio helper used by SWU map implementations.
+ *
+ * ```ts
+ * import { SWUFpSqrtRatio } from '@noble/curves/abstract/hash-to-curve.js';
+ * import { Field } from '@noble/curves/abstract/modular.js';
+ * const Fp = Field(17n);
+ * const sqrtRatio = SWUFpSqrtRatio(Fp, 3n);
+ * const out = sqrtRatio(4n, 1n);
+ * ```
+ */
+export function SWUFpSqrtRatio(Fp, Z) {
+    // Fail with the usual field-shape error before touching pow/cmov on malformed field shims.
+    const F = validateField(Fp);
+    // Generic implementation
+    const q = F.ORDER;
+    let l = _0n;
+    for (let o = q - _1n; o % _2n === _0n; o /= _2n)
+        l += _1n;
+    const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.
+    // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.
+    // 2n ** c1 == 2n << (c1-1)
+    const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);
+    const _2n_pow_c1 = _2n_pow_c1_1 * _2n;
+    const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic
+    const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic
+    const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic
+    const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic
+    const c6 = F.pow(Z, c2); // 6. c6 = Z^c2
+    const c7 = F.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)
+    // RFC 9380 Appendix F.2.1.1 defines sqrt_ratio(u, v) only for v != 0.
+    // We keep v=0 on the regular result path with isValid=false instead of
+    // throwing so the helper stays closer to the RFC's fixed control flow.
+    let sqrtRatio = (u, v) => {
+        let tv1 = c6; // 1. tv1 = c6
+        let tv2 = F.pow(v, c4); // 2. tv2 = v^c4
+        let tv3 = F.sqr(tv2); // 3. tv3 = tv2^2
+        tv3 = F.mul(tv3, v); // 4. tv3 = tv3 * v
+        let tv5 = F.mul(u, tv3); // 5. tv5 = u * tv3
+        tv5 = F.pow(tv5, c3); // 6. tv5 = tv5^c3
+        tv5 = F.mul(tv5, tv2); // 7. tv5 = tv5 * tv2
+        tv2 = F.mul(tv5, v); // 8. tv2 = tv5 * v
+        tv3 = F.mul(tv5, u); // 9. tv3 = tv5 * u
+        let tv4 = F.mul(tv3, tv2); // 10. tv4 = tv3 * tv2
+        tv5 = F.pow(tv4, c5); // 11. tv5 = tv4^c5
+        let isQR = F.eql(tv5, F.ONE); // 12. isQR = tv5 == 1
+        tv2 = F.mul(tv3, c7); // 13. tv2 = tv3 * c7
+        tv5 = F.mul(tv4, tv1); // 14. tv5 = tv4 * tv1
+        tv3 = F.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)
+        tv4 = F.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)
+        // 17. for i in (c1, c1 - 1, ..., 2):
+        for (let i = c1; i > _1n; i--) {
+            let tv5 = i - _2n; // 18.    tv5 = i - 2
+            tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5
+            let tvv5 = F.pow(tv4, tv5); // 20.    tv5 = tv4^tv5
+            const e1 = F.eql(tvv5, F.ONE); // 21.    e1 = tv5 == 1
+            tv2 = F.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1
+            tv1 = F.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1
+            tvv5 = F.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1
+            tv3 = F.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)
+            tv4 = F.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)
+        }
+        // RFC 9380 Appendix F.2.1.1 defines sqrt_ratio(u, v) for v != 0.
+        // When u = 0 and v != 0, u / v = 0 is square and the computed root is
+        // still 0, so widen only the final flag and keep the full control flow.
+        return { isValid: !F.is0(v) && (isQR || F.is0(u)), value: tv3 };
+    };
+    if (F.ORDER % _4n === _3n) {
+        // sqrt_ratio_3mod4(u, v)
+        const c1 = (F.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic
+        const c2 = F.sqrt(F.neg(Z)); // 2. c2 = sqrt(-Z)
+        sqrtRatio = (u, v) => {
+            let tv1 = F.sqr(v); // 1. tv1 = v^2
+            const tv2 = F.mul(u, v); // 2. tv2 = u * v
+            tv1 = F.mul(tv1, tv2); // 3. tv1 = tv1 * tv2
+            let y1 = F.pow(tv1, c1); // 4. y1 = tv1^c1
+            y1 = F.mul(y1, tv2); // 5. y1 = y1 * tv2
+            const y2 = F.mul(y1, c2); // 6. y2 = y1 * c2
+            const tv3 = F.mul(F.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v
+            const isQR = F.eql(tv3, u); // 9. isQR = tv3 == u
+            let y = F.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)
+            return { isValid: !F.is0(v) && isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2
+        };
+    }
+    // No curves uses that
+    // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8
+    return sqrtRatio;
+}
+/**
+ * Simplified Shallue-van de Woestijne-Ulas Method
+ * See {@link https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2 | RFC 9380 section 6.6.2}.
+ * @param Fp - Field implementation.
+ * @param opts - SWU parameters:
+ *   - `A`: Curve parameter `A`.
+ *   - `B`: Curve parameter `B`.
+ *   - `Z`: Simplified SWU map parameter.
+ * @returns Deterministic map-to-curve function.
+ * @throws If the SWU parameters are invalid or the field lacks the required helpers. {@link Error}
+ * @example
+ * Map one field element to a Weierstrass curve point with the SWU recipe.
+ *
+ * ```ts
+ * import { mapToCurveSimpleSWU } from '@noble/curves/abstract/hash-to-curve.js';
+ * import { Field } from '@noble/curves/abstract/modular.js';
+ * const Fp = Field(17n);
+ * const map = mapToCurveSimpleSWU(Fp, { A: 1n, B: 2n, Z: 3n });
+ * const point = map(5n);
+ * ```
+ */
+export function mapToCurveSimpleSWU(Fp, opts) {
+    const F = validateField(Fp);
+    validateObject(opts, {}, {}, 'opts');
+    const { A, B, Z } = opts;
+    if (!F.isValidNot0(A) || !F.isValidNot0(B) || !F.isValid(Z))
+        throw new Error('mapToCurveSimpleSWU: invalid opts');
+    // RFC 9380 §6.6.2 and Appendix H.2 require:
+    // 1. Z is non-square in F
+    // 2. Z != -1 in F
+    // 3. g(x) - Z is irreducible over F
+    // 4. g(B / (Z * A)) is square in F
+    // We can enforce 1, 2, and 4 with the current field API.
+    // Criterion 3 is not checked here because generic `IField<T>` does not expose
+    // polynomial-ring / irreducibility operations, and this helper is used for
+    // both prime and extension fields.
+    if (F.eql(Z, F.neg(F.ONE)) || FpIsSquare(F, Z))
+        throw new Error('mapToCurveSimpleSWU: invalid opts');
+    // RFC 9380 Appendix H.2 criterion 4: g(B / (Z * A)) is square in F.
+    // x = B / (Z * A)
+    const x = F.mul(B, F.inv(F.mul(Z, A)));
+    // g(x) = x^3 + A*x + B
+    const gx = F.add(F.add(F.mul(F.sqr(x), x), F.mul(A, x)), B);
+    if (!FpIsSquare(F, gx))
+        throw new Error('mapToCurveSimpleSWU: invalid opts');
+    const sqrtRatio = SWUFpSqrtRatio(F, Z);
+    if (!F.isOdd)
+        throw new Error('Field does not have .isOdd()');
+    // Input: u, an element of F.
+    // Output: (x, y), a point on E.
+    return (u) => {
+        // prettier-ignore
+        let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
+        tv1 = F.sqr(u); // 1.  tv1 = u^2
+        tv1 = F.mul(tv1, Z); // 2.  tv1 = Z * tv1
+        tv2 = F.sqr(tv1); // 3.  tv2 = tv1^2
+        tv2 = F.add(tv2, tv1); // 4.  tv2 = tv2 + tv1
+        tv3 = F.add(tv2, F.ONE); // 5.  tv3 = tv2 + 1
+        tv3 = F.mul(tv3, B); // 6.  tv3 = B * tv3
+        tv4 = F.cmov(Z, F.neg(tv2), !F.eql(tv2, F.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)
+        tv4 = F.mul(tv4, A); // 8.  tv4 = A * tv4
+        tv2 = F.sqr(tv3); // 9.  tv2 = tv3^2
+        tv6 = F.sqr(tv4); // 10. tv6 = tv4^2
+        tv5 = F.mul(tv6, A); // 11. tv5 = A * tv6
+        tv2 = F.add(tv2, tv5); // 12. tv2 = tv2 + tv5
+        tv2 = F.mul(tv2, tv3); // 13. tv2 = tv2 * tv3
+        tv6 = F.mul(tv6, tv4); // 14. tv6 = tv6 * tv4
+        tv5 = F.mul(tv6, B); // 15. tv5 = B * tv6
+        tv2 = F.add(tv2, tv5); // 16. tv2 = tv2 + tv5
+        x = F.mul(tv1, tv3); // 17.   x = tv1 * tv3
+        const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)
+        y = F.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1
+        y = F.mul(y, value); // 20.   y = y * y1
+        x = F.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)
+        y = F.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)
+        const e1 = F.isOdd(u) === F.isOdd(y); // 23.  e1 = sgn0(u) == sgn0(y)
+        y = F.cmov(F.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)
+        const tv4_inv = FpInvertBatch(F, [tv4], true)[0];
+        x = F.mul(x, tv4_inv); // 25.   x = x / tv4
+        return { x, y };
+    };
+}

abstract/modular.d.ts

@@ -61,3 +61,3 @@ /**
  * @param number - Value to invert.
- * @param modulo - Positive modulus.
+ * @param modulo - Modulus greater than 1.
  * @returns Multiplicative inverse.
@@ -74,2 +74,28 @@ * @throws If the modulus is invalid or the inverse does not exist. {@link Error}
 /**
+ * Inverses number over modulo using Fermat's little theorem: `a^(p-2) ≡ a⁻¹ (mod p)`.
+ *
+ * Unlike {@link invert} (extended Euclidean), the exponent `p-2` is a public constant, so the
+ * underlying square-and-multiply has the same control flow for every secret `a`: there is no
+ * data-dependent branching or loop count that could leak `a` through timing (e.g. Minerva-style
+ * ECDSA nonce-inversion attacks). This is only "algorithmically" constant-time — JS bigint
+ * multiplication/reduction is still value-dependent — and it is roughly 4x slower than
+ * {@link invert}.
+ *
+ * REQUIRES a prime modulus; Fermat's theorem does not hold otherwise. The result is verified to be
+ * a real inverse, so a non-prime modulus (or a non-invertible input) fails closed with an error
+ * instead of returning a wrong value.
+ * @param a - Value to invert.
+ * @param prime - Prime modulus.
+ * @returns Multiplicative inverse in `[1, prime)`.
+ * @throws If the modulus is below 2, the input reduces to zero, or the inverse does not exist.
+ *   {@link Error}
+ * @example
+ * Compute one modular inverse without secret-dependent branching.
+ *
+ * ```ts
+ * invertCt(3n, 11n); // 4n, since 3 * 4 = 12 ≡ 1 (mod 11)
+ * ```
+ */
+export declare function invertCt(a: bigint, prime: bigint): bigint;
+/**
  * Tonelli-Shanks square root search algorithm.
@@ -339,7 +365,11 @@ * This implementation is variable-time: it searches data-dependently for the first non-residue `Z`
  * Efficiently invert an array of Field elements.
- * Exception-free. Zero-valued field elements stay `undefined` unless `passZero` is enabled.
+ * Zero-valued inputs are not inverted: by default their slot stays `undefined` (hence the
+ * `(T | undefined)[]` return type), or becomes `0` when `passZero` is enabled. Because of that the
+ * batch never calls `inv` on a zero, so over a prime field it is exception-free. The single
+ * `Fp.inv` of the accumulated product can still throw, but only for a non-invertible product, which
+ * a prime `ORDER` cannot produce (it requires a composite / non-field `ORDER`).
  * @param Fp - Field implementation.
  * @param nums - Values to invert.
  * @param passZero - map 0 to 0 (instead of undefined)
- * @returns Inverted values.
+ * @returns Inverted values; entries for zero inputs are `undefined` unless `passZero` is set.
  * @example
@@ -354,3 +384,4 @@ * Invert several field elements with one shared inversion.
  */
-export declare function FpInvertBatch<T>(Fp: TArg<IField<T>>, nums: T[], passZero?: boolean): T[];
+export declare function FpInvertBatch<T>(Fp: TArg<IField<T>>, nums: T[], passZero: true): T[];
+export declare function FpInvertBatch<T>(Fp: TArg<IField<T>>, nums: T[], passZero?: boolean): (T | undefined)[];
 /**
@@ -383,3 +414,3 @@ * @param Fp - Field implementation.
  * @returns Legendre symbol.
- * @throws If the field returns an invalid Legendre symbol value. {@link Error}
+ * @throws If the powered value does not match a valid Legendre symbol. {@link Error}
  * @example
@@ -556,2 +587,1 @@ * Compute the Legendre symbol of one field element.
 export {};
-//# sourceMappingURL=modular.d.ts.map

abstract/modular.js

@@ -8,3 +8,3 @@ /**
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { abool, abytes, anumber, asafenumber, bitLen, bytesToNumberBE, bytesToNumberLE, numberToBytesBE, numberToBytesLE, validateObject, } from "../utils.js";
+import { aarray, abool, abytes, afunction, anumber, aobject, asafenumber, bitLen, bytesToNumberBE, bytesToNumberLE, numberToBytesBE, numberToBytesLE, } from "../utils.js";
 // Numbers aren't used in x25519 / x448 builds
@@ -17,3 +17,6 @@ // prettier-ignore
 const _7n = /* @__PURE__ */ BigInt(7), _8n = /* @__PURE__ */ BigInt(8), _9n = /* @__PURE__ */ BigInt(9);
-const _16n = /* @__PURE__ */ BigInt(16);
+const _15n = /* @__PURE__ */ BigInt(15), _16n = /* @__PURE__ */ BigInt(16);
+// 2^64: exponents below this use plain square-and-multiply in pow()/FpPow(); the windowed path's
+// table build (14 multiplications) only pays off for longer exponents (break-even ~50 bits).
+const POW_WINDOWED_MIN = /* @__PURE__ */ BigInt('0x10000000000000000');
 /**
@@ -55,3 +58,53 @@ * @param a - Dividend value.
 export function pow(num, power, modulo) {
-    return FpPow(Field(modulo), num, power);
+    if (modulo <= _1n)
+        throw new Error('pow: expected modulus > 1, got ' + modulo);
+    // Non-bigint exponents coerce every comparison below to false and would silently return 1.
+    if (typeof power !== 'bigint')
+        throw new TypeError('invalid exponent: expected bigint, got ' + typeof power);
+    if (power < _0n)
+        throw new Error('invalid exponent, negatives unsupported');
+    if (power === _0n)
+        return _1n;
+    if (power === _1n)
+        return num;
+    let d = num % modulo;
+    if (d < _0n)
+        d += modulo;
+    // Control flow in both branches below depends only on the exponent, never on `num` — invertCt()
+    // relies on that for its (public-exponent) secret-independence guarantee.
+    if (power < POW_WINDOWED_MIN) {
+        // Square-and-multiply: cheaper than the windowed path for short exponents.
+        let p = _1n;
+        while (power > _0n) {
+            if (power & _1n)
+                p = (p * d) % modulo;
+            d = (d * d) % modulo;
+            power >>= _1n;
+        }
+        return p;
+    }
+    // Fixed 4-bit windows, MSB-first: a 14-multiplication table drops per-window cost to <1
+    // multiplication (vs ~2 per window for square-and-multiply), ~25-30% faster for the dense
+    // 256-bit exponents of sqrt / Legendre / invertCt.
+    const digits = [];
+    while (power > _0n) {
+        digits.push(Number(power & _15n));
+        power >>= _4n;
+    }
+    const table = new Array(16);
+    table[0] = _1n;
+    table[1] = d;
+    for (let i = 2; i < 16; i++)
+        table[i] = (table[i - 1] * d) % modulo;
+    let p = table[digits[digits.length - 1]]; // top digit is nonzero: the loop above stops on 0
+    for (let w = digits.length - 2; w >= 0; w--) {
+        p = (p * p) % modulo;
+        p = (p * p) % modulo;
+        p = (p * p) % modulo;
+        p = (p * p) % modulo;
+        const digit = digits[w];
+        if (digit !== 0)
+            p = (p * table[digit]) % modulo;
+    }
+    return p;
 }
@@ -75,2 +128,4 @@ /**
 export function pow2(x, power, modulo) {
+    if (modulo <= _1n)
+        throw new Error('pow2: expected modulus > 1, got ' + modulo);
     if (power < _0n)
@@ -89,3 +144,3 @@ throw new Error('pow2: expected non-negative exponent, got ' + power);
  * @param number - Value to invert.
- * @param modulo - Positive modulus.
+ * @param modulo - Modulus greater than 1.
  * @returns Multiplicative inverse.
@@ -103,9 +158,14 @@ * @throws If the modulus is invalid or the inverse does not exist. {@link Error}
         throw new Error('invert: expected non-zero number');
-    if (modulo <= _0n)
-        throw new Error('invert: expected positive modulus, got ' + modulo);
-    // Fermat's little theorem "CT-like" version inv(n) = n^(m-2) mod m is 30x slower.
+    // modulo = 1 is the zero ring: gcd(x, 1) = 1 makes the loop below "succeed" and return the
+    // useless inverse 0. Reject it like pow() and invertCt() do.
+    if (modulo <= _1n)
+        throw new Error('invert: expected modulus > 1, got ' + modulo);
+    // This is variable-time: the loop count depends on `number`. For a secret-independent
+    // (Fermat) alternative over a prime modulus, see {@link invertCt} (~4x slower).
     let a = mod(number, modulo);
     let b = modulo;
+    // Only the Bézout coefficient of `number` (x/u chain) is tracked; the coefficient of `modulo`
+    // never affects the output, so it is not computed.
     // prettier-ignore
-    let x = _0n, y = _1n, u = _1n, v = _0n;
+    let x = _0n, u = _1n;
     while (a !== _0n) {
@@ -115,5 +175,4 @@ const q = b / a;
         const m = x - u * q;
-        const n = y - v * q;
         // prettier-ignore
-        b = a, a = r, x = u, y = v, u = m, v = n;
+        b = a, a = r, x = u, u = m;
     }
@@ -125,2 +184,40 @@ const gcd = b;
 }
+/**
+ * Inverses number over modulo using Fermat's little theorem: `a^(p-2) ≡ a⁻¹ (mod p)`.
+ *
+ * Unlike {@link invert} (extended Euclidean), the exponent `p-2` is a public constant, so the
+ * underlying square-and-multiply has the same control flow for every secret `a`: there is no
+ * data-dependent branching or loop count that could leak `a` through timing (e.g. Minerva-style
+ * ECDSA nonce-inversion attacks). This is only "algorithmically" constant-time — JS bigint
+ * multiplication/reduction is still value-dependent — and it is roughly 4x slower than
+ * {@link invert}.
+ *
+ * REQUIRES a prime modulus; Fermat's theorem does not hold otherwise. The result is verified to be
+ * a real inverse, so a non-prime modulus (or a non-invertible input) fails closed with an error
+ * instead of returning a wrong value.
+ * @param a - Value to invert.
+ * @param prime - Prime modulus.
+ * @returns Multiplicative inverse in `[1, prime)`.
+ * @throws If the modulus is below 2, the input reduces to zero, or the inverse does not exist.
+ *   {@link Error}
+ * @example
+ * Compute one modular inverse without secret-dependent branching.
+ *
+ * ```ts
+ * invertCt(3n, 11n); // 4n, since 3 * 4 = 12 ≡ 1 (mod 11)
+ * ```
+ */
+export function invertCt(a, prime) {
+    if (prime <= _1n)
+        throw new Error('invertCt: expected prime modulus > 1, got ' + prime);
+    const an = mod(a, prime);
+    if (an === _0n)
+        throw new Error('invertCt: expected non-zero number');
+    // Exponent (prime - 2) is public, so FpPow's square-and-multiply is secret-independent.
+    const inverse = pow(an, prime - _2n, prime);
+    // O(1) safety net: verifies the inverse and rejects composite moduli where a^(p-2) is not one.
+    if (mod(an * inverse, prime) !== _1n)
+        throw new Error('invertCt: does not exist');
+    return inverse;
+}
 function assertIsSquare(Fp, root, n) {
@@ -131,2 +228,11 @@ const F = Fp;
 }
+// The Legendre symbol and every sqrt variant here are only defined over an odd (prime) modulus.
+// An even ORDER makes their integer divisions — (p-1)/2, (p+1)/4, (p-5)/8, (p+7)/16 — truncate and
+// silently return a wrong result, so reject it explicitly at the entry points instead. This is a
+// cheap necessary-condition check, not a primality test (composite odd moduli are caught later by
+// the Legendre-result / assertIsSquare checks).
+function aoddModulus(order, fnName) {
+    if ((order & _1n) === _0n)
+        throw new Error(fnName + ': expected odd modulus, got ' + order);
+}
 // Not all roots are possible! Example which will throw:
@@ -204,2 +310,3 @@ // const NUM =
         throw new Error('sqrt is not defined for small field');
+    aoddModulus(P, 'tonelliShanks');
     // Factor P - 1 = Q * 2^S, where Q is odd
@@ -243,4 +350,6 @@ let Q = P - _1n;
         while (!F.eql(t, F.ONE)) {
+            // Unreachable over a genuine field (no zero divisors; n=0 already returned above). A zero t
+            // means composite ORDER, where a fabricated root would be wrong: fail closed instead.
             if (F.is0(t))
-                return F.ZERO; // if t=0 return R=0
+                throw new Error('Cannot find square root: probably non-prime P');
             let i = 1;
@@ -292,2 +401,3 @@ // Find the smallest i >= 1 such that t^(2^i) ≡ 1 (mod P)
 export function FpSqrt(P) {
+    aoddModulus(P, 'Fp.sqrt');
     // P ≡ 3 (mod 4) => √n = n^((P+1)/4)
@@ -342,16 +452,11 @@ if (P % _4n === _3n)
 export function validateField(field) {
-    const initial = {
-        ORDER: 'bigint',
-        BYTES: 'number',
-        BITS: 'number',
-    };
-    const opts = FIELD_FIELDS.reduce((map, val) => {
-        map[val] = 'function';
-        return map;
-    }, initial);
-    validateObject(field, opts);
+    aobject(field, 'field');
+    if (typeof field.ORDER !== 'bigint')
+        throw new TypeError('param "ORDER" is invalid: expected bigint, got ' + typeof field.ORDER);
     // Runtime field implementations must expose real integer byte/bit sizes; fractional / NaN /
-    // infinite metadata leaks through validateObject(type='number') but breaks encoders and caches.
+    // infinite metadata breaks encoders and caches.
     asafenumber(field.BYTES, 'BYTES');
     asafenumber(field.BITS, 'BITS');
+    for (const name of FIELD_FIELDS)
+        afunction(field[name], 'field.' + name);
     // Runtime field implementations must expose positive byte/bit sizes; zero leaks through the
@@ -384,3 +489,8 @@ // numeric shape checks above but still breaks encoding helpers and cached-length assumptions.
 export function FpPow(Fp, num, power) {
+    validateField(Fp);
     const F = Fp;
+    // Non-bigint exponents (e.g. an accidental field element) coerce every comparison below to
+    // false and would silently return ONE.
+    if (typeof power !== 'bigint')
+        throw new TypeError('invalid exponent: expected bigint, got ' + typeof power);
     if (power < _0n)
@@ -392,29 +502,40 @@ throw new Error('invalid exponent, negatives unsupported');
         return num;
-    let p = F.ONE;
-    let d = num;
+    if (power < POW_WINDOWED_MIN) {
+        // Square-and-multiply: cheaper than the windowed path for short exponents (e.g. poseidon
+        // sbox x^5), which would waste the 14-multiplication table build.
+        let p = F.ONE;
+        let d = num;
+        while (power > _0n) {
+            if (power & _1n)
+                p = F.mul(p, d);
+            d = F.sqr(d);
+            power >>= _1n;
+        }
+        return p;
+    }
+    // Fixed 4-bit windows, MSB-first — same shape as pow() above, over generic field ops.
+    // Speeds up dense long exponents (extension-field sqrt / Legendre, e.g. Fp2 decompression).
+    const digits = [];
     while (power > _0n) {
-        if (power & _1n)
-            p = F.mul(p, d);
-        d = F.sqr(d);
-        power >>= _1n;
+        digits.push(Number(power & _15n));
+        power >>= _4n;
     }
+    const table = new Array(16);
+    table[0] = F.ONE;
+    table[1] = num;
+    for (let i = 2; i < 16; i++)
+        table[i] = F.mul(table[i - 1], num);
+    let p = table[digits[digits.length - 1]]; // top digit is nonzero: the loop above stops on 0
+    for (let w = digits.length - 2; w >= 0; w--) {
+        p = F.sqr(F.sqr(F.sqr(F.sqr(p))));
+        const digit = digits[w];
+        if (digit !== 0)
+            p = F.mul(p, table[digit]);
+    }
     return p;
 }
-/**
- * Efficiently invert an array of Field elements.
- * Exception-free. Zero-valued field elements stay `undefined` unless `passZero` is enabled.
- * @param Fp - Field implementation.
- * @param nums - Values to invert.
- * @param passZero - map 0 to 0 (instead of undefined)
- * @returns Inverted values.
- * @example
- * Invert several field elements with one shared inversion.
- *
- * ```ts
- * import { Field, FpInvertBatch } from '@noble/curves/abstract/modular.js';
- * const Fp = Field(17n);
- * const inv = FpInvertBatch(Fp, [1n, 2n, 4n]);
- * ```
- */
 export function FpInvertBatch(Fp, nums, passZero = false) {
+    validateField(Fp);
+    aarray(nums, 'nums');
+    abool(passZero, 'passZero');
     const F = Fp;
@@ -435,2 +556,3 @@ const inverted = new Array(nums.length).fill(passZero ? F.ZERO : undefined);
             return acc;
+        // Non-zero `num` means the forward pass already stored a defined prefix product at index i.
         inverted[i] = F.mul(acc, inverted[i]);
@@ -457,2 +579,3 @@ return F.mul(acc, num);
 export function FpDiv(Fp, lhs, rhs) {
+    validateField(Fp);
     const F = Fp;
@@ -472,3 +595,3 @@ return F.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, F.ORDER) : F.inv(rhs));
  * @returns Legendre symbol.
- * @throws If the field returns an invalid Legendre symbol value. {@link Error}
+ * @throws If the powered value does not match a valid Legendre symbol. {@link Error}
  * @example
@@ -484,3 +607,5 @@ * Compute the Legendre symbol of one field element.
 export function FpLegendre(Fp, n) {
+    validateField(Fp);
     const F = Fp;
+    aoddModulus(F.ORDER, 'FpLegendre');
     // We can use 3rd argument as optional cache of this value
@@ -542,3 +667,3 @@ // but seems unneeded for now. The operation is very fast.
     if (nBitLength !== undefined && nBitLength < bits)
-        throw new Error(`invalid n length: expected bit length (${bits}) >= n.length (${nBitLength})`);
+        throw new Error(`invalid n length: expected nBitLength (${nBitLength}) >= bitLen(n) (${bits})`);
     const _nBitLength = nBitLength !== undefined ? nBitLength : bits;
@@ -627,3 +752,3 @@ const nByteLength = Math.ceil(_nBitLength / 8);
     pow(num, power) {
-        return FpPow(this, num, power);
+        return pow(num, power, this.ORDER);
     }
@@ -691,3 +816,6 @@ div(lhs, rhs) {
     invertBatch(lst) {
-        return FpInvertBatch(this, lst);
+        // `passZero` keeps the `bigint[]` contract honest: zero inputs map to `0` instead of leaking
+        // `undefined` into a `bigint[]`. Callers that must distinguish non-invertible inputs should use
+        // `FpInvertBatch` directly, whose default omits `passZero` and returns `(bigint | undefined)[]`.
+        return FpInvertBatch(this, lst, true);
     }
@@ -703,5 +831,2 @@ // We can't move this out because Fp6, Fp12 implement it
 }
-// Freeze the shared method surface too; otherwise callers can still poison every Field instance by
-// monkey-patching `_Field.prototype` even if each instance is frozen.
-Object.freeze(_Field.prototype);
 /**
@@ -734,17 +859,9 @@ * Creates a finite field. Major performance optimizations:
 export function Field(ORDER, opts = {}) {
+    // Freeze the shared method surface before any instance is reachable; otherwise callers can
+    // poison every Field instance by monkey-patching `_Field.prototype` even if each instance is
+    // frozen. Freezing here instead of module scope keeps `_Field` tree-shakeable for importers
+    // that never construct a field; the call is idempotent and cheap.
+    Object.freeze(_Field.prototype);
     return new _Field(ORDER, opts);
 }
-// Generic random scalar, we can do same for other fields if via Fp2.mul(Fp2.ONE, Fp2.random)?
-// This allows unsafe methods like ignore bias or zero. These unsafe, but often used in different protocols (if deterministic RNG).
-// which mean we cannot force this via opts.
-// Not sure what to do with randomBytes, we can accept it inside opts if wanted.
-// Probably need to export getMinHashLength somewhere?
-// random(bytes?: Uint8Array, unsafeAllowZero = false, unsafeAllowBias = false) {
-//   const LEN = !unsafeAllowBias ? getMinHashLength(ORDER) : BYTES;
-//   if (bytes === undefined) bytes = randomBytes(LEN); // _opts.randomBytes?
-//   const num = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
-//   // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0
-//   const reduced = unsafeAllowZero ? mod(num, ORDER) : mod(num, ORDER - _1n) + _1n;
-//   return reduced;
-// },
 /**
@@ -766,2 +883,3 @@ * @param Fp - Field implementation.
 export function FpSqrtOdd(Fp, elm) {
+    validateField(Fp);
     const F = Fp;
@@ -788,2 +906,3 @@ if (!F.isOdd)
 export function FpSqrtEven(Fp, elm) {
+    validateField(Fp);
     const F = Fp;
@@ -872,6 +991,9 @@ if (!F.isOdd)
     const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);
-    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0
+    // Map into the non-zero scalar range [1, fieldOrder-1]: reduce mod (fieldOrder-1) to land in
+    // [0, fieldOrder-2], then add 1. This shifts the range off zero; it is NOT equal to
+    // `mod(num, fieldOrder)` (which spans [0, fieldOrder-1] and can be 0). A residual modulo bias
+    // remains but is negligible (~2^-(nBits/2), e.g. ~2^-128 for a 256-bit order) because `key` is
+    // required to be at least `getMinHashLength(fieldOrder)` (~1.5x field size) bytes of input.
     const reduced = mod(num, fieldOrder - _1n) + _1n;
     return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
 }
-//# sourceMappingURL=modular.js.map

abstract/montgomery.d.ts

@@ -30,5 +30,16 @@ /**
      * Optional randomness source for `keygen()` and `utils.randomSecretKey()`.
-     * Receives the requested byte length and returns fresh random bytes.
+     * @param bytesLength - Requested byte length.
+     * @returns Random bytes.
      */
     randomBytes?: (bytesLength?: number) => TRet<Uint8Array>;
+    /**
+     * Optional fast fixed-base multiplication, replacing the Montgomery ladder in
+     * `scalarMultBase()` / `getPublicKey()` only. Standard implementation computes `[k]B` on the
+     * equivalent Edwards curve with cached base-point tables and maps the result back to a
+     * Montgomery `u` coordinate (libsodium does the same for X25519); ~3x faster than the ladder.
+     * @param k - Decoded, clamped scalar; guaranteed to be in the RFC 7748 clamped range.
+     * @returns `u([k]G)` as an integer. Must return `0` when `[k]G` is the point at infinity
+     *   (`k ≡ 0 mod n`) so the caller can reject it exactly like the ladder path does.
+     */
+    scalarMultBase?: (k: bigint) => bigint;
 };
@@ -84,2 +95,55 @@ /** Public X25519/X448 ECDH API built on a Montgomery ladder. */
 /**
+ * Selector for cswap(): `P` to keep, `P + 1` to swap, chosen by the low bit of `swap`.
+ * Higher bits are ignored, and `swap` is passed in whole rather than as a {0n, 1n} bit on
+ * purpose: `P + (swap & _1n)` would short-circuit the addition whenever the bit is clear, which
+ * is the very leak this construction avoids, one round-trip further down. Subtracting `swap`
+ * with its low bit cleared keeps every operand full-width instead.
+ * @param P - Field modulus.
+ * @param swap - Value whose low bit selects; ignored above that bit.
+ * @returns `P` when the low bit is clear, `P + 1` when it is set.
+ */
+declare function cmask(P: bigint, swap: bigint): bigint;
+/**
+ * Swap two field elements when `mask` is `P + 1`, keep them when it is `P`:
+ *
+ *   d    = 6P + x_3 - x_2
+ *   x_2' = d * mask + x_2   (mod P)      x_3' = (x_2 + x_3) - x_2'
+ *
+ * The extra `6P * mask` vanishes modulo P, so `mask === P` leaves x_2 and `mask === P + 1`
+ * leaves x_3. Without the offset, the reduction dividend changes sign with input order and crosses
+ * BigInt limb boundaries; those classes measured differently on the tested Node/V8 build. For
+ * canonical inputs, the deliberately left-associative `offset + x_3 - x_2` is between 5P and 7P,
+ * keeping the dividend positive and in one word-count band for both RFC fields and masks. Six is
+ * the smallest coefficient `c` for which the shared offset `cP` has that property.
+ *
+ * This reduced the tested sign/size timing ratios, but JavaScript BigInt has no constant-time
+ * contract and the contents of the multiply and remainder still vary. Valid ladder states can
+ * contain genuine zero coordinates; this construction does not mask those value-shape effects.
+ * Computing `x_3'` independently as `((6P + x_2 - x_3) * mask + x_3) % P` is more symmetric.
+ * On the tested Node/V8 build, it reduced the timing difference between keeping `(0, v)` and
+ * swapping `(v, 0)`—both return `(0, v)`—from about 10%/13% for X25519/X448 to about 3%.
+ * Successful calls cannot reach that zero-in-the-first-output case. For the case they can reach,
+ * swapping `(0, v)` and keeping `(v, 0)` both return `(v, 0)`; the difference instead grew from
+ * about 0.7%/1.1% to 2.7%/2.8%. The extra multiply/remainder also made public
+ * `getSharedSecret()` about 16% slower. The retained one-remainder form measured about 2.5%
+ * slower than the prior helper for public X25519 `getSharedSecret()` in the same environment.
+ * x_3' falls out of the sum, which a swap leaves invariant: no second multiply or reduction is
+ * needed. Bind `6P` once per field so production and the timing regression exercise the same
+ * configured helper without paying for the multiplication in every ladder round.
+ *
+ * The returned function is called twice per ladder round, so it validates nothing. Both elements
+ * MUST already be reduced mod P; unreduced input silently corrupts the kept-side output.
+ * @param P - Field modulus.
+ * @returns A field-bound swap function taking mask, x_2, and x_3.
+ */
+declare function cswap(P: bigint): (mask: bigint, x_2: bigint, x_3: bigint) => {
+    x_2: bigint;
+    x_3: bigint;
+};
+/** Internal helpers, exported for tests only. Not part of the public API. */
+export declare const __TEST: {
+    cmask: typeof cmask;
+    cswap: typeof cswap;
+};
+/**
  * @param curveDef - Montgomery curve definition.
@@ -89,11 +153,36 @@ * @returns ECDH helper namespace.
  * @example
- * Perform one X25519 key exchange through the generic Montgomery helper.
+ * Build an X25519 helper from curve parameters, then derive one public key.
  *
  * ```ts
- * import { x25519 } from '@noble/curves/ed25519.js';
- * const alice = x25519.keygen();
- * const shared = x25519.getSharedSecret(alice.secretKey, alice.publicKey);
+ * import { montgomery } from '@noble/curves/abstract/montgomery.js';
+ * const P = 2n ** 255n - 19n;
+ * const mod = (num: bigint) => {
+ *   const out = num % P;
+ *   return out >= 0n ? out : out + P;
+ * };
+ * const pow = (num: bigint, power: bigint) => {
+ *   let res = 1n;
+ *   for (; power > 0n; power >>= 1n) {
+ *     if (power & 1n) res = mod(res * num);
+ *     num = mod(num * num);
+ *   }
+ *   return res;
+ * };
+ * const x25519 = montgomery({
+ *   P,
+ *   type: 'x25519',
+ *   adjustScalarBytes(bytes: Uint8Array) {
+ *     bytes[0] &= 248;
+ *     bytes[31] &= 127;
+ *     bytes[31] |= 64;
+ *     return bytes;
+ *   },
+ *   powPminus2(x) {
+ *     return pow(x, P - 2n);
+ *   },
+ * });
+ * const publicKey = x25519.getPublicKey(new Uint8Array(32).fill(1));
  * ```
  */
 export declare function montgomery(curveDef: TArg<MontgomeryOpts>): TRet<MontgomeryECDH>;
-//# sourceMappingURL=montgomery.d.ts.map
+export {};

abstract/montgomery.js

@@ -11,5 +11,76 @@ /**
 import { mod } from "./modular.js";
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _2n = BigInt(2);
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+const _2n = /* @__PURE__ */ BigInt(2);
+// cswap from RFC7748 "example code", adapted to BigInt.
+//
+// RFC: "dummy = mask(swap) AND (x_2 XOR x_3), where mask(swap) is the all-1 or all-0 word of the
+// same length as x_2 and x_3". On fixed-width machine words both cases cost the same. BigInt has
+// no fixed width, so a {0n, 1n} selector does not: V8 short-circuits `0n * v` - and, identically,
+// `0n & v`, `v + 0n`, `v - 0n` - to a no-op, while `1n * v` is a real multiply. The ladder calls
+// this with swap = k_t XOR k_(t+1), which would make total running time a linear function of how
+// often adjacent bits of the secret scalar differ: remotely measurable, and worth ~4 bits of a
+// long-term key.
+//
+// So select with a full-width mask instead, and interpolate rather than mask off a dummy.
+/**
+ * Selector for cswap(): `P` to keep, `P + 1` to swap, chosen by the low bit of `swap`.
+ * Higher bits are ignored, and `swap` is passed in whole rather than as a {0n, 1n} bit on
+ * purpose: `P + (swap & _1n)` would short-circuit the addition whenever the bit is clear, which
+ * is the very leak this construction avoids, one round-trip further down. Subtracting `swap`
+ * with its low bit cleared keeps every operand full-width instead.
+ * @param P - Field modulus.
+ * @param swap - Value whose low bit selects; ignored above that bit.
+ * @returns `P` when the low bit is clear, `P + 1` when it is set.
+ */
+function cmask(P, swap) {
+    return P + swap - ((swap >> _1n) << _1n);
+}
+/**
+ * Swap two field elements when `mask` is `P + 1`, keep them when it is `P`:
+ *
+ *   d    = 6P + x_3 - x_2
+ *   x_2' = d * mask + x_2   (mod P)      x_3' = (x_2 + x_3) - x_2'
+ *
+ * The extra `6P * mask` vanishes modulo P, so `mask === P` leaves x_2 and `mask === P + 1`
+ * leaves x_3. Without the offset, the reduction dividend changes sign with input order and crosses
+ * BigInt limb boundaries; those classes measured differently on the tested Node/V8 build. For
+ * canonical inputs, the deliberately left-associative `offset + x_3 - x_2` is between 5P and 7P,
+ * keeping the dividend positive and in one word-count band for both RFC fields and masks. Six is
+ * the smallest coefficient `c` for which the shared offset `cP` has that property.
+ *
+ * This reduced the tested sign/size timing ratios, but JavaScript BigInt has no constant-time
+ * contract and the contents of the multiply and remainder still vary. Valid ladder states can
+ * contain genuine zero coordinates; this construction does not mask those value-shape effects.
+ * Computing `x_3'` independently as `((6P + x_2 - x_3) * mask + x_3) % P` is more symmetric.
+ * On the tested Node/V8 build, it reduced the timing difference between keeping `(0, v)` and
+ * swapping `(v, 0)`—both return `(0, v)`—from about 10%/13% for X25519/X448 to about 3%.
+ * Successful calls cannot reach that zero-in-the-first-output case. For the case they can reach,
+ * swapping `(0, v)` and keeping `(v, 0)` both return `(v, 0)`; the difference instead grew from
+ * about 0.7%/1.1% to 2.7%/2.8%. The extra multiply/remainder also made public
+ * `getSharedSecret()` about 16% slower. The retained one-remainder form measured about 2.5%
+ * slower than the prior helper for public X25519 `getSharedSecret()` in the same environment.
+ * x_3' falls out of the sum, which a swap leaves invariant: no second multiply or reduction is
+ * needed. Bind `6P` once per field so production and the timing regression exercise the same
+ * configured helper without paying for the multiplication in every ladder round.
+ *
+ * The returned function is called twice per ladder round, so it validates nothing. Both elements
+ * MUST already be reduced mod P; unreduced input silently corrupts the kept-side output.
+ * @param P - Field modulus.
+ * @returns A field-bound swap function taking mask, x_2, and x_3.
+ */
+function cswap(P) {
+    const offset = BigInt(6) * P;
+    return (mask, x_2, x_3) => {
+        const sum = x_2 + x_3;
+        const d = offset + x_3 - x_2;
+        const a = (d * mask + x_2) % P;
+        return { x_2: a, x_3: sum - a };
+    };
+}
+/** Internal helpers, exported for tests only. Not part of the public API. */
+export const __TEST = /* @__PURE__ */ Object.freeze({
+    cmask,
+    cswap,
+});
 function validateOpts(curve) {
@@ -26,2 +97,3 @@ // Validate constructor config eagerly, but do not call user-provided hooks here:
         randomBytes: 'function',
+        scalarMultBase: 'function',
     });
@@ -35,8 +107,33 @@ return Object.freeze({ ...curve });
  * @example
- * Perform one X25519 key exchange through the generic Montgomery helper.
+ * Build an X25519 helper from curve parameters, then derive one public key.
  *
  * ```ts
- * import { x25519 } from '@noble/curves/ed25519.js';
- * const alice = x25519.keygen();
- * const shared = x25519.getSharedSecret(alice.secretKey, alice.publicKey);
+ * import { montgomery } from '@noble/curves/abstract/montgomery.js';
+ * const P = 2n ** 255n - 19n;
+ * const mod = (num: bigint) => {
+ *   const out = num % P;
+ *   return out >= 0n ? out : out + P;
+ * };
+ * const pow = (num: bigint, power: bigint) => {
+ *   let res = 1n;
+ *   for (; power > 0n; power >>= 1n) {
+ *     if (power & 1n) res = mod(res * num);
+ *     num = mod(num * num);
+ *   }
+ *   return res;
+ * };
+ * const x25519 = montgomery({
+ *   P,
+ *   type: 'x25519',
+ *   adjustScalarBytes(bytes: Uint8Array) {
+ *     bytes[0] &= 248;
+ *     bytes[31] &= 127;
+ *     bytes[31] |= 64;
+ *     return bytes;
+ *   },
+ *   powPminus2(x) {
+ *     return pow(x, P - 2n);
+ *   },
+ * });
+ * const publicKey = x25519.getPublicKey(new Uint8Array(32).fill(1));
  * ```
@@ -47,2 +144,3 @@ */
     const { P, type, adjustScalarBytes, powPminus2, randomBytes: rand } = CURVE;
+    const mulBaseHook = CURVE.scalarMultBase;
     const is25519 = type === 'x25519';
@@ -53,2 +151,3 @@ if (!is25519 && type !== 'x448')
     const montgomeryBits = is25519 ? 255 : 448;
+    const swap = cswap(P);
     const fieldLen = is25519 ? 32 : 56;
@@ -66,4 +165,4 @@ const Gu = is25519 ? BigInt(9) : BigInt(5);
     const maxAdded = is25519
-        ? BigInt(8) * _2n ** BigInt(251) - _1n
-        : BigInt(4) * _2n ** BigInt(445) - _1n;
+        ? BigInt(8) * (_2n ** BigInt(251) - _1n)
+        : BigInt(4) * (_2n ** BigInt(445) - _1n);
     const maxScalar = minScalar + maxAdded + _1n; // (inclusive)
@@ -90,7 +189,39 @@ const modP = (n) => mod(n, P);
     }
+    /**
+     * u coordinates whose order divides the cofactor, on the curve and on its quadratic twist -
+     * the ladder sends every one of them to zero. Same blocklist libsodium and post-CVE-2017-0379
+     * Libgcrypt carry. decodeU() reduces mod P first, so the non-canonical encodings P and P + 1
+     * collapse onto 0 and 1, and `type` admits no curve beyond these two, so both lists are total.
+     *
+     * Complete by construction: x-only doubling sends u to (u^2 - 1)^2 / 4u(u^2 + a*u + 1). Order 4
+     * therefore needs (u^2 - 1)^2 === 0, i.e. u = +-1; order 2 needs u(u^2 + a*u + 1) === 0, and
+     * a^2 - 4 is a non-residue on both curves, leaving u = 0. curve448 stops there (cofactor 4);
+     * curve25519 (cofactor 8) adds the two order-8 roots below. Cross-checked by clearing the
+     * cofactor with those same doublings over 200k random u: no sixth value exists.
+     */
+    const lowOrderU = new Set(is25519
+        ? [
+            _0n,
+            _1n,
+            P - _1n,
+            BigInt('325606250916557431795983626356110631294008115727848805560023387167927233504'),
+            BigInt('39382357235489614581723060781553021112529911719440698176882885853963445705823'),
+        ]
+        : [_0n, _1n, P - _1n]);
     function scalarMult(scalar, u) {
-        const pu = montgomeryLadder(decodeU(u), decodeScalar(scalar));
         // Some public keys are useless, of low-order. Curve author doesn't think
         // it needs to be validated, but we do it nonetheless.
         // https://cr.yp.to/ecdh.html#validate
+        //
+        // Reject them BEFORE the ladder. RFC 7748 #6.1 also permits detecting them from the
+        // all-zero output, but that first runs all 255 rounds against the long-term secret,
+        // handing an unauthenticated attacker a free timing oracle. Low-order inputs also drive
+        // the ladder into a degenerate state (x_2 + z_2 === 0) whose extra zero-operand
+        // multiplications amplify any residual key-dependent timing.
+        const pointU = decodeU(u);
+        if (lowOrderU.has(pointU))
+            throw new Error('invalid private or public key received');
+        const pu = montgomeryLadder(pointU, decodeScalar(scalar));
+        // Unreachable for RFC 7748 clamped scalars, which are cofactor multiples smaller than the
+        // group order; kept because adjustScalarBytes is caller-supplied.
         if (pu === _0n)
@@ -101,17 +232,16 @@ throw new Error('invalid private or public key received');
     // Computes public key from private. By doing scalar multiplication of base point.
+    // With a curve-provided fixed-base hook (Edwards tables), the ladder is skipped, but the
+    // contract — scalar validation, low-order rejection, encoding — stays identical.
     function scalarMultBase(scalar) {
-        return scalarMult(scalar, GuBytes);
+        if (mulBaseHook === undefined)
+            return scalarMult(scalar, GuBytes);
+        const k = decodeScalar(scalar);
+        aInRange('scalar', k, minScalar, maxScalar);
+        const pu = modP(mulBaseHook(k));
+        if (pu === _0n)
+            throw new Error('invalid private or public key received');
+        return encodeU(pu);
     }
     const getPublicKey = scalarMultBase;
     const getSharedSecret = scalarMult;
-    // cswap from RFC7748 "example code"
-    function cswap(swap, x_2, x_3) {
-        // dummy = mask(swap) AND (x_2 XOR x_3)
-        // Where mask(swap) is the all-1 or all-0 word of the same length as x_2
-        // and x_3, computed, e.g., as mask(swap) = 0 - swap.
-        const dummy = modP(swap * (x_2 - x_3));
-        x_2 = modP(x_2 - dummy); // x_2 = x_2 XOR dummy
-        x_3 = modP(x_3 + dummy); // x_3 = x_3 XOR dummy
-        return { x_2, x_3 };
-    }
     /**
@@ -132,9 +262,11 @@ * Montgomery x-only multiplication ladder for the selected X25519/X448 curve.
         let z_3 = _1n;
-        let swap = _0n;
+        // The RFC tracks `swap` across rounds to hold k_t XOR k_(t+1); the low bit of `kx >> t` is
+        // the same value, without the carried state. aInRange above pins bit (montgomeryBits - 1)
+        // of k set and everything above it clear, so `kx >> t` is never zero and its width is a
+        // function of t alone - never of a secret bit.
+        const kx = k ^ (k >> _1n);
         for (let t = BigInt(montgomeryBits - 1); t >= _0n; t--) {
-            const k_t = (k >> t) & _1n;
-            swap ^= k_t;
-            ({ x_2, x_3 } = cswap(swap, x_2, x_3));
-            ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
-            swap = k_t;
+            const mask = cmask(P, kx >> t);
+            ({ x_2, x_3 } = swap(mask, x_2, x_3));
+            ({ x_2: z_2, x_3: z_3 } = swap(mask, z_2, z_3));
             const A = x_2 + z_2;
@@ -156,4 +288,6 @@ const AA = modP(A * A);
         }
-        ({ x_2, x_3 } = cswap(swap, x_2, x_3));
-        ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
+        // trailing cswap: the RFC's `swap` holds k_0 here, which is the low bit of k
+        const mask = cmask(P, k);
+        ({ x_2, x_3 } = swap(mask, x_2, x_3));
+        ({ x_2: z_2, x_3: z_3 } = swap(mask, z_2, z_3));
         const z2 = powPminus2(z_2); // `Fp.pow(x, P - _2n)` is much slower equivalent
@@ -188,2 +322,1 @@ return modP(x_2 * z2); // Return x_2 * (z_2^(p - 2))
 }
-//# sourceMappingURL=montgomery.js.map

abstract/oprf.d.ts

@@ -298,3 +298,3 @@ /**
          */
-        blindEvaluateBatch(secretKey: TArg<ScalarBytes>, blinded: TArg<PointBytes[]>, rng: RNG): TRet<OPRFBlindEvalBatch>;
+        blindEvaluateBatch(secretKey: TArg<ScalarBytes>, blinded: TArg<PointBytes[]>, rng?: RNG): TRet<OPRFBlindEvalBatch>;
         /**
@@ -356,2 +356,1 @@ * (Client-side) A batch-aware version of `finalize` for the POPRF mode.
 export declare function createOPRF<P extends CurvePoint<any, P>>(opts: OPRFOpts<P>): TRet<OPRF>;
-//# sourceMappingURL=oprf.d.ts.map

abstract/oprf.js

@@ -54,4 +54,4 @@ /**
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { abytes, asciiToBytes, bytesToNumberBE, bytesToNumberLE, concatBytes, numberToBytesBE, randomBytes, validateObject, } from "../utils.js";
-import { pippenger, validatePointCons } from "./curve.js";
+import { abytes, asciiToBytes, bytesToNumberBE, bytesToNumberLE, concatBytes, copyBytes, numberToBytesBE, randomBytes, validateObject, } from "../utils.js";
+import { mulAddUnsafe, validatePointCons } from "./curve.js";
 import { _DST_scalar } from "./hash-to-curve.js";
@@ -98,2 +98,4 @@ import { getMinHashLength, mapHashToField } from "./modular.js";
     const randomScalar = (rng = randomBytes) => {
+        if (typeof rng !== 'function')
+            throw new TypeError('"rng" expected function, got type=' + typeof rng);
         // RFC 9497 §2.1 defines RandomScalar as nonzero; blind inversion and generated public keys
@@ -106,3 +108,6 @@ // both rely on keeping this helper in the `1..n-1` range.
     };
-    const msm = (points, scalars) => pippenger(Point, points, scalars);
+    // Every MSM input in this module is public (hash-derived transcript weights, wire-decoded
+    // points, proof scalars), so the vartime shared-doubling-chain walk is safe. It is also
+    // 1.6-2.5x faster than pippenger() for all realistic batch sizes (measured up to L=2048).
+    const msm = (points, scalars) => mulAddUnsafe(Point, points, scalars);
     const getCtx = (mode) => concatBytes(asciiToBytes('OPRFV1-'), new Uint8Array([mode]), asciiToBytes('-' + name));
@@ -179,4 +184,4 @@ const ctxOPRF = getCtx(0x00);
         const [c, s] = [proof.subarray(0, Fn.BYTES), proof.subarray(Fn.BYTES)].map((f) => Fn.fromBytes(f));
-        const t2 = Point.BASE.multiply(s).add(B.multiply(c)); // s*G + c*B
-        const t3 = M.multiply(s).add(Z.multiply(c)); // s*M + c*Z
+        const t2 = msm([Point.BASE, B], [s, c]); // s*G + c*B
+        const t3 = msm([M, Z], [s, c]); // s*M + c*Z
         const expectedC = challengeTranscript(B, M, Z, t2, t3, ctx);
@@ -279,3 +284,10 @@ if (!Fn.eql(c, expectedC))
             verifyProof(ctxVOPRF, pkS, blindedPoints, evalPoints, proof);
-            return items.map((i) => oprf.finalize(i.input, i.blind, i.evaluated));
+            // Same unblind+hash as oprf.finalize(), but reuses the evaluated points already decoded
+            // (and identity-checked) for verifyProof instead of deserializing each one again.
+            return items.map((i, j) => {
+                const input = inputBytes('input', i.input);
+                const blind = Fn.fromBytes(i.blind);
+                const unblinded = evalPoints[j].multiply(Fn.inv(blind)).toBytes();
+                return hashInput(input, unblinded);
+            });
         },
@@ -289,3 +301,3 @@ finalize(input, blind, evaluated, blinded, publicKey, proof) {
     const poprf = (info) => {
-        info = inputBytes('info', info);
+        info = copyBytes(inputBytes('info', info));
         const m = hashToScalarPrefixed(encode('Info', info), ctxPOPRF);
@@ -362,2 +374,1 @@ const T = Point.BASE.multiply(m);
 }
-//# sourceMappingURL=oprf.js.map

abstract/poseidon.d.ts

@@ -199,2 +199,1 @@ /**
 export {};
-//# sourceMappingURL=poseidon.d.ts.map

abstract/poseidon.js

@@ -10,3 +10,3 @@ /**
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { asafenumber, bitGet, validateObject } from "../utils.js";
+import { aarray, asafenumber, bitGet, validateObject } from "../utils.js";
 import { FpInvertBatch, FpPow, validateField } from "./modular.js";
@@ -41,2 +41,3 @@ // Grain LFSR (Linear-Feedback Shift Register): https://eprint.iacr.org/2009/109.pdf
 function assertValidPosOpts(opts) {
+    validateObject(opts, {}, {}, 'opts');
     const { Fp, roundsFull } = opts;
@@ -121,2 +122,3 @@ validateField(Fp);
 export function grainGenConstants(opts, skipMDS = 0) {
+    assertValidPosOpts(opts);
     const { Fp, t, roundsFull, roundsPartial } = opts;
@@ -149,3 +151,5 @@ // `skipMDS` counts how many candidate matrices to discard before taking one.
         }
-        mds.push(FpInvertBatch(Fp, row));
+        // `row` is guaranteed non-zero (the loop throws on a zero entry above), so `passZero` only
+        // pins the `bigint[]` return type; it does not change any value here.
+        mds.push(FpInvertBatch(Fp, row, true));
     }
@@ -176,10 +180,12 @@ return { roundConstants, mds };
     // MDS is TxT matrix
-    if (!Array.isArray(mds) || mds.length !== t)
+    aarray(mds, 'opts.mds');
+    if (mds.length !== t)
         throw new Error('Poseidon: invalid MDS matrix');
-    const _mds = mds.map((mdsRow) => {
-        if (!Array.isArray(mdsRow) || mdsRow.length !== t)
-            throw new Error('invalid MDS matrix row: ' + mdsRow);
-        return mdsRow.map((i) => {
+    const _mds = mds.map((mdsRow, row) => {
+        aarray(mdsRow, 'opts.mds[' + row + ']');
+        if (mdsRow.length !== t)
+            throw new Error('"opts.mds[' + row + ']" expected length ' + t + ', got ' + mdsRow.length);
+        return mdsRow.map((i, col) => {
             if (typeof i !== 'bigint')
-                throw new Error('invalid MDS matrix bigint: ' + i);
+                throw new Error('"opts.mds[' + row + '][' + col + ']" expected bigint, got type=' + typeof i);
             // Hardcoded Poseidon MDS matrices often use signed entries like `-1`;
@@ -280,9 +286,12 @@ // accept bigint representatives here and reduce them into the field.
     const poseidonRound = (values, isFull, idx) => {
-        values = values.map((i, j) => Fp.add(i, roundConstants[idx][j]));
+        const rc = roundConstants[idx];
         if (isFull)
-            values = values.map((i) => sboxFn(i));
-        else
+            values = values.map((i, j) => sboxFn(Fp.add(i, rc[j])));
+        else {
+            values = values.map((i, j) => Fp.add(i, rc[j]));
             values[partialIdx] = sboxFn(values[partialIdx]);
-        // Matrix multiplication
-        values = mds.map((i) => i.reduce((acc, i, j) => Fp.add(acc, Fp.mulN(i, values[j])), Fp.ZERO));
+        }
+        // Matrix multiplication. Row entries and values are reduced (< p), so each product is < p²
+        // and a row sum is < t⋅p²: accumulate without mod, reduce once per row instead of per cell.
+        values = mds.map((row) => Fp.create(row.reduce((acc, m, j) => Fp.addN(acc, Fp.mulN(m, values[j])), Fp.ZERO)));
         return values;
@@ -350,2 +359,9 @@ };
     constructor(Fp, rate, capacity, hash) {
+        validateField(Fp);
+        asafenumber(rate, 'rate');
+        asafenumber(capacity, 'capacity');
+        if (typeof hash !== 'function')
+            throw new TypeError('"hash" expected function, got type=' + typeof hash);
+        if (hash.roundConstants !== undefined)
+            aarray(hash.roundConstants, 'hash.roundConstants');
         const width = spongeShape(rate, capacity);
@@ -355,4 +371,5 @@ // The direct constructor accepts an arbitrary permutation hook, but callers still
         // mismatches here instead of deferring them until the first `process()` call.
-        if (width !== hash.roundConstants[0]?.length)
-            throw new Error(`invalid sponge width: expected ${hash.roundConstants[0]?.length}, got ${width}`);
+        if (width !== hash.roundConstants?.[0]?.length) {
+            throw new Error(`invalid sponge width: expected ${hash.roundConstants?.[0]?.length}, got ${width}`);
+        }
         this.Fp = Fp;
@@ -371,2 +388,4 @@ this.hash = hash;
     absorb(input) {
+        if (!Array.isArray(input))
+            throw new Error('invalid input: expected array');
         for (const i of input)
@@ -464,2 +483,3 @@ if (typeof i !== 'bigint' || !this.Fp.isValid(i))
 export function poseidonSponge(opts) {
+    validateObject(opts, {}, {}, 'opts');
     const { rate, capacity } = opts;
@@ -473,2 +493,1 @@ const t = spongeShape(rate, capacity);
 }
-//# sourceMappingURL=poseidon.js.map

abstract/tower.d.ts

@@ -113,6 +113,2 @@ /**
     fromBigTwelve: (t: BigintTwelve) => Fp12;
-    /** Multiply by a sparse `(o0, o1, 0, 0, o4, 0)` element. */
-    mul014(num: Fp12, o0: Fp2, o1: Fp2, o4: Fp2): Fp12;
-    /** Multiply by a sparse `(o0, 0, 0, o3, o4, 0)` element. */
-    mul034(num: Fp12, o0: Fp2, o3: Fp2, o4: Fp2): Fp12;
     /** Multiply by one quadratic-extension element. */
@@ -174,3 +170,4 @@ mulByFp2(lhs: Fp12, rhs: Fp2): Fp12;
      * Optional custom quadratic square-root helper.
-     * Receives one quadratic-extension element and returns one square root.
+     * @param num - Quadratic-extension element.
+     * @returns One square root.
      */
@@ -199,2 +196,3 @@ Fp2sqrt?: (num: Fp2) => Fp2;
  * ```ts
+ * import { tower12, type Fp2, type Fp12 } from '@noble/curves/abstract/tower.js';
  * const fields = tower12({
@@ -204,4 +202,4 @@ *   ORDER: 17n,
  *   FP2_NONRESIDUE: [1n, 1n],
- *   Fp2mulByB: (num) => num,
- *   Fp12finalExponentiate: (num) => num,
+ *   Fp2mulByB: (num: Fp2) => num,
+ *   Fp12finalExponentiate: (num: Fp12) => num,
  * });
@@ -218,2 +216,1 @@ * const fp12 = fields.Fp12.ONE;
 export {};
-//# sourceMappingURL=tower.d.ts.map

abstract/tower.js

@@ -14,2 +14,3 @@ /**
 import { abytes, aInRange, asafenumber, bitGet, bitLen, concatBytes, notImplemented, validateObject, } from "../utils.js";
+import { validatePointCons } from "./curve.js";
 import * as mod from "./modular.js";
@@ -22,8 +23,17 @@ // Be friendly to bad ECMAScript parsers by not using bigint literals
     asafenumber(num, 'num');
+    asafenumber(degree, 'degree');
+    const divisorN = divisor === undefined ? degree : divisor;
+    asafenumber(divisorN, 'divisor');
     const F = Fp;
-    // Generic callers can hit empty / fractional row counts through `__TEST`; fail closed instead of
-    // silently returning `[]` or deriving extra Frobenius rows from a truncated loop bound.
+    // Generic callers reach this through `__TEST`; validate before bigint operators can throw raw
+    // native RangeError/TypeError diagnostics for malformed tower parameters.
+    if (typeof modulus !== 'bigint' || modulus <= _1n)
+        throw new Error('calcFrobeniusCoefficients: expected valid modulus, got ' + modulus);
+    if (degree <= 0)
+        throw new Error('calcFrobeniusCoefficients: expected positive degree, got ' + degree);
     if (num <= 0)
         throw new Error('calcFrobeniusCoefficients: expected positive row count, got ' + num);
-    const _divisor = BigInt(divisor === undefined ? degree : divisor);
+    if (divisorN <= 0)
+        throw new Error('calcFrobeniusCoefficients: expected positive divisor, got ' + divisorN);
+    const _divisor = BigInt(divisorN);
     const towerModulus = modulus ** BigInt(degree);
@@ -75,2 +85,18 @@ const res = [];
 export function psiFrobenius(Fp, Fp2, base) {
+    mod.validateField(Fp);
+    mod.validateField(Fp2);
+    validateObject(Fp2, {
+        Fp: 'object',
+        frobeniusMap: 'function',
+        fromBigTuple: 'function',
+        mulByB: 'function',
+        mulByNonresidue: 'function',
+        reim: 'function',
+        Fp4Square: 'function',
+        NONRESIDUE: 'object',
+    }, {});
+    if (!isObj(base) || Array.isArray(base))
+        throw new TypeError('"base" expected Fp2 element, got type=' + typeof base);
+    if (!Fp2.isValid(base))
+        throw new RangeError('"base" expected valid Fp2 element');
     // GLV endomorphism Ψ(P)
@@ -97,2 +123,7 @@ const PSI_X = Fp2.pow(base, (Fp.ORDER - _1n) / _3n); // u^((p-1)/3)
     const mapAffine = (fn) => (c, P) => {
+        if (typeof c !== 'function')
+            throw new TypeError('"c" expected point constructor, got type=' + typeof c);
+        validatePointCons(c);
+        if (!(P instanceof c))
+            throw new TypeError('"P" expected Point instance, got type=' + typeof P);
         const affine = P.toAffine();
@@ -118,3 +149,2 @@ const p = fn(affine.x, affine.y);
     Fp_div2;
-    FROBENIUS_COEFFICIENTS;
     constructor(Fp, opts = {}) {
@@ -137,4 +167,5 @@ const { NONRESIDUE = BigInt(-1), FP2_NONRESIDUE, Fp2mulByB } = opts;
         this.NONRESIDUE = this.create({ c0: FP2_NONRESIDUE[0], c1: FP2_NONRESIDUE[1] });
-        // const Fp2Nonresidue = this.create({ c0: FP2_NONRESIDUE![0], c1: FP2_NONRESIDUE![1] });
-        this.FROBENIUS_COEFFICIENTS = Object.freeze(calcFrobeniusCoefficients(Fp, this.Fp_NONRESIDUE, Fp.ORDER, 2)[0]);
+        // NOTE: no Fp2 FROBENIUS_COEFFICIENTS table: for the shipped `u² = -1` tower the coefficients
+        // are always [1, -1] (x²+1 irreducible forces p ≡ 3 mod 4), so frobeniusMap conjugates
+        // directly and the eager table computation was pure import-time waste.
         this.mulByB = (num) => {
@@ -195,3 +226,3 @@ // This config hook is trusted to return a canonical Fp2 value already.
     invertBatch(nums) {
-        return mod.FpInvertBatch(this, nums);
+        return mod.FpInvertBatch(this, nums, true);
     }
@@ -346,9 +377,18 @@ // Normalized
     mulByNonresidue({ c0, c1 }) {
-        return this.mul({ c0, c1 }, this.NONRESIDUE);
+        const { Fp, NONRESIDUE: nr } = this;
+        if (nr.c0 === Fp.ONE && nr.c1 === Fp.ONE) {
+            return Object.freeze({ c0: Fp.sub(c0, c1), c1: Fp.add(c0, c1) });
+        }
+        if (nr.c1 === Fp.ONE) {
+            return Object.freeze({
+                c0: Fp.sub(Fp.mul(c0, nr.c0), c1),
+                c1: Fp.add(c0, Fp.mul(c1, nr.c0)),
+            });
+        }
+        return this.mul({ c0, c1 }, nr);
     }
-    frobeniusMap({ c0, c1 }, power) {
-        return Object.freeze({
-            c0,
-            c1: this.Fp.mul(c1, this.FROBENIUS_COEFFICIENTS[power % 2]),
-        });
+    frobeniusMap(num, power) {
+        const { c0, c1 } = num;
+        const { Fp } = this;
+        return Object.freeze({ c0, c1: power % 2 === 0 ? c1 : Fp.neg(c1) });
     }
@@ -507,3 +547,3 @@ }
     invertBatch(nums) {
-        return mod.FpInvertBatch(this, nums);
+        return mod.FpInvertBatch(this, nums, true);
     }
@@ -558,3 +598,6 @@ inv({ c0, c1, c2 }) {
     }
-    frobeniusMap({ c0, c1, c2 }, power) {
+    frobeniusMap(num, power) {
+        const { c0, c1, c2 } = num;
+        if (power % 6 === 0)
+            return Object.freeze({ c0, c1, c2 });
         const { Fp2 } = this;
@@ -707,3 +750,3 @@ return Object.freeze({
     invertBatch(nums) {
-        return mod.FpInvertBatch(this, nums);
+        return mod.FpInvertBatch(this, nums, true);
     }
@@ -804,6 +847,11 @@ // Normalized
     frobeniusMap(lhs, power) {
+        const p = power % 12;
+        if (p === 0)
+            return Object.freeze({ c0: lhs.c0, c1: lhs.c1 });
+        if (p === 6)
+            return this.conjugate(lhs);
         const { Fp6 } = this;
         const { Fp2 } = Fp6;
         const { c0, c1, c2 } = Fp6.frobeniusMap(lhs.c1, power);
-        const coeff = this.FROBENIUS_COEFFICIENTS[power % 12];
+        const coeff = this.FROBENIUS_COEFFICIENTS[p];
         return Object.freeze({
@@ -829,29 +877,2 @@ c0: Fp6.frobeniusMap(lhs.c0, power),
     }
-    // Sparse multiplication
-    mul014({ c0, c1 }, o0, o1, o4) {
-        const { Fp6 } = this;
-        const { Fp2 } = Fp6;
-        let t0 = Fp6.mul01(c0, o0, o1);
-        let t1 = Fp6.mul1(c1, o4);
-        return Object.freeze({
-            c0: Fp6.add(Fp6.mulByNonresidue(t1), t0), // T1 * v + T0
-            // (c1 + c0) * [o0, o1+o4] - T0 - T1
-            c1: Fp6.sub(Fp6.sub(Fp6.mul01(Fp6.add(c1, c0), o0, Fp2.add(o1, o4)), t0), t1),
-        });
-    }
-    mul034({ c0, c1 }, o0, o3, o4) {
-        const { Fp6 } = this;
-        const { Fp2 } = Fp6;
-        const a = Object.freeze({
-            c0: Fp2.mul(c0.c0, o0),
-            c1: Fp2.mul(c0.c1, o0),
-            c2: Fp2.mul(c0.c2, o0),
-        });
-        const b = Fp6.mul01(c1, o3, o4);
-        const e = Fp6.mul01(Fp6.add(c0, c1), Fp2.add(o0, o3), o4);
-        return Object.freeze({
-            c0: Fp6.add(Fp6.mulByNonresidue(b), a),
-            c1: Fp6.sub(e, Fp6.add(a, b)),
-        });
-    }
     // A cyclotomic group is a subgroup of Fp^n defined by
@@ -889,4 +910,6 @@ //   GΦₙ(p) = {α ∈ Fpⁿ : α^Φₙ(p) = 1}
         aInRange('cyclotomic exponent', n, _0n, _1n << BigInt(this.X_LEN));
-        let z = this.ONE;
-        for (let i = this.X_LEN - 1; i >= 0; i--) {
+        if (n === _0n)
+            return this.ONE;
+        let z = num;
+        for (let i = bitLen(n) - 2; i >= 0; i--) {
             z = this._cyclotomicSquare(z);
@@ -908,2 +931,3 @@ if (bitGet(n, i))
  * ```ts
+ * import { tower12, type Fp2, type Fp12 } from '@noble/curves/abstract/tower.js';
  * const fields = tower12({
@@ -913,4 +937,4 @@ *   ORDER: 17n,
  *   FP2_NONRESIDUE: [1n, 1n],
- *   Fp2mulByB: (num) => num,
- *   Fp12finalExponentiate: (num) => num,
+ *   Fp2mulByB: (num: Fp2) => num,
+ *   Fp12finalExponentiate: (num: Fp12) => num,
  * });
@@ -942,2 +966,1 @@ * const fp12 = fields.Fp12.ONE;
 }
-//# sourceMappingURL=tower.js.map

abstract/weierstrass.d.ts

@@ -6,2 +6,3 @@ import { type CHash, type HmacFn, type TArg, type TRet } from '../utils.ts';
 export type { AffinePoint };
+export { DER, DERErr, type IDER } from './der.ts';
 type EndoBasis = [[bigint, bigint], [bigint, bigint]];
@@ -11,6 +12,6 @@ /**
  * Koblitz curves allow using **efficiently-computable GLV endomorphism ψ**.
- * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
- * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
+ * Endomorphism speeds up un-precomputed public-scalar multiplication (verification / key
+ * recovery) by splitting a scalar into two half-width halves that share doublings.
  *
- * Endomorphism consists of beta, lambda and splitScalar:
+ * Endomorphism consists of beta, lambda and basises:
  *
@@ -26,3 +27,3 @@ * 1. GLV endomorphism ψ transforms a point: `P = (x, y) ↦ ψ(P) = (β·x mod p, y)`
  * * lambda: λ ∈ Fₙ with λ³ = 1, λ ≠ 1
- * * splitScalar decomposes k ↦ k₁, k₂, by using reduced basis vectors.
+ * * `_splitEndoScalar` decomposes k ↦ k₁, k₂, by using reduced basis vectors.
  *   Gauss lattice reduction calculates them from initial basis vectors `(n, 0), (-λ, 0)`
@@ -38,12 +39,2 @@ *
     basises?: EndoBasis;
-    /**
-     * Optional custom scalar-splitting helper.
-     * Receives one scalar and returns two half-sized scalar components.
-     */
-    splitScalar?: (k: bigint) => {
-        k1neg: boolean;
-        k1: bigint;
-        k2neg: boolean;
-        k2: bigint;
-    };
 };
@@ -156,2 +147,13 @@ /** Two half-sized scalar components returned by endomorphism splitting. */
     toHex(isCompressed?: boolean): string;
+    /**
+     * Double-scalar multiplication `a⋅this + b⋅other` via Strauss–Shamir: both scalar walks
+     * share one doubling chain, and GLV endomorphism (when the curve has one) halves the chain
+     * again by splitting each scalar. 1.3-1.7x faster than two `multiplyUnsafe()` calls.
+     * Not constant-time: only for public scalars, e.g. ECDSA verification's `u1⋅G + u2⋅P`.
+     * @param a - Scalar for this point.
+     * @param other - Second point.
+     * @param b - Scalar for the second point.
+     * @returns Combined product point.
+     */
+    mulAddUnsafe(a: bigint, other: WeierstrassPoint<T>, b: bigint): WeierstrassPoint<T>;
 }
@@ -211,2 +213,4 @@ /** Constructor and metadata helpers for Weierstrass points. */
     endo: EndomorphismOpts;
+    /** RNG override used for scalar blinding. */
+    randomBytes: (bytesLength?: number) => TRet<Uint8Array>;
     /** Optional torsion-check override. */
@@ -319,91 +323,2 @@ isTorsionFree: (c: WeierstrassPointCons<T>, point: WeierstrassPoint<T>) => boolean;
 /**
- * @param m - Error message.
- * @example
- * Throw a DER-specific error when signature parsing encounters invalid bytes.
- *
- * ```ts
- * new DERErr('bad der');
- * ```
- */
-export declare class DERErr extends Error {
-    constructor(m?: string);
-}
-/** DER helper namespace used by ECDSA signature parsing and encoding. */
-export type IDER = {
-    /**
-     * DER-specific error constructor.
-     * @param m - Error message.
-     * @returns DER-specific error instance.
-     */
-    Err: typeof DERErr;
-    /** Low-level tag-length-value helpers used by DER encoders. */
-    _tlv: {
-        /**
-         * Encode one TLV record.
-         * @param tag - ASN.1 tag byte.
-         * @param data - Hex-encoded value payload.
-         * @returns Encoded TLV string.
-         */
-        encode: (tag: number, data: string) => string;
-        /**
-         * Decode one TLV record and return the value plus leftover bytes.
-         * @param tag - Expected ASN.1 tag byte.
-         * @param data - Remaining DER bytes.
-         * @returns Parsed value plus leftover bytes.
-         */
-        decode(tag: number, data: TArg<Uint8Array>): TRet<{
-            v: Uint8Array;
-            l: Uint8Array;
-        }>;
-    };
-    /** Positive-integer DER helpers used by ECDSA signature encoding. */
-    _int: {
-        /**
-         * Encode one positive bigint as a DER INTEGER.
-         * @param num - Positive integer to encode.
-         * @returns Encoded DER INTEGER.
-         */
-        encode(num: bigint): string;
-        /**
-         * Decode one DER INTEGER into a bigint.
-         * @param data - DER INTEGER bytes.
-         * @returns Decoded bigint.
-         */
-        decode(data: TArg<Uint8Array>): bigint;
-    };
-    /**
-     * Parse a DER signature into `{ r, s }`.
-     * @param bytes - DER signature bytes.
-     * @returns Parsed signature components.
-     */
-    toSig(bytes: TArg<Uint8Array>): {
-        r: bigint;
-        s: bigint;
-    };
-    /**
-     * Encode `{ r, s }` as a DER signature.
-     * @param sig - Signature components.
-     * @returns DER-encoded signature hex.
-     */
-    hexFromSig(sig: {
-        r: bigint;
-        s: bigint;
-    }): string;
-};
-/**
- * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:
- *
- *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]
- *
- * Docs: {@link https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/ | Let's Encrypt ASN.1 guide} and
- * {@link https://luca.ntop.org/Teaching/Appunti/asn1.html | Luca Deri's ASN.1 notes}.
- * @example
- * ASN.1 DER encoding utilities.
- *
- * ```ts
- * const der = DER.hexFromSig({ r: 1n, s: 2n });
- * ```
- */
-export declare const DER: IDER;
-/**
  * Creates weierstrass Point constructor, based on specified curve options.
@@ -494,55 +409,2 @@ *
 /**
- * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.
- * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.
- * b = True and y = sqrt(u / v) if (u / v) is square in F, and
- * b = False and y = sqrt(Z * (u / v)) otherwise.
- * RFC 9380 expects callers to provide `v != 0`; this helper does not enforce it.
- * @param Fp - Field implementation.
- * @param Z - Simplified SWU map parameter.
- * @returns Square-root ratio helper.
- * @example
- * Build the square-root ratio helper used by SWU map implementations.
- *
- * ```ts
- * import { SWUFpSqrtRatio } from '@noble/curves/abstract/weierstrass.js';
- * import { Field } from '@noble/curves/abstract/modular.js';
- * const Fp = Field(17n);
- * const sqrtRatio = SWUFpSqrtRatio(Fp, 3n);
- * const out = sqrtRatio(4n, 1n);
- * ```
- */
-export declare function SWUFpSqrtRatio<T>(Fp: TArg<IField<T>>, Z: T): (u: T, v: T) => {
-    isValid: boolean;
-    value: T;
-};
-/**
- * Simplified Shallue-van de Woestijne-Ulas Method
- * See {@link https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2 | RFC 9380 section 6.6.2}.
- * @param Fp - Field implementation.
- * @param opts - SWU parameters:
- *   - `A`: Curve parameter `A`.
- *   - `B`: Curve parameter `B`.
- *   - `Z`: Simplified SWU map parameter.
- * @returns Deterministic map-to-curve function.
- * @throws If the SWU parameters are invalid or the field lacks the required helpers. {@link Error}
- * @example
- * Map one field element to a Weierstrass curve point with the SWU recipe.
- *
- * ```ts
- * import { mapToCurveSimpleSWU } from '@noble/curves/abstract/weierstrass.js';
- * import { Field } from '@noble/curves/abstract/modular.js';
- * const Fp = Field(17n);
- * const map = mapToCurveSimpleSWU(Fp, { A: 1n, B: 2n, Z: 3n });
- * const point = map(5n);
- * ```
- */
-export declare function mapToCurveSimpleSWU<T>(Fp: TArg<IField<T>>, opts: {
-    A: T;
-    B: T;
-    Z: T;
-}): (u: T) => {
-    x: T;
-    y: T;
-};
-/**
  * Sometimes users only need getPublicKey, getSharedSecret, and secret key handling.
@@ -596,2 +458,1 @@ * This helper ensures no signature functionality is present. Less code, smaller bundle size.
 export declare function ecdsa(Point: WeierstrassPointCons<bigint>, hash: TArg<CHash>, ecdsaOpts?: TArg<ECDSAOpts>): ECDSA;
-//# sourceMappingURL=weierstrass.d.ts.map

abstract/weierstrass.js

@@ -30,5 +30,8 @@ /**
 import { ahash } from '@noble/hashes/utils.js';
-import { abignumber, abool, abytes, aInRange, asafenumber, bitLen, bitMask, bytesToHex, bytesToNumberBE, concatBytes, createHmacDrbg, hexToBytes, isBytes, numberToHexUnpadded, validateObject, randomBytes as wcRandomBytes, } from "../utils.js";
-import { createCurveFields, createKeygen, mulEndoUnsafe, negateCt, normalizeZ, wNAF, } from "./curve.js";
-import { FpInvertBatch, FpIsSquare, getMinHashLength, mapHashToField, validateField, } from "./modular.js";
+import { abool, abytes, aInRange, bitLen, bitMask, bytesToHex, bytesToNumberBE, concatBytes, createHmacDrbg, hexToBytes, isBytes, validateObject, randomBytes as wcRandomBytes, } from "../utils.js";
+import { createCurveFields, createKeygen, mulAddUnsafe, normalizeZ, probeRandomBytes, ScalarMultiplier, validatePointCons, } from "./curve.js";
+import { DER } from "./der.js";
+import { getMinHashLength, invertCt, mapHashToField } from "./modular.js";
+// DER codec lives in der.ts; re-exported here because ECDSA signatures are its main consumer.
+export { DER, DERErr } from "./der.js";
 // We construct the basis so `den` is always positive and equals `n`,
@@ -61,4 +64,4 @@ // but the `num` sign depends on the basis, not on the secret value.
         k2 = -k2;
-    // Double check that resulting scalar less than half bits of N: otherwise wNAF will fail.
-    // This should only happen on wrong bases.
+    // Double check that resulting scalar is less than half bits of N: the wNAF pair walk
+    // relies on the halves being short. This should only happen on wrong bases.
     // Also, the math inside is complex enough that this guard is worth keeping.
@@ -92,149 +95,2 @@ const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n; // Half bits of N
 }
-/**
- * @param m - Error message.
- * @example
- * Throw a DER-specific error when signature parsing encounters invalid bytes.
- *
- * ```ts
- * new DERErr('bad der');
- * ```
- */
-export class DERErr extends Error {
-    constructor(m = '') {
-        super(m);
-    }
-}
-/**
- * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:
- *
- *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]
- *
- * Docs: {@link https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/ | Let's Encrypt ASN.1 guide} and
- * {@link https://luca.ntop.org/Teaching/Appunti/asn1.html | Luca Deri's ASN.1 notes}.
- * @example
- * ASN.1 DER encoding utilities.
- *
- * ```ts
- * const der = DER.hexFromSig({ r: 1n, s: 2n });
- * ```
- */
-export const DER = {
-    // asn.1 DER encoding utils
-    Err: DERErr,
-    // Basic building block is TLV (Tag-Length-Value)
-    _tlv: {
-        encode: (tag, data) => {
-            const { Err: E } = DER;
-            asafenumber(tag, 'tag');
-            if (tag < 0 || tag > 255)
-                throw new E('tlv.encode: wrong tag');
-            if (typeof data !== 'string')
-                throw new TypeError('"data" expected string, got type=' + typeof data);
-            // Internal helper: callers hand this already-validated hex payload, so we only enforce
-            // byte alignment here instead of re-validating every nibble.
-            if (data.length & 1)
-                throw new E('tlv.encode: unpadded data');
-            const dataLen = data.length / 2;
-            const len = numberToHexUnpadded(dataLen);
-            if ((len.length / 2) & 0b1000_0000)
-                throw new E('tlv.encode: long form length too big');
-            // length of length with long form flag
-            const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 0b1000_0000) : '';
-            const t = numberToHexUnpadded(tag);
-            return t + lenLen + len + data;
-        },
-        // v - value, l - left bytes (unparsed)
-        decode(tag, data) {
-            const { Err: E } = DER;
-            data = abytes(data, undefined, 'DER data');
-            let pos = 0;
-            if (tag < 0 || tag > 255)
-                throw new E('tlv.encode: wrong tag');
-            if (data.length < 2 || data[pos++] !== tag)
-                throw new E('tlv.decode: wrong tlv');
-            const first = data[pos++];
-            // First bit of first length byte is the short/long form flag.
-            const isLong = !!(first & 0b1000_0000);
-            let length = 0;
-            if (!isLong)
-                length = first;
-            else {
-                // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]
-                const lenLen = first & 0b0111_1111;
-                if (!lenLen)
-                    throw new E('tlv.decode(long): indefinite length not supported');
-                // This would overflow u32 in JS.
-                if (lenLen > 4)
-                    throw new E('tlv.decode(long): byte length is too big');
-                const lengthBytes = data.subarray(pos, pos + lenLen);
-                if (lengthBytes.length !== lenLen)
-                    throw new E('tlv.decode: length bytes not complete');
-                if (lengthBytes[0] === 0)
-                    throw new E('tlv.decode(long): zero leftmost byte');
-                for (const b of lengthBytes)
-                    length = (length << 8) | b;
-                pos += lenLen;
-                if (length < 128)
-                    throw new E('tlv.decode(long): not minimal encoding');
-            }
-            const v = data.subarray(pos, pos + length);
-            if (v.length !== length)
-                throw new E('tlv.decode: wrong value length');
-            return { v, l: data.subarray(pos + length) };
-        },
-    },
-    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
-    // since we always use positive integers here. It must always be empty:
-    // - add zero byte if exists
-    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
-    _int: {
-        encode(num) {
-            const { Err: E } = DER;
-            abignumber(num);
-            if (num < _0n)
-                throw new E('integer: negative integers are not allowed');
-            let hex = numberToHexUnpadded(num);
-            // Pad with zero byte if negative flag is present
-            if (Number.parseInt(hex[0], 16) & 0b1000)
-                hex = '00' + hex;
-            if (hex.length & 1)
-                throw new E('unexpected DER parsing assertion: unpadded hex');
-            return hex;
-        },
-        decode(data) {
-            const { Err: E } = DER;
-            if (data.length < 1)
-                throw new E('invalid signature integer: empty');
-            if (data[0] & 0b1000_0000)
-                throw new E('invalid signature integer: negative');
-            // Single-byte zero `00` is the canonical DER INTEGER encoding for zero.
-            if (data.length > 1 && data[0] === 0x00 && !(data[1] & 0b1000_0000))
-                throw new E('invalid signature integer: unnecessary leading zero');
-            return bytesToNumberBE(data);
-        },
-    },
-    toSig(bytes) {
-        // parse DER signature
-        const { Err: E, _int: int, _tlv: tlv } = DER;
-        const data = abytes(bytes, undefined, 'signature');
-        const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);
-        if (seqLeftBytes.length)
-            throw new E('invalid signature: left bytes after parsing');
-        const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);
-        const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);
-        if (sLeftBytes.length)
-            throw new E('invalid signature: left bytes after parsing');
-        return { r: int.decode(rBytes), s: int.decode(sBytes) };
-    },
-    hexFromSig(sig) {
-        const { _tlv: tlv, _int: int } = DER;
-        const rs = tlv.encode(0x02, int.encode(sig.r));
-        const ss = tlv.encode(0x02, int.encode(sig.s));
-        const seq = rs + ss;
-        return tlv.encode(0x30, seq);
-    },
-};
-Object.freeze(DER._tlv);
-Object.freeze(DER._int);
-Object.freeze(DER);
 // Be friendly to bad ECMAScript parsers by not using bigint literals
@@ -281,2 +137,3 @@ // prettier-ignore
         endo: 'object',
+        randomBytes: 'function',
     });
@@ -286,4 +143,4 @@ // Snapshot constructor-time flags whose later mutation would otherwise change
     const { endo, allowInfinityPoint } = extraOpts;
+    const randomBytes = extraOpts.randomBytes === undefined ? wcRandomBytes : extraOpts.randomBytes;
     if (endo) {
-        // validateObject(endo, { beta: 'bigint', splitScalar: 'function' });
         if (!Fp.is0(CURVE.a) || typeof endo.beta !== 'bigint' || !Array.isArray(endo.basises)) {
@@ -365,5 +222,10 @@ throw new Error('invalid endo: expected "beta": bigint and "basises": array');
     const decodePoint = extraOpts.fromBytes === undefined ? pointFromBytes : extraOpts.fromBytes;
+    // Hoisted from double() / add(): curve params never change after construction.
+    // Koblitz curves (a=0, e.g. secp256k1) skip the three a-multiplications per operation;
+    // the selection depends only on public curve constants.
+    const b3 = Fp.mul(CURVE.b, _3n);
+    const mulA = Fp.is0(CURVE.a) ? (_) => Fp.ZERO : (x) => Fp.mul(CURVE.a, x);
     function weierstrassEquation(x) {
-        const x2 = Fp.sqr(x); // x * x
-        const x3 = Fp.mul(x2, x); // x² * x
+        const x2 = Fp.sqr(x);
+        const x3 = Fp.mul(x2, x);
         return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b); // x³ + a * x + b
@@ -374,3 +236,3 @@ }
     function isValidXY(x, y) {
-        const left = Fp.sqr(y); // y²
+        const left = Fp.sqr(y);
         const right = weierstrassEquation(x); // x³ + ax + b
@@ -405,8 +267,28 @@ return Fp.eql(left, right);
     }
-    function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
-        k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);
-        k1p = negateCt(k1neg, k1p);
-        k2p = negateCt(k2neg, k2p);
-        return k1p.add(k2p);
+    /**
+     * Appends a (point, scalar) pair to the inputs of a vartime wNAF walk
+     * ({@link mulAddUnsafe}). With GLV endomorphism the scalar is split into two half-width
+     * pairs against P and ψ(P) = (β⋅x, y), halving the walk's shared doubling chain;
+     * split signs fold into the points.
+     */
+    function pushWnafPair(points, scalars, p, k) {
+        if (!Fn.isValid(k))
+            throw new RangeError('invalid scalar: out of range'); // 0 is valid
+        if (endo) {
+            const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(k);
+            const psi = new Point(Fp.mul(p.X, endo.beta), p.Y, p.Z);
+            points.push(k1neg ? p.negate() : p, k2neg ? psi.negate() : psi);
+            scalars.push(k1, k2);
+        }
+        else {
+            points.push(p);
+            scalars.push(k);
+        }
     }
+    // Successful assertValidity() results are cached: Point instances are frozen at construction,
+    // so on-curve + subgroup facts cannot change afterwards. Only success is cached — invalid
+    // points re-throw on every call. This matters most for pairing curves, where subgroup checks
+    // cost a scalar multiplication and the same instance is re-validated across layers
+    // (signature fromBytes, pairingBatch) or across repeated verifies with a cached public key.
+    const validityCache = new WeakSet();
     /**
@@ -418,9 +300,5 @@ * Projective Point works in 3d / projective (homogeneous) coordinates:(X, Y, Z) ∋ (x=X/Z, y=Y/Z).
     class Point {
-        // base / generator point
         static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
-        // zero / infinity / identity point
-        static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO); // 0, 1, 0
-        // math field
+        static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
         static Fp = Fp;
-        // scalar field
         static Fn = Fn;
@@ -470,9 +348,6 @@ X;
         /**
-         *
-         * @param windowSize
          * @param isLazy - true will defer table computation until the first multiplication
-         * @returns
          */
-        precompute(windowSize = 8, isLazy = true) {
-            wnaf.createCache(this, windowSize);
+        precompute(windowSize = 6, isLazy = true) {
+            wnaf.setWindowSize(this, windowSize);
             if (!isLazy)
@@ -495,2 +370,4 @@ this.multiply(_3n); // random number
             }
+            if (validityCache.has(p))
+                return;
             // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`
@@ -504,2 +381,3 @@ const { x, y } = p.toAffine();
                 throw new Error('bad point: not in prime-order subgroup');
+            validityCache.add(p);
         }
@@ -530,4 +408,2 @@ hasEvenY() {
         double() {
-            const { a, b } = CURVE;
-            const b3 = Fp.mul(b, _3n);
             const { X: X1, Y: Y1, Z: Z1 } = this;
@@ -542,3 +418,3 @@ let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore
             Z3 = Fp.add(Z3, Z3);
-            X3 = Fp.mul(a, Z3);
+            X3 = mulA(Z3);
             Y3 = Fp.mul(b3, t2);
@@ -551,5 +427,5 @@ Y3 = Fp.add(X3, Y3); // step 10
             Z3 = Fp.mul(b3, Z3); // step 15
-            t2 = Fp.mul(a, t2);
+            t2 = mulA(t2);
             t3 = Fp.sub(t0, t2);
-            t3 = Fp.mul(a, t3);
+            t3 = mulA(t3);
             t3 = Fp.add(t3, Z3);
@@ -579,4 +455,2 @@ Z3 = Fp.add(t0, t0); // step 20
             let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore
-            const a = CURVE.a;
-            const b3 = Fp.mul(CURVE.b, _3n);
             let t0 = Fp.mul(X1, X2); // step 1
@@ -600,3 +474,3 @@ let t1 = Fp.mul(Y1, Y2);
             t5 = Fp.sub(t5, X3);
-            Z3 = Fp.mul(a, t4);
+            Z3 = mulA(t4);
             X3 = Fp.mul(b3, t2); // step 20
@@ -609,7 +483,7 @@ Z3 = Fp.add(X3, Z3);
             t1 = Fp.add(t1, t0);
-            t2 = Fp.mul(a, t2);
+            t2 = mulA(t2);
             t4 = Fp.mul(b3, t4);
             t1 = Fp.add(t1, t2);
             t2 = Fp.sub(t0, t2); // step 30
-            t2 = Fp.mul(a, t2);
+            t2 = mulA(t2);
             t4 = Fp.add(t4, t2);
@@ -637,6 +511,4 @@ t0 = Fp.mul(t1, t4);
          * Constant time multiplication.
-         * Uses wNAF method. Windowed method may be 10% faster,
-         * but takes 2x longer to generate and consumes 2x memory.
-         * Uses precomputes when available.
-         * Uses endomorphism for Koblitz curves.
+         * Uses precomputed tables (signed fixed-window wNAF) when available.
+         * Uses scalar blinding and avoids endomorphism splitting in the secret-scalar path.
          * @param scalar - by which the point would be multiplied
@@ -646,3 +518,2 @@ * @returns New point
         multiply(scalar) {
-            const { endo } = extraOpts;
             // Keep the subgroup-scalar contract strict instead of reducing 0 / n to ZERO.
@@ -653,22 +524,8 @@ // In key/signature-style callers, those values usually mean broken hash/scalar plumbing,
                 throw new RangeError('invalid scalar: out of range'); // 0 is invalid
-            let point, fake; // Fake point is used to const-time mult
-            const mul = (n) => wnaf.cached(this, n, (p) => normalizeZ(Point, p));
-            /** See docs for {@link EndomorphismOpts} */
-            if (endo) {
-                const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);
-                const { p: k1p, f: k1f } = mul(k1);
-                const { p: k2p, f: k2f } = mul(k2);
-                fake = k1f.add(k2f);
-                point = finishEndo(endo.beta, k1p, k2p, k1neg, k2neg);
-            }
-            else {
-                const { p, f } = mul(scalar);
-                point = p;
-                fake = f;
-            }
-            // Normalize `z` for both points, but return only real one
-            return normalizeZ(Point, [point, fake])[0];
+            const { p, f } = wnaf.mulSecret(this, scalar, cofactor, normalize);
+            return normalize([p, f])[0];
         }
         /**
-         * Non-constant-time multiplication. Uses double-and-add algorithm.
+         * Non-constant-time multiplication. Uses width-4 wNAF with GLV endomorphism splitting
+         * when available (two half-width scalars sharing one halved doubling chain).
          * It's faster, but should only be used when you don't care about
@@ -678,3 +535,2 @@ * an exposed secret key e.g. sig verification, which works over *public* keys.
         multiplyUnsafe(scalar) {
-            const { endo } = extraOpts;
             const p = this;
@@ -687,19 +543,28 @@ const sc = scalar;
             if (sc === _0n || p.is0())
-                return Point.ZERO; // 0
+                return Point.ZERO;
             if (sc === _1n)
-                return p; // 1
-            if (wnaf.hasCache(this))
-                return this.multiply(sc); // precomputes
-            // We don't have method for double scalar multiplication (aP + bQ):
-            // Even with using Strauss-Shamir trick, it's 35% slower than naïve mul+add.
-            if (endo) {
-                const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);
-                const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2); // 30% faster vs wnaf.unsafe
-                return finishEndo(endo.beta, p1, p2, k1neg, k2neg);
-            }
-            else {
-                return wnaf.unsafe(p, sc);
-            }
+                return p;
+            if (wnaf.hasWindowSize(this))
+                return wnaf.mulUnsafe(p, sc, normalize); // precomputes
+            const points = [];
+            const scalars = [];
+            pushWnafPair(points, scalars, p, sc);
+            return mulAddUnsafe(Point, points, scalars);
         }
         /**
+         * Non-constant-time double-scalar multiplication `a⋅this + b⋅other` (Strauss–Shamir).
+         * Both walks share one doubling chain via {@link mulAddUnsafe}, and GLV endomorphism
+         * (when available) halves the chain again by splitting each scalar into two half-width
+         * parts. Used by ECDSA verification and public-key recovery for `R = u1⋅G + u2⋅P`.
+         * Only for public scalars.
+         */
+        mulAddUnsafe(a, other, b) {
+            aprjpoint(other);
+            const points = [];
+            const scalars = [];
+            pushWnafPair(points, scalars, this, a);
+            pushWnafPair(points, scalars, other, b);
+            return mulAddUnsafe(Point, points, scalars);
+        }
+        /**
          * Converts Projective point to affine (x, y) coordinates.
@@ -712,2 +577,4 @@ * (X, Y, Z) ∋ (x=X/Z, y=Y/Z).
             let iz = invertedZ;
+            if (iz != null && !Fp.isValid(iz))
+                throw new RangeError('"invertedZ" expected valid field element');
             const { X, Y, Z } = p;
@@ -741,3 +608,4 @@ // Fast-path for normalized points
                 return isTorsionFree(Point, this);
-            return wnaf.unsafe(this, CURVE_ORDER).is0();
+            // unsafe() will use the uncached wNAF path internally, since CURVE_ORDER >= Fn.ORDER
+            return wnaf.mulUnsafe(this, CURVE_ORDER).is0();
         }
@@ -774,8 +642,8 @@ clearCofactor() {
     }
-    const bits = Fn.BITS;
-    const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits);
-    // Tiny toy curves can have scalar fields narrower than 8 bits. Skip the
-    // eager W=8 cache there instead of rejecting an otherwise valid constructor.
-    if (bits >= 8)
-        Point.BASE.precompute(8); // Enable precomputes. Slows down first publicKey computation by 20ms.
+    const normalize = (points) => normalizeZ(Point, points);
+    const wnaf = new ScalarMultiplier(Point, randomBytes);
+    // Enable W=6 wNAF precomputes. Slows down first publicKey computation.
+    // Disable for tiny toy curves, with scalar fields < 6 bits.
+    if (wnaf.bits >= 6)
+        Point.BASE.precompute(6);
     Object.freeze(Point.prototype);
@@ -789,180 +657,2 @@ Object.freeze(Point);
 }
-/**
- * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.
- * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.
- * b = True and y = sqrt(u / v) if (u / v) is square in F, and
- * b = False and y = sqrt(Z * (u / v)) otherwise.
- * RFC 9380 expects callers to provide `v != 0`; this helper does not enforce it.
- * @param Fp - Field implementation.
- * @param Z - Simplified SWU map parameter.
- * @returns Square-root ratio helper.
- * @example
- * Build the square-root ratio helper used by SWU map implementations.
- *
- * ```ts
- * import { SWUFpSqrtRatio } from '@noble/curves/abstract/weierstrass.js';
- * import { Field } from '@noble/curves/abstract/modular.js';
- * const Fp = Field(17n);
- * const sqrtRatio = SWUFpSqrtRatio(Fp, 3n);
- * const out = sqrtRatio(4n, 1n);
- * ```
- */
-export function SWUFpSqrtRatio(Fp, Z) {
-    // Fail with the usual field-shape error before touching pow/cmov on malformed field shims.
-    const F = validateField(Fp);
-    // Generic implementation
-    const q = F.ORDER;
-    let l = _0n;
-    for (let o = q - _1n; o % _2n === _0n; o /= _2n)
-        l += _1n;
-    const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.
-    // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.
-    // 2n ** c1 == 2n << (c1-1)
-    const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);
-    const _2n_pow_c1 = _2n_pow_c1_1 * _2n;
-    const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic
-    const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic
-    const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic
-    const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic
-    const c6 = F.pow(Z, c2); // 6. c6 = Z^c2
-    const c7 = F.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)
-    // RFC 9380 Appendix F.2.1.1 defines sqrt_ratio(u, v) only for v != 0.
-    // We keep v=0 on the regular result path with isValid=false instead of
-    // throwing so the helper stays closer to the RFC's fixed control flow.
-    let sqrtRatio = (u, v) => {
-        let tv1 = c6; // 1. tv1 = c6
-        let tv2 = F.pow(v, c4); // 2. tv2 = v^c4
-        let tv3 = F.sqr(tv2); // 3. tv3 = tv2^2
-        tv3 = F.mul(tv3, v); // 4. tv3 = tv3 * v
-        let tv5 = F.mul(u, tv3); // 5. tv5 = u * tv3
-        tv5 = F.pow(tv5, c3); // 6. tv5 = tv5^c3
-        tv5 = F.mul(tv5, tv2); // 7. tv5 = tv5 * tv2
-        tv2 = F.mul(tv5, v); // 8. tv2 = tv5 * v
-        tv3 = F.mul(tv5, u); // 9. tv3 = tv5 * u
-        let tv4 = F.mul(tv3, tv2); // 10. tv4 = tv3 * tv2
-        tv5 = F.pow(tv4, c5); // 11. tv5 = tv4^c5
-        let isQR = F.eql(tv5, F.ONE); // 12. isQR = tv5 == 1
-        tv2 = F.mul(tv3, c7); // 13. tv2 = tv3 * c7
-        tv5 = F.mul(tv4, tv1); // 14. tv5 = tv4 * tv1
-        tv3 = F.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)
-        tv4 = F.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)
-        // 17. for i in (c1, c1 - 1, ..., 2):
-        for (let i = c1; i > _1n; i--) {
-            let tv5 = i - _2n; // 18.    tv5 = i - 2
-            tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5
-            let tvv5 = F.pow(tv4, tv5); // 20.    tv5 = tv4^tv5
-            const e1 = F.eql(tvv5, F.ONE); // 21.    e1 = tv5 == 1
-            tv2 = F.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1
-            tv1 = F.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1
-            tvv5 = F.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1
-            tv3 = F.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)
-            tv4 = F.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)
-        }
-        // RFC 9380 Appendix F.2.1.1 defines sqrt_ratio(u, v) for v != 0.
-        // When u = 0 and v != 0, u / v = 0 is square and the computed root is
-        // still 0, so widen only the final flag and keep the full control flow.
-        return { isValid: !F.is0(v) && (isQR || F.is0(u)), value: tv3 };
-    };
-    if (F.ORDER % _4n === _3n) {
-        // sqrt_ratio_3mod4(u, v)
-        const c1 = (F.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic
-        const c2 = F.sqrt(F.neg(Z)); // 2. c2 = sqrt(-Z)
-        sqrtRatio = (u, v) => {
-            let tv1 = F.sqr(v); // 1. tv1 = v^2
-            const tv2 = F.mul(u, v); // 2. tv2 = u * v
-            tv1 = F.mul(tv1, tv2); // 3. tv1 = tv1 * tv2
-            let y1 = F.pow(tv1, c1); // 4. y1 = tv1^c1
-            y1 = F.mul(y1, tv2); // 5. y1 = y1 * tv2
-            const y2 = F.mul(y1, c2); // 6. y2 = y1 * c2
-            const tv3 = F.mul(F.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v
-            const isQR = F.eql(tv3, u); // 9. isQR = tv3 == u
-            let y = F.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)
-            return { isValid: !F.is0(v) && isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2
-        };
-    }
-    // No curves uses that
-    // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8
-    return sqrtRatio;
-}
-/**
- * Simplified Shallue-van de Woestijne-Ulas Method
- * See {@link https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2 | RFC 9380 section 6.6.2}.
- * @param Fp - Field implementation.
- * @param opts - SWU parameters:
- *   - `A`: Curve parameter `A`.
- *   - `B`: Curve parameter `B`.
- *   - `Z`: Simplified SWU map parameter.
- * @returns Deterministic map-to-curve function.
- * @throws If the SWU parameters are invalid or the field lacks the required helpers. {@link Error}
- * @example
- * Map one field element to a Weierstrass curve point with the SWU recipe.
- *
- * ```ts
- * import { mapToCurveSimpleSWU } from '@noble/curves/abstract/weierstrass.js';
- * import { Field } from '@noble/curves/abstract/modular.js';
- * const Fp = Field(17n);
- * const map = mapToCurveSimpleSWU(Fp, { A: 1n, B: 2n, Z: 3n });
- * const point = map(5n);
- * ```
- */
-export function mapToCurveSimpleSWU(Fp, opts) {
-    const F = validateField(Fp);
-    const { A, B, Z } = opts;
-    if (!F.isValidNot0(A) || !F.isValidNot0(B) || !F.isValid(Z))
-        throw new Error('mapToCurveSimpleSWU: invalid opts');
-    // RFC 9380 §6.6.2 and Appendix H.2 require:
-    // 1. Z is non-square in F
-    // 2. Z != -1 in F
-    // 3. g(x) - Z is irreducible over F
-    // 4. g(B / (Z * A)) is square in F
-    // We can enforce 1, 2, and 4 with the current field API.
-    // Criterion 3 is not checked here because generic `IField<T>` does not expose
-    // polynomial-ring / irreducibility operations, and this helper is used for
-    // both prime and extension fields.
-    if (F.eql(Z, F.neg(F.ONE)) || FpIsSquare(F, Z))
-        throw new Error('mapToCurveSimpleSWU: invalid opts');
-    // RFC 9380 Appendix H.2 criterion 4: g(B / (Z * A)) is square in F.
-    // x = B / (Z * A)
-    const x = F.mul(B, F.inv(F.mul(Z, A)));
-    // g(x) = x^3 + A*x + B
-    const gx = F.add(F.add(F.mul(F.sqr(x), x), F.mul(A, x)), B);
-    if (!FpIsSquare(F, gx))
-        throw new Error('mapToCurveSimpleSWU: invalid opts');
-    const sqrtRatio = SWUFpSqrtRatio(F, Z);
-    if (!F.isOdd)
-        throw new Error('Field does not have .isOdd()');
-    // Input: u, an element of F.
-    // Output: (x, y), a point on E.
-    return (u) => {
-        // prettier-ignore
-        let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
-        tv1 = F.sqr(u); // 1.  tv1 = u^2
-        tv1 = F.mul(tv1, Z); // 2.  tv1 = Z * tv1
-        tv2 = F.sqr(tv1); // 3.  tv2 = tv1^2
-        tv2 = F.add(tv2, tv1); // 4.  tv2 = tv2 + tv1
-        tv3 = F.add(tv2, F.ONE); // 5.  tv3 = tv2 + 1
-        tv3 = F.mul(tv3, B); // 6.  tv3 = B * tv3
-        tv4 = F.cmov(Z, F.neg(tv2), !F.eql(tv2, F.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)
-        tv4 = F.mul(tv4, A); // 8.  tv4 = A * tv4
-        tv2 = F.sqr(tv3); // 9.  tv2 = tv3^2
-        tv6 = F.sqr(tv4); // 10. tv6 = tv4^2
-        tv5 = F.mul(tv6, A); // 11. tv5 = A * tv6
-        tv2 = F.add(tv2, tv5); // 12. tv2 = tv2 + tv5
-        tv2 = F.mul(tv2, tv3); // 13. tv2 = tv2 * tv3
-        tv6 = F.mul(tv6, tv4); // 14. tv6 = tv6 * tv4
-        tv5 = F.mul(tv6, B); // 15. tv5 = B * tv6
-        tv2 = F.add(tv2, tv5); // 16. tv2 = tv2 + tv5
-        x = F.mul(tv1, tv3); // 17.   x = tv1 * tv3
-        const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)
-        y = F.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1
-        y = F.mul(y, value); // 20.   y = y * y1
-        x = F.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)
-        y = F.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)
-        const e1 = F.isOdd(u) === F.isOdd(y); // 23.  e1 = sgn0(u) == sgn0(y)
-        y = F.cmov(F.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)
-        const tv4_inv = FpInvertBatch(F, [tv4], true)[0];
-        x = F.mul(x, tv4_inv); // 25.   x = x / tv4
-        return { x, y };
-    };
-}
 function getWLengths(Fp, Fn) {
@@ -998,2 +688,3 @@ return {
 export function ecdh(Point, ecdhOpts = {}) {
+    validatePointCons(Point);
     const { Fn } = Point;
@@ -1120,2 +811,3 @@ const randomBytes_ = ecdhOpts.randomBytes === undefined ? wcRandomBytes : ecdhOpts.randomBytes;
 export function ecdsa(Point, hash, ecdsaOpts = {}) {
+    validatePointCons(Point);
     // Custom hash / bits2int hooks are treated as pure functions over validated caller-owned bytes.
@@ -1131,13 +823,20 @@ const hash_ = hash;
     });
-    ecdsaOpts = Object.assign({}, ecdsaOpts);
-    const randomBytes = ecdsaOpts.randomBytes === undefined ? wcRandomBytes : ecdsaOpts.randomBytes;
-    const hmac = ecdsaOpts.hmac === undefined
+    const opts = Object.assign({}, ecdsaOpts);
+    const randomBytes = opts.randomBytes === undefined ? wcRandomBytes : opts.randomBytes;
+    const hmac = opts.hmac === undefined
         ? (key, msg) => nobleHmac(hash_, key, msg)
-        : ecdsaOpts.hmac;
+        : opts.hmac;
     const { Fp, Fn } = Point;
     const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
-    const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);
+    // Nonce-inversion blinding in k2sig draws `getMinHashLength(n)` bytes per sign. Probe the RNG
+    // once (see {@link probeRandomBytes}, shared with ScalarMultiplier): in environments without
+    // working randomness, signing downgrades to Fermat inversion (invertCt) instead of throwing on
+    // every sign(). The shape of returned bytes is still validated (by mapHashToField) on every
+    // blinded call, where breakage fails closed.
+    const blindLength = getMinHashLength(CURVE_ORDER);
+    const csprng = probeRandomBytes(randomBytes, blindLength);
+    const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, opts);
     const defaultSigOpts = {
         prehash: true,
-        lowS: typeof ecdsaOpts.lowS === 'boolean' ? ecdsaOpts.lowS : true,
+        lowS: typeof opts.lowS === 'boolean' ? opts.lowS : true,
         format: 'compact',
@@ -1160,2 +859,12 @@ extraEntropy: false,
     }
+    function assertFieldSignIsSupported() {
+        if (!Fp.isOdd)
+            throw new Error("Field doesn't support isOdd");
+    }
+    // Recovery id of an affine point (x, y) whose x reduces to signature `r` mod n:
+    // bit 0 = y parity, bit 1 = x overflowed the group order (x = r + n).
+    function getRecoveryBit(x, y, r) {
+        assertFieldSignIsSupported();
+        return (x === r ? 0 : 2) | Number(Fp.isOdd(y));
+    }
     function assertRecoverableCurve() {
@@ -1240,3 +949,3 @@ // ECDSA recovery only supports curves where the current recovery id can distinguish
             // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1). unsafe is fine: there is no private data.
-            const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));
+            const Q = Point.BASE.mulAddUnsafe(u1, R, u2);
             if (Q.is0())
@@ -1274,3 +983,3 @@ throw new Error('invalid recovery: point at infinify');
     // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors
-    const bits2int = ecdsaOpts.bits2int === undefined
+    const bits2int = opts.bits2int === undefined
         ? function bits2int_def(bytes) {
@@ -1286,8 +995,8 @@ // Our custom check "just in case", for protection against DoS
         }
-        : ecdsaOpts.bits2int;
-    const bits2int_modN = ecdsaOpts.bits2int_modN === undefined
+        : opts.bits2int;
+    const bits2int_modN = opts.bits2int_modN === undefined
         ? function bits2int_modN_def(bytes) {
             return Fn.create(bits2int(bytes)); // can't use bytesToNumberBE here
         }
-        : ecdsaOpts.bits2int_modN;
+        : opts.bits2int_modN;
     const ORDER_MASK = bitMask(fnBits);
@@ -1337,5 +1046,8 @@ // Pads output with zero as per spec.
         // s = k^-1(m + rd) mod n
-        // Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to
-        // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:
-        // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT
+        // The nonce inversion is blinded: with random b ∈ [1,n−1], s = (bk)^-1(bm + bdr) per
+        // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. Fn.inv()'s extended-Euclidean
+        // loop count depends on its input (cf. Minerva), but here it only ever sees b·k — uniformly
+        // random, independent of k — so its timing reveals nothing about the nonce; b also masks d in
+        // the products. Without a CSPRNG (probed in ecdsa()) we fall back to Fermat inversion
+        // (invertCt), whose control flow is data-independent, at ~4x the inversion cost.
         function k2sig(kBytes) {
@@ -1347,3 +1059,2 @@ // RFC 6979 Section 3.2, step 3: k = bits2int(T)
                 return; // Valid scalars (including k) must be in 1..N-1
-            const ik = Fn.inv(k); // k^-1 mod n
             const q = Point.BASE.multiply(k).toAffine(); // q = k⋅G
@@ -1353,6 +1064,18 @@ const r = Fn.create(q.x); // r = q.x mod n
                 return;
-            const s = Fn.create(ik * Fn.create(m + r * d)); // s = k^-1(m + rd) mod n
+            let s;
+            if (csprng !== undefined) {
+                // mapHashToField maps 1.5x-order-length uniform bytes into [1, n-1], negligible bias.
+                const b = bytesToNumberBE(mapHashToField(csprng(blindLength), CURVE_ORDER));
+                const ibk = Fn.inv(Fn.mul(b, k)); // (bk)^-1: inversion input is decorrelated from k
+                const bm = Fn.mul(b, m);
+                const bd = Fn.mul(b, d);
+                s = Fn.create(ibk * Fn.create(bm + bd * r)); // s = (bk)^-1(bm + bdr) = k^-1(m + rd) mod n
+            }
+            else {
+                const ik = invertCt(k, CURVE_ORDER); // k^-1 mod n with data-independent control flow
+                s = Fn.create(ik * Fn.create(m + r * d)); // s = k^-1(m + rd) mod n
+            }
             if (s === _0n)
                 return;
-            let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3 when q.x>n)
+            let recovery = getRecoveryBit(q.x, q.y, r); // recovery bit (2 or 3 when q.x>n)
             let normS = s;
@@ -1418,7 +1141,14 @@ if (lowS && isBiggerThanHalfOrder(s)) {
             const u2 = Fn.create(r * is); // u2 = rs^-1 mod n
-            const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2)); // u1⋅G + u2⋅P
+            const R = Point.BASE.mulAddUnsafe(u1, P, u2); // u1⋅G + u2⋅P, joint Strauss–Shamir
             if (R.is0())
                 return false;
-            const v = Fn.create(R.x); // v = r.x mod n
-            return v === r;
+            const q = R.toAffine();
+            const v = Fn.create(q.x); // v = R.x mod n
+            if (v !== r)
+                return false;
+            // R is the exact point `recoverPublicKey(r, recid)` reconstructs (sR = hG + rP),
+            // so binding the signature to its recovery id only needs R's parity/overflow bits.
+            if (format === 'recovered' && sig.recovery !== getRecoveryBit(q.x, q.y, r))
+                return false;
+            return true;
         }
@@ -1450,2 +1180,1 @@ catch (e) {
 }
-//# sourceMappingURL=weierstrass.js.map

bls12-381.d.ts

@@ -24,2 +24,1 @@ import { type BlsCurvePairWithSignatures } from './abstract/bls.ts';
 export declare const bls12_381: BlsCurvePairWithSignatures;
-//# sourceMappingURL=bls12-381.d.ts.map

bls12-381.js

@@ -83,7 +83,7 @@ /**
 import { Field } from "./abstract/modular.js";
-import { abytes, bitLen, bitMask, bytesToHex, bytesToNumberBE, concatBytes, copyBytes, hexToBytes, numberToBytesBE, randomBytes, } from "./utils.js";
+import { abytes, bitLen, bytesToHex, concatBytes, copyBytes, hexToBytes, numberToBytesBE, randomBytes, } from "./utils.js";
 // Types
-import { isogenyMap } from "./abstract/hash-to-curve.js";
+import { isogenyMap, mapToCurveSimpleSWU } from "./abstract/hash-to-curve.js";
 import { psiFrobenius, tower12 } from "./abstract/tower.js";
-import { mapToCurveSimpleSWU, weierstrass, } from "./abstract/weierstrass.js";
+import { weierstrass, } from "./abstract/weierstrass.js";
 // Be friendly to bad ECMAScript parsers by not using bigint literals
@@ -131,2 +131,76 @@ // prettier-ignore
 });
+// Karabina's G2345 compression for the cyclotomic subgroup. Noble stores Fp12 as
+// (c0 + c1*w), so (g0, g1, g2, g3, g4, g5) map to (c0.c0, c1.c1, c1.c0, c0.c2, c0.c1, c1.c2).
+function bls12FromCompressed(g0, g1, { g2, g3, g4, g5 }) {
+    return { c0: { c0: g0, c1: g4, c2: g3 }, c1: { c0: g2, c1: g1, c2: g5 } };
+}
+function bls12Compress({ c0, c1 }) {
+    return { g2: c1.c0, g3: c0.c2, g4: c0.c1, g5: c1.c2 };
+}
+function bls12CyclotomicSquareCompressed({ g2, g3, g4, g5 }) {
+    const { first: h23c0, second: h23c1 } = Fp2.Fp4Square(g4, g5);
+    const { first: h45c0, second: h45c1 } = Fp2.Fp4Square(g2, g3);
+    const d2 = Fp2.add(g2, g2);
+    const d3 = Fp2.add(g3, g3);
+    const d4 = Fp2.add(g4, g4);
+    const d5 = Fp2.add(g5, g5);
+    return {
+        g2: Fp2.add(Fp2.mul(Fp2.mulByNonresidue(h23c1), _3n), d2),
+        g3: Fp2.sub(Fp2.mul(h23c0, _3n), d3),
+        g4: Fp2.sub(Fp2.mul(h45c0, _3n), d4),
+        g5: Fp2.add(Fp2.mul(h45c1, _3n), d5),
+    };
+}
+function bls12RecoverG1Ratio({ g2, g3, g4, g5 }) {
+    if (Fp2.is0(g2))
+        return { num: Fp2.mul(Fp2.mul(g4, g5), _2n), den: g3 };
+    return {
+        num: Fp2.add(Fp2.sub(Fp2.mul(Fp2.sqr(g4), _3n), Fp2.mul(g3, _2n)), Fp2.mulByNonresidue(Fp2.sqr(g5))),
+        den: Fp2.mul(g2, _4n),
+    };
+}
+function bls12RecoverG0(g1, { g2, g3, g4, g5 }) {
+    const g3g4 = Fp2.mul(g3, g4);
+    const t = Fp2.add(Fp2.sub(Fp2.mul(Fp2.sub(Fp2.sqr(g1), g3g4), _2n), g3g4), Fp2.mul(g2, g5));
+    return Fp2.add(Fp2.mulByNonresidue(t), Fp2.ONE);
+}
+function bls12CyclotomicExpCompressed(num, squarings) {
+    const gs = [];
+    let g = bls12Compress(num);
+    for (const count of squarings) {
+        for (let i = 0; i < count; i++)
+            g = bls12CyclotomicSquareCompressed(g);
+        gs.push(g);
+    }
+    // Karabina decompression is undefined at g2 = g3 = 0. Every element decompressed here lies in
+    // the cyclotomic subgroup GΦ₁₂, where the only such element is the identity: unitarity
+    // (z⋅z^(p⁶) = 1) forces g4² = ξ⋅g5², so g4 = g5 = 0 because ξ is a non-square in Fp2, leaving
+    // z ∈ Fp4* ∩ GΦ₁₂ — trivial since gcd(p⁴−p²+1, p⁴−1) = gcd(3, p²−2) = 1 for p ≡ 1 mod 3.
+    // Handle the identity explicitly instead of relying on invertBatch's passZero mapping the zero
+    // denominator to 0 (which happens to reconstruct ONE, but only by coincidence of formulas).
+    const isOne = gs.map(({ g2, g3 }) => Fp2.is0(g2) && Fp2.is0(g3));
+    const ratios = gs.map(bls12RecoverG1Ratio);
+    const invDens = Fp2.invertBatch(ratios.map(({ den }) => den));
+    const elems = gs.map((compressed, i) => {
+        if (isOne[i])
+            return Fp12.ONE;
+        const g1 = Fp2.mul(ratios[i].num, invDens[i]);
+        return bls12FromCompressed(bls12RecoverG0(g1, compressed), g1, compressed);
+    });
+    return { result: Fp12.mul(Fp12.mul(elems[0], elems[1]), elems[2]), last: elems[2] };
+}
+function bls12CyclotomicExpX(num) {
+    // BLS_X = 2^63 + 2^62 + 2^60 + 2^57 + 2^48 + 2^16.
+    const { result, last } = bls12CyclotomicExpCompressed(num, [16, 32, 9]);
+    let r = result;
+    let s = last;
+    for (let i = 0; i < 3; i++)
+        s = Fp12._cyclotomicSquare(s);
+    r = Fp12.mul(r, s);
+    for (let i = 0; i < 2; i++)
+        s = Fp12._cyclotomicSquare(s);
+    r = Fp12.mul(r, s);
+    s = Fp12._cyclotomicSquare(s);
+    return Fp12.mul(r, s);
+}
 const { Fp, Fp2, Fp6, Fp12 } = tower12({
@@ -141,4 +215,4 @@ ORDER: bls12_381_CURVE_G1.p,
     Fp2mulByB: ({ c0, c1 }) => {
-        const t0 = Fp.mul(c0, _4n); // 4 * c0
-        const t1 = Fp.mul(c1, _4n); // 4 * c1
+        const t0 = Fp.mul(c0, _4n);
+        const t1 = Fp.mul(c1, _4n);
         // (T0-T1) + (T0+T1)*i
@@ -148,3 +222,3 @@ return { c0: Fp.sub(t0, t1), c1: Fp.add(t0, t1) };
     Fp12finalExponentiate: (num) => {
-        const x = BLS_X;
+        const powMinusX = (num) => Fp12.conjugate(bls12CyclotomicExpX(num));
         // this^(q⁶) / this
@@ -154,8 +228,8 @@ const t0 = Fp12.div(Fp12.frobeniusMap(num, 6), num);
         const t1 = Fp12.mul(Fp12.frobeniusMap(t0, 2), t0);
-        const t2 = Fp12.conjugate(Fp12._cyclotomicExp(t1, x));
+        const t2 = powMinusX(t1);
         const t3 = Fp12.mul(Fp12.conjugate(Fp12._cyclotomicSquare(t1)), t2);
-        const t4 = Fp12.conjugate(Fp12._cyclotomicExp(t3, x));
-        const t5 = Fp12.conjugate(Fp12._cyclotomicExp(t4, x));
-        const t6 = Fp12.mul(Fp12.conjugate(Fp12._cyclotomicExp(t5, x)), Fp12._cyclotomicSquare(t2));
-        const t7 = Fp12.conjugate(Fp12._cyclotomicExp(t6, x));
+        const t4 = powMinusX(t3);
+        const t5 = powMinusX(t4);
+        const t6 = Fp12.mul(powMinusX(t5), Fp12._cyclotomicSquare(t2));
+        const t7 = powMinusX(t6);
         const t2_t5_pow_q2 = Fp12.frobeniusMap(Fp12.mul(t2, t5), 2);
@@ -242,4 +316,4 @@ const t4_t1_pow_q3 = Fp12.frobeniusMap(Fp12.mul(t4, t1), 3);
         return Fp2.create({
-            c0: Fp.create(bytesToNumberBE(bytes.subarray(L))),
-            c1: Fp.create(bytesToNumberBE(bytes.subarray(0, L))),
+            c0: decodeFp(bytes.subarray(L)),
+            c1: decodeFp(bytes.subarray(0, L)),
         });
@@ -249,2 +323,5 @@ },
 const BaseFp = Fp;
+function decodeFp(bytes) {
+    return Fp.fromBytes(bytes);
+}
 // Keep BLS12-381 point/signature codecs on one control-flow skeleton: the G1/G2
@@ -281,4 +358,4 @@ // and point/signature variants differ only in field packing, subgroup bytes, and
             if (infinity) {
-                // Infinity canonicality has to be checked on raw bytes before decode()
-                // reduces coordinates modulo p and turns non-empty payloads into zero.
+                // Infinity has a dedicated encoding: after the flag bits are cleared, every
+                // remaining payload byte must be zero.
                 for (const b of value) {
@@ -302,4 +379,4 @@ if (b)
             }
-            // Noble keeps the permissive coordinate reduction path here, but an
-            // omitted infinity flag must not still decode to ZERO afterwards.
+            // The all-zero uncompressed payload must use the infinity flag instead of
+            // decoding as an ordinary affine point.
             if (!compressed && F.is0(x) && F.is0(y))
@@ -323,3 +400,2 @@ throw new Error(`invalid ${name} point: uncompressed`);
     // Copy, so we can remove mask data.
-    // It will be removed also later, when Fp.create will call modulo.
     bytes = copyBytes(bytes);
@@ -349,3 +425,3 @@ const mask = bytes[0] & 0b1110_0000;
 }
-const g1coder = coder('G1', Fp, Fp.create(bls12_381_CURVE_G1.b), (x) => numberToBytesBE(x, Fp.BYTES), (bytes) => Fp.create(bytesToNumberBE(bytes) & bitMask(Fp.BITS)), (y) => [y]);
+const g1coder = coder('G1', Fp, Fp.create(bls12_381_CURVE_G1.b), (x) => numberToBytesBE(x, Fp.BYTES), decodeFp, (y) => [y]);
 const g1 = { point: g1coder(true), sig: g1coder(false) };
@@ -689,2 +765,1 @@ const signatureG1ToBytes = (point) => {
 }
-//# sourceMappingURL=bls12-381.js.map

bn254.d.ts

@@ -75,2 +75,1 @@ /**
 export declare const bn254: BlsCurvePair;
-//# sourceMappingURL=bn254.d.ts.map

bn254.js

@@ -99,2 +99,33 @@ /**
 let Fp12;
+const bn254CyclotomicExpX = (num) => {
+    const cyclSqrN = (n, count) => {
+        for (let i = 0; i < count; i++)
+            n = Fp12._cyclotomicSquare(n);
+        return n;
+    };
+    // Addition chain for BN_X = 0x44e992b44a6909f1. This keeps the same cyclotomic-square
+    // count as binary exponentiation, but cuts Fp12 multiplications by about a third.
+    const x10 = Fp12._cyclotomicSquare(num);
+    const x100 = Fp12._cyclotomicSquare(x10);
+    const x1000 = Fp12._cyclotomicSquare(x100);
+    const x10000 = Fp12._cyclotomicSquare(x1000);
+    const x10001 = Fp12.mul(x10000, num);
+    const x10011 = Fp12.mul(x10001, x10);
+    const x10100 = Fp12.mul(x10011, num);
+    const x11001 = Fp12.mul(x1000, x10001);
+    const x100010 = Fp12._cyclotomicSquare(x10001);
+    const x100111 = Fp12.mul(x10011, x10100);
+    const x101001 = Fp12.mul(x10, x100111);
+    let r = cyclSqrN(x100010, 6);
+    r = Fp12.mul(Fp12.mul(r, x100), x11001);
+    r = Fp12.mul(cyclSqrN(r, 7), x11001);
+    r = cyclSqrN(r, 8);
+    r = Fp12.mul(Fp12.mul(r, x101001), x10);
+    r = Fp12.mul(cyclSqrN(r, 6), x10001);
+    r = Fp12.mul(cyclSqrN(r, 8), x101001);
+    r = Fp12.mul(cyclSqrN(r, 6), x101001);
+    r = Fp12.mul(cyclSqrN(r, 10), x100111);
+    r = Fp12.mul(Fp12.mul(cyclSqrN(r, 6), x101001), x1000);
+    return r;
+};
 const tower = /* @__PURE__ */ (() => {
@@ -109,3 +140,3 @@ const res = tower12({
         Fp12finalExponentiate: (num) => {
-            const powMinusX = (num) => Fp12.conjugate(Fp12._cyclotomicExp(num, BN_X));
+            const powMinusX = (num) => Fp12.conjugate(bn254CyclotomicExpX(num));
             const r0 = Fp12.mul(Fp12.conjugate(num), Fp12.inv(num));
@@ -247,2 +278,1 @@ const r = Fp12.mul(Fp12.frobeniusMap(r0, 2), r0);
 export const bn254 = /* @__PURE__ */ blsBasic(fields, bn254_G1, bn254_G2, bn254_params);
-//# sourceMappingURL=bn254.js.map

ed25519.d.ts

@@ -83,2 +83,3 @@ import { type AffinePoint } from './abstract/curve.ts';
  * const bob = x25519.keygen();
+ * const alicePublic = x25519.getPublicKey(alice.secretKey);
  * const shared = x25519.getSharedSecret(alice.secretKey, bob.publicKey);
@@ -213,2 +214,1 @@ * ```
 export {};
-//# sourceMappingURL=ed25519.d.ts.map

ed25519.js

@@ -97,2 +97,14 @@ /**
 const Fp = /* @__PURE__ */ (() => ed25519_Point.Fp)();
+function toMontgomery(point) {
+    // Birational map from Ed25519 to Curve25519 / X25519:
+    //   (u, v) = ((1 + y) / (1 - y), sqrt(-486664) * u / x)
+    //   (x, y) = (sqrt(-486664) * u / v, (u - 1) / (u + 1))
+    const { y } = point;
+    return Fp.toBytes(Fp.div(_1n + y, _1n - y));
+}
+function toMontgomerySecret(secretKey) {
+    const size = ed25519_Point.Fp.BYTES;
+    abytes(secretKey, size);
+    return adjustScalarBytes(sha512(secretKey.subarray(0, size))).subarray(0, size);
+}
 const Fn = /* @__PURE__ */ (() => ed25519_Point.Fn)();
@@ -108,3 +120,3 @@ // RFC 8032 `dom2` helper for ctx/ph variants only. Plain Ed25519 keeps the
     // Ed25519 keeps ZIP-215 default verification semantics for consensus compatibility.
-    return eddsa(ed25519_Point, sha512, Object.assign({ adjustScalarBytes, zip215: true }, opts));
+    return eddsa(ed25519_Point, sha512, Object.assign({ adjustScalarBytes, toMontgomery, toMontgomerySecret, zip215: true }, opts));
 }
@@ -198,2 +210,3 @@ /**
  * const bob = x25519.keygen();
+ * const alicePublic = x25519.getPublicKey(alice.secretKey);
  * const shared = x25519.getSharedSecret(alice.secretKey, bob.publicKey);
@@ -204,11 +217,26 @@ * ```
     const P = ed25519_CURVE_p;
+    const powPminus2 = (x) => {
+        // x^(p-2) aka x^(2^255-21)
+        const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);
+        return mod(pow2(pow_p_5_8, _3n, P) * b2, P);
+    };
     return montgomery({
         P,
         type: 'x25519',
-        powPminus2: (x) => {
-            // x^(p-2) aka x^(2^255-21)
-            const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);
-            return mod(pow2(pow_p_5_8, _3n, P) * b2, P);
+        powPminus2,
+        adjustScalarBytes,
+        // ~3x faster fixed-base: [k]B on the birationally-equivalent Edwards curve using cached
+        // base tables, mapped back via u = (1+y)/(1-y) = (Z+Y)/(Z-Y) with one Fermat inversion.
+        // Same construction as libsodium's crypto_scalarmult_curve25519_base.
+        scalarMultBase: (k) => {
+            // Clamped k (≈2^254) exceeds n, but B has prime order n, so [k]B == [k mod n]B.
+            const kn = mod(k, ed25519_Point.Fn.ORDER);
+            // k ≡ 0 (mod n): [k]B is the point at infinity, whose u is 0 in the x-only ladder;
+            // returning 0 makes montgomery() reject it exactly like the ladder path.
+            if (kn === _0n)
+                return _0n;
+            const p = ed25519_Point.BASE.multiply(kn);
+            // Z-Y == 0 only at the identity, which kn != 0 excludes.
+            return mod((p.Z + p.Y) * powPminus2(mod(p.Z - p.Y, P)), P);
         },
-        adjustScalarBytes,
     });
@@ -223,2 +251,3 @@ })();
 const ELL2_C3 = /* @__PURE__ */ (() => Fp.sqrt(Fp.neg(Fp.ONE)))(); // 3. c3 = sqrt(-1)
+const ELL2_J = /* @__PURE__ */ BigInt(486662);
 /**
@@ -230,4 +259,4 @@ * RFC 9380 method `map_to_curve_elligator2_curve25519`. Experimental name: may be renamed later.
 export function _map_to_curve_elligator2_curve25519(u) {
-    const ELL2_C4 = (ed25519_CURVE_p - _5n) / _8n; // 4. c4 = (q - 5) / 8       # Integer arithmetic
-    const ELL2_J = BigInt(486662);
+    // 4. c4 = (q - 5) / 8: tv2^c4 below reuses the ed25519_pow_2_252_3 addition chain,
+    // whose pow_p_5_8 output is exactly x^((p-5)/8).
     let tv1 = Fp.sqr(u); //  1.  tv1 = u^2
@@ -249,3 +278,3 @@ tv1 = Fp.mul(tv1, _2n); //  2.  tv1 = 2 * tv1
     tv2 = Fp.mul(tv2, tv3); //  15. tv2 = tv2 * tv3       # gx1 * gxd^7
-    let y11 = Fp.pow(tv2, ELL2_C4); //  16. y11 = tv2^c4        # (gx1 * gxd^7)^((p - 5) / 8)
+    let y11 = ed25519_pow_2_252_3(tv2).pow_p_5_8; //  16. y11 = tv2^c4  # (gx1 * gxd^7)^((p - 5) / 8)
     y11 = Fp.mul(y11, tv3); //  17. y11 = y11 * tv3       # gx1*gxd^3*(gx1*gxd^7)^((p-5)/8)
@@ -345,12 +374,10 @@ let y12 = Fp.mul(y11, ELL2_C3); //  18. y12 = y11 * c3
     const { d } = ed25519_CURVE;
-    const P = ed25519_CURVE_p;
-    const mod = (n) => Fp.create(n);
-    const r = mod(SQRT_M1 * r0 * r0); // 1
-    const Ns = mod((r + _1n) * ONE_MINUS_D_SQ); // 2
+    const r = Fp.mul(Fp.mulN(SQRT_M1, r0), r0); // 1
+    const Ns = Fp.mul(Fp.addN(r, _1n), ONE_MINUS_D_SQ); // 2
     let c = BigInt(-1); // 3
-    const D = mod((c - d * r) * mod(r + d)); // 4
+    const D = Fp.mul(Fp.subN(c, Fp.mulN(d, r)), Fp.add(r, d)); // 4
     let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D); // 5
-    let s_ = mod(s * r0); // 6
-    if (!isNegativeLE(s_, P))
-        s_ = mod(-s_);
+    let s_ = Fp.mul(s, r0); // 6
+    if (!Fp.isOdd(s_))
+        s_ = Fp.neg(s_);
     if (!Ns_D_is_sq)
@@ -360,9 +387,9 @@ s = s_; // 7
         c = r; // 8
-    const Nt = mod(c * (r - _1n) * D_MINUS_ONE_SQ - D); // 9
-    const s2 = s * s;
-    const W0 = mod((s + s) * D); // 10
-    const W1 = mod(Nt * SQRT_AD_MINUS_ONE); // 11
-    const W2 = mod(_1n - s2); // 12
-    const W3 = mod(_1n + s2); // 13
-    return new ed25519_Point(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));
+    const Nt = Fp.sub(Fp.mulN(Fp.mulN(c, Fp.subN(r, _1n)), D_MINUS_ONE_SQ), D); // 9
+    const s2 = Fp.sqrN(s);
+    const W0 = Fp.mul(Fp.addN(s, s), D); // 10
+    const W1 = Fp.mul(Nt, SQRT_AD_MINUS_ONE); // 11
+    const W2 = Fp.sub(_1n, s2); // 12
+    const W3 = Fp.add(_1n, s2); // 13
+    return new ed25519_Point(Fp.mul(W0, W3), Fp.mul(W2, W1), Fp.mul(W1, W3), Fp.mul(W0, W2));
 }
@@ -415,26 +442,24 @@ /**
         const { a, d } = ed25519_CURVE;
-        const P = ed25519_CURVE_p;
-        const mod = (n) => Fp.create(n);
         const s = bytes255ToNumberLE(bytes);
         // 1. Check that s_bytes is the canonical encoding of a field element, or else abort.
         // 3. Check that s is non-negative, or else abort
-        if (!equalBytes(Fp.toBytes(s), bytes) || isNegativeLE(s, P))
+        if (!equalBytes(Fp.toBytes(s), bytes) || Fp.isOdd(s))
             throw new Error('invalid ristretto255 encoding 1');
-        const s2 = mod(s * s);
-        const u1 = mod(_1n + a * s2); // 4 (a is -1)
-        const u2 = mod(_1n - a * s2); // 5
-        const u1_2 = mod(u1 * u1);
-        const u2_2 = mod(u2 * u2);
-        const v = mod(a * d * u1_2 - u2_2); // 6
-        const { isValid, value: I } = invertSqrt(mod(v * u2_2)); // 7
-        const Dx = mod(I * u2); // 8
-        const Dy = mod(I * Dx * v); // 9
-        let x = mod((s + s) * Dx); // 10
-        if (isNegativeLE(x, P))
-            x = mod(-x); // 10
-        const y = mod(u1 * Dy); // 11
-        const t = mod(x * y); // 12
-        if (!isValid || isNegativeLE(t, P) || y === _0n)
+        const s2 = Fp.sqr(s);
+        const u1 = Fp.add(_1n, Fp.mulN(a, s2)); // 4 (a is -1)
+        const u2 = Fp.sub(_1n, Fp.mulN(a, s2)); // 5
+        const u1_2 = Fp.sqr(u1);
+        const u2_2 = Fp.sqr(u2);
+        const v = Fp.sub(Fp.mulN(Fp.mulN(a, d), u1_2), u2_2); // 6
+        const { isValid, value: I } = invertSqrt(Fp.mul(v, u2_2)); // 7
+        const Dx = Fp.mul(I, u2); // 8
+        const Dy = Fp.mul(Fp.mulN(I, Dx), v); // 9
+        let x = Fp.mul(Fp.addN(s, s), Dx); // 10
+        if (Fp.isOdd(x))
+            x = Fp.neg(x); // 10
+        const y = Fp.mul(u1, Dy); // 11
+        const t = Fp.mul(x, y); // 12
+        if (!isValid || Fp.isOdd(t) || Fp.is0(y))
             throw new Error('invalid ristretto255 encoding 2');
-        return new _RistrettoPoint(new ed25519_Point(x, y, _1n, t));
+        return new _RistrettoPoint(new ed25519_Point(x, y, Fp.ONE, t));
     }
@@ -455,19 +480,17 @@ /**
         let { X, Y, Z, T } = this.ep;
-        const P = ed25519_CURVE_p;
-        const mod = (n) => Fp.create(n);
-        const u1 = mod(mod(Z + Y) * mod(Z - Y)); // 1
-        const u2 = mod(X * Y); // 2
+        const u1 = Fp.mul(Fp.add(Z, Y), Fp.sub(Z, Y)); // 1
+        const u2 = Fp.mul(X, Y); // 2
         // Square root always exists
-        const u2sq = mod(u2 * u2);
-        const { value: invsqrt } = invertSqrt(mod(u1 * u2sq)); // 3
-        const D1 = mod(invsqrt * u1); // 4
-        const D2 = mod(invsqrt * u2); // 5
-        const zInv = mod(D1 * D2 * T); // 6
+        const u2sq = Fp.sqr(u2);
+        const { value: invsqrt } = invertSqrt(Fp.mul(u1, u2sq)); // 3
+        const D1 = Fp.mul(invsqrt, u1); // 4
+        const D2 = Fp.mul(invsqrt, u2); // 5
+        const zInv = Fp.mul(Fp.mulN(D1, D2), T); // 6
         let D; // 7
-        if (isNegativeLE(T * zInv, P)) {
-            let _x = mod(Y * SQRT_M1);
-            let _y = mod(X * SQRT_M1);
+        if (Fp.isOdd(Fp.mul(T, zInv))) {
+            let _x = Fp.mul(Y, SQRT_M1);
+            let _y = Fp.mul(X, SQRT_M1);
             X = _x;
             Y = _y;
-            D = mod(D1 * INVSQRT_A_MINUS_D);
+            D = Fp.mul(D1, INVSQRT_A_MINUS_D);
         }
@@ -477,7 +500,7 @@ else {
         }
-        if (isNegativeLE(X * zInv, P))
-            Y = mod(-Y); // 9
-        let s = mod((Z - Y) * D); // 10 (check footer's note, no sqrt(-a))
-        if (isNegativeLE(s, P))
-            s = mod(-s);
+        if (Fp.isOdd(Fp.mul(X, zInv)))
+            Y = Fp.neg(Y); // 9
+        let s = Fp.mul(Fp.subN(Z, Y), D); // 10 (check footer's note, no sqrt(-a))
+        if (Fp.isOdd(s))
+            s = Fp.neg(s);
         return Fp.toBytes(s); // 11
@@ -493,6 +516,5 @@ }
         const { X: X2, Y: Y2 } = other.ep;
-        const mod = (n) => Fp.create(n);
         // (x1 * y2 == y1 * x2) | (y1 * y2 == x1 * x2)
-        const one = mod(X1 * Y2) === mod(Y1 * X2);
-        const two = mod(Y1 * Y2) === mod(X1 * X2);
+        const one = Fp.eql(Fp.mul(X1, Y2), Fp.mul(Y1, X2));
+        const two = Fp.eql(Fp.mul(Y1, Y2), Fp.mul(X1, X2));
         return one || two;
@@ -504,8 +526,10 @@ }
 }
-Object.freeze(_RistrettoPoint.BASE);
-Object.freeze(_RistrettoPoint.ZERO);
-Object.freeze(_RistrettoPoint.prototype);
-Object.freeze(_RistrettoPoint);
 /** Prime-order Ristretto255 group bundle. */
-export const ristretto255 = /* @__PURE__ */ Object.freeze({ Point: _RistrettoPoint });
+export const ristretto255 = /* @__PURE__ */ (() => {
+    Object.freeze(_RistrettoPoint.BASE);
+    Object.freeze(_RistrettoPoint.ZERO);
+    Object.freeze(_RistrettoPoint.prototype);
+    Object.freeze(_RistrettoPoint);
+    return Object.freeze({ Point: _RistrettoPoint });
+})();
 /**
@@ -523,18 +547,19 @@ * Hashing to ristretto255 points / field. RFC 9380 methods.
  */
-export const ristretto255_hasher = Object.freeze({
+export const ristretto255_hasher = 
+/* @__PURE__ */ Object.freeze({
     Point: _RistrettoPoint,
     /**
-    * Spec: https://www.rfc-editor.org/rfc/rfc9380.html#name-hashing-to-ristretto255. Caveats:
-    * * There are no test vectors
-    * * encodeToCurve / mapToCurve is undefined
-    * * mapToCurve would be `calcElligatorRistrettoMap(scalars[0])`, not ristretto255_map!
-    * * hashToScalar is undefined too, so we just use OPRF implementation
-    * * We cannot re-use 'createHasher', because ristretto255_map is different algorithm/RFC
-      (os2ip -> bytes255ToNumberLE)
-    * * mapToCurve == calcElligatorRistrettoMap, hashToCurve == ristretto255_map
-    * * hashToScalar is undefined in RFC9380 for ristretto, so we use the OPRF
-      version here. Using `bytes255ToNumblerLE` will create a different result
-      if we use `bytes255ToNumberLE` as os2ip
-    * * current version is closest to spec.
-    */
+  * Spec: https://www.rfc-editor.org/rfc/rfc9380.html#name-hashing-to-ristretto255. Caveats:
+  * * There are no test vectors
+  * * encodeToCurve / mapToCurve is undefined
+  * * mapToCurve would be `calcElligatorRistrettoMap(scalars[0])`, not ristretto255_map!
+  * * hashToScalar is undefined too, so we just use OPRF implementation
+  * * We cannot re-use 'createHasher', because ristretto255_map is different algorithm/RFC
+    (os2ip -> bytes255ToNumberLE)
+  * * mapToCurve == calcElligatorRistrettoMap, hashToCurve == ristretto255_map
+  * * hashToScalar is undefined in RFC9380 for ristretto, so we use the OPRF
+    version here. Using `bytes255ToNumblerLE` will create a different result
+    if we use `bytes255ToNumberLE` as os2ip
+  * * current version is closest to spec.
+  */
     hashToCurve(msg, options) {
@@ -551,4 +576,5 @@ // == 'hash_to_ristretto255'
     },
-    hashToScalar(msg, options = { DST: _DST_scalar }) {
-        const xmd = expand_message_xmd(msg, options.DST, 64, sha512);
+    hashToScalar(msg, options) {
+        const DST = options?.DST === undefined ? _DST_scalar : options.DST;
+        const xmd = expand_message_xmd(msg, DST, 64, sha512);
         return Fn.create(bytesToNumberLE(xmd));
@@ -640,2 +666,1 @@ },
 ]);
-//# sourceMappingURL=ed25519.js.map

ed448.d.ts

@@ -49,6 +49,8 @@ import type { AffinePoint } from './abstract/curve.ts';
  * @example
- * Multiply the E448 base point.
+ * Reconstruct and validate the E448 base point from its projective coordinates.
  *
  * ```ts
- * const point = E448.BASE.multiply(2n);
+ * import { E448 } from '@noble/curves/ed448.js';
+ * const point = new E448(E448.BASE.X, E448.BASE.Y, E448.BASE.Z, E448.BASE.T);
+ * point.assertValidity();
  * ```
@@ -175,3 +177,3 @@ */
  * Instead, the torsion subgroup here is cyclic of order 4, generated by
- * `(1, 0)`, and the array below lists that subgroup set (Klein four-group).
+ * `(1, 0)`, and the array below lists that subgroup set.
  * @example
@@ -187,2 +189,1 @@ * Decode one known torsion point for debugging.
 export {};
-//# sourceMappingURL=ed448.d.ts.map

ed448.js

@@ -15,3 +15,3 @@ /**
 import { _DST_scalar, createHasher, expand_message_xof, } from "./abstract/hash-to-curve.js";
-import { Field, FpInvertBatch, isNegativeLE, mod, pow2 } from "./abstract/modular.js";
+import { Field, FpInvertBatch, mod, pow2 } from "./abstract/modular.js";
 import { montgomery } from "./abstract/montgomery.js";
@@ -52,3 +52,3 @@ import { createOPRF } from "./abstract/oprf.js";
 // prettier-ignore
-const _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4), _11n = /* @__PURE__ */ BigInt(11);
+const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4), _11n = /* @__PURE__ */ BigInt(11);
 // prettier-ignore
@@ -123,2 +123,16 @@ const _22n = /* @__PURE__ */ BigInt(22), _44n = /* @__PURE__ */ BigInt(44), _88n = /* @__PURE__ */ BigInt(88), _223n = /* @__PURE__ */ BigInt(223);
 const Fn448 = /* @__PURE__ */ (() => Field(ed448_CURVE.n, { BITS: 448, isLE: true }))();
+function toMontgomery(point) {
+    // RFC 7748 section 4.2 maps Ed448-Goldilocks to Curve448 via a 4-isogeny.
+    // The u-coordinate map is:
+    //   u = y^2 / x^2
+    // In projective coordinates this is:
+    //   u = Y^2 / X^2
+    const u = Fp.div(Fp.mul(point.Y, point.Y), Fp.mul(point.X, point.X));
+    return Fp448.toBytes(u);
+}
+function toMontgomerySecret(secretKey) {
+    const size = ed448_Point.Fp.BYTES;
+    abytes(secretKey, size);
+    return adjustScalarBytes(shake256_114(secretKey.subarray(0, size))).subarray(0, 56);
+}
 // SHAKE256(dom4(phflag,context)||x, 114)
@@ -136,3 +150,3 @@ // RFC 8032 `dom4` prefix. Empty contexts are valid; the accepted length range
 function ed4(opts) {
-    return eddsa(ed448_Point, shake256_114, Object.assign({ adjustScalarBytes, domain: dom4 }, opts));
+    return eddsa(ed448_Point, shake256_114, Object.assign({ adjustScalarBytes, domain: dom4, toMontgomery, toMontgomerySecret }, opts));
 }
@@ -180,9 +194,11 @@ /**
  * @example
- * Multiply the E448 base point.
+ * Reconstruct and validate the E448 base point from its projective coordinates.
  *
  * ```ts
- * const point = E448.BASE.multiply(2n);
+ * import { E448 } from '@noble/curves/ed448.js';
+ * const point = new E448(E448.BASE.X, E448.BASE.Y, E448.BASE.Z, E448.BASE.T);
+ * point.assertValidity();
  * ```
  */
-export const E448 = /* @__PURE__ */ edwards(E448_CURVE);
+export const E448 = /* @__PURE__ */ edwards(E448_CURVE, { Fp, Fn });
 /**
@@ -205,16 +221,32 @@ * ECDH using curve448 aka x448.
     const P = ed448_CURVE_p;
+    const powPminus2 = (x) => {
+        const Pminus3div4 = ed448_pow_Pminus3div4(x);
+        const Pminus3 = pow2(Pminus3div4, _2n, P);
+        return mod(Pminus3 * x, P); // Pminus3 * x = Pminus2
+    };
     return montgomery({
         P,
         type: 'x448',
-        powPminus2: (x) => {
-            const Pminus3div4 = ed448_pow_Pminus3div4(x);
-            const Pminus3 = pow2(Pminus3div4, _2n, P);
-            return mod(Pminus3 * x, P); // Pminus3 * x = Pminus2
+        powPminus2,
+        adjustScalarBytes,
+        // ~3x faster fixed-base: [k]B on Ed448-Goldilocks using cached base tables, mapped back
+        // through the 4-isogeny to curve448: u = y²/x² = Y²/X² (the isogeny is a homomorphism and
+        // sends the Ed448 base point to u=5, so no scalar correction factor is needed).
+        scalarMultBase: (k) => {
+            // Clamped k (≈2^447) exceeds n, but B has prime order n, so [k]B == [k mod n]B.
+            const kn = mod(k, ed448_Point.Fn.ORDER);
+            // k ≡ 0 (mod n): [k]B is the point at infinity, whose u is 0 in the x-only ladder;
+            // returning 0 makes montgomery() reject it exactly like the ladder path.
+            if (kn === _0n)
+                return _0n;
+            const p = ed448_Point.BASE.multiply(kn);
+            // X == 0 only at the identity and the order-2 point, both excluded from the prime-order
+            // subgroup hit by kn in 1..n-1.
+            return mod(p.Y * p.Y * powPminus2(mod(p.X * p.X, P)), P);
         },
-        adjustScalarBytes,
     });
 })();
 // Hash To Curve Elligator2 Map
-// 1. c1 = (q - 3) / 4 # Integer arithmetic
-const ELL2_C1 = /* @__PURE__ */ (() => (ed448_CURVE_p - BigInt(3)) / BigInt(4))();
+// 1. c1 = (q - 3) / 4 # Integer arithmetic — tv3^c1 below reuses the
+// ed448_pow_Pminus3div4 addition chain, which computes exactly x^((p-3)/4).
 const ELL2_J = /* @__PURE__ */ BigInt(156326);
@@ -238,3 +270,3 @@ // Returns RFC 9380 Appendix G.2.3 rational Montgomery numerators/denominators
     tv3 = Fp.mul(tv3, tv2); // 14. tv3 = tv3 * tv2         # gx1 * gxd^3
-    let y1 = Fp.pow(tv3, ELL2_C1); // 15.  y1 = tv3^c1            # (gx1 * gxd^3)^((p - 3) / 4)
+    let y1 = ed448_pow_Pminus3div4(tv3); // 15.  y1 = tv3^c1      # (gx1 * gxd^3)^((p - 3) / 4)
     y1 = Fp.mul(y1, tv2); // 16.  y1 = y1 * tv2          # gx1 * gxd * (gx1 * gxd^3)^((p - 3) / 4)
@@ -357,5 +389,4 @@ // 17. x2n = -tv1 * x1n # x2 = x2n / xd = -1 * u^2 * x1n / xd
 const sqrtRatioM1 = (u, v) => {
-    const P = ed448_CURVE_p;
     const { isValid, value } = uvRatio(u, v);
-    return { isValid, value: isNegativeLE(value, P) ? Fp448.create(-value) : value };
+    return { isValid, value: Fp448.isOdd(value) ? Fp448.neg(value) : value };
 };
@@ -370,24 +401,23 @@ const invertSqrt = (number) => sqrtRatioM1(_1n, number);
 function calcElligatorDecafMap(r0) {
-    const { d, p: P } = ed448_CURVE;
-    const mod = (n) => Fp448.create(n);
-    const r = mod(-(r0 * r0)); // 1
-    const u0 = mod(d * (r - _1n)); // 2
-    const u1 = mod((u0 + _1n) * (u0 - r)); // 3
-    const { isValid: was_square, value: v } = sqrtRatioM1(ONE_MINUS_TWO_D, mod((r + _1n) * u1)); // 4
+    const { d } = ed448_CURVE;
+    const r = Fp448.create(-Fp448.sqrN(r0)); // 1
+    const u0 = Fp448.mul(d, Fp448.subN(r, _1n)); // 2
+    const u1 = Fp448.mul(Fp448.addN(u0, _1n), Fp448.subN(u0, r)); // 3
+    const { isValid: was_square, value: v } = sqrtRatioM1(ONE_MINUS_TWO_D, Fp448.mul(Fp448.addN(r, _1n), u1)); // 4
     let v_prime = v; // 5
     if (!was_square)
-        v_prime = mod(r0 * v);
+        v_prime = Fp448.mul(r0, v);
     let sgn = _1n; // 6
     if (!was_square)
-        sgn = mod(-_1n);
-    const s = mod(v_prime * (r + _1n)); // 7
+        sgn = Fp448.neg(Fp448.ONE);
+    const s = Fp448.mul(v_prime, Fp448.addN(r, _1n)); // 7
     let s_abs = s;
-    if (isNegativeLE(s, P))
-        s_abs = mod(-s);
-    const s2 = s * s;
-    const W0 = mod(s_abs * _2n); // 8
-    const W1 = mod(s2 + _1n); // 9
-    const W2 = mod(s2 - _1n); // 10
-    const W3 = mod(v_prime * s * (r - _1n) * ONE_MINUS_TWO_D + sgn); // 11
-    return new ed448_Point(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));
+    if (Fp448.isOdd(s))
+        s_abs = Fp448.neg(s);
+    const s2 = Fp448.sqrN(s);
+    const W0 = Fp448.mul(s_abs, _2n); // 8
+    const W1 = Fp448.add(s2, _1n); // 9
+    const W2 = Fp448.sub(s2, _1n); // 10
+    const W3 = Fp448.add(Fp448.mulN(Fp448.mulN(Fp448.mulN(v_prime, s), Fp448.subN(r, _1n)), ONE_MINUS_TWO_D), sgn); // 11
+    return new ed448_Point(Fp448.mul(W0, W3), Fp448.mul(W2, W1), Fp448.mul(W1, W3), Fp448.mul(W0, W2));
 }
@@ -442,23 +472,22 @@ // Keep the Decaf448 base representative literal here: deriving it with
         abytes(bytes, 56);
-        const { d, p: P } = ed448_CURVE;
-        const mod = (n) => Fp448.create(n);
+        const { d } = ed448_CURVE;
         const s = Fp448.fromBytes(bytes);
         // 1. Check that s_bytes is the canonical encoding of a field element, or else abort.
         // 2. Check that s is non-negative, or else abort
-        if (!equalBytes(Fn448.toBytes(s), bytes) || isNegativeLE(s, P))
+        if (!equalBytes(Fp448.toBytes(s), bytes) || Fp448.isOdd(s))
             throw new Error('invalid decaf448 encoding 1');
-        const s2 = mod(s * s); // 1
-        const u1 = mod(_1n + s2); // 2
-        const u1sq = mod(u1 * u1);
-        const u2 = mod(u1sq - _4n * d * s2); // 3
-        const { isValid, value: invsqrt } = invertSqrt(mod(u2 * u1sq)); // 4
-        let u3 = mod((s + s) * invsqrt * u1 * SQRT_MINUS_D); // 5
-        if (isNegativeLE(u3, P))
-            u3 = mod(-u3);
-        const x = mod(u3 * invsqrt * u2 * INVSQRT_MINUS_D); // 6
-        const y = mod((_1n - s2) * invsqrt * u1); // 7
-        const t = mod(x * y); // 8
+        const s2 = Fp448.sqr(s); // 1
+        const u1 = Fp448.add(Fp448.ONE, s2); // 2
+        const u1sq = Fp448.sqr(u1);
+        const u2 = Fp448.sub(u1sq, Fp448.mulN(Fp448.mulN(_4n, d), s2)); // 3
+        const { isValid, value: invsqrt } = invertSqrt(Fp448.mul(u2, u1sq)); // 4
+        let u3 = Fp448.mul(Fp448.mulN(Fp448.mulN(Fp448.addN(s, s), invsqrt), u1), SQRT_MINUS_D); // 5
+        if (Fp448.isOdd(u3))
+            u3 = Fp448.neg(u3);
+        const x = Fp448.mul(Fp448.mulN(Fp448.mulN(u3, invsqrt), u2), INVSQRT_MINUS_D); // 6
+        const y = Fp448.mul(Fp448.mulN(Fp448.subN(_1n, s2), invsqrt), u1); // 7
+        const t = Fp448.mul(x, y); // 8
         if (!isValid)
             throw new Error('invalid decaf448 encoding 2');
-        return new _DecafPoint(new ed448_Point(x, y, _1n, t));
+        return new _DecafPoint(new ed448_Point(x, y, Fp448.ONE, t));
     }
@@ -479,15 +508,13 @@ /**
         const { X, Z, T } = this.ep;
-        const P = ed448_CURVE.p;
-        const mod = (n) => Fp448.create(n);
-        const u1 = mod(mod(X + T) * mod(X - T)); // 1
-        const x2 = mod(X * X);
-        const { value: invsqrt } = invertSqrt(mod(u1 * ONE_MINUS_D * x2)); // 2
-        let ratio = mod(invsqrt * u1 * SQRT_MINUS_D); // 3
-        if (isNegativeLE(ratio, P))
-            ratio = mod(-ratio);
-        const u2 = mod(INVSQRT_MINUS_D * ratio * Z - T); // 4
-        let s = mod(ONE_MINUS_D * invsqrt * X * u2); // 5
-        if (isNegativeLE(s, P))
-            s = mod(-s);
-        return Fn448.toBytes(s);
+        const u1 = Fp448.mul(Fp448.add(X, T), Fp448.sub(X, T)); // 1
+        const x2 = Fp448.sqr(X);
+        const { value: invsqrt } = invertSqrt(Fp448.mul(Fp448.mulN(u1, ONE_MINUS_D), x2)); // 2
+        let ratio = Fp448.mul(Fp448.mulN(invsqrt, u1), SQRT_MINUS_D); // 3
+        if (Fp448.isOdd(ratio))
+            ratio = Fp448.neg(ratio);
+        const u2 = Fp448.sub(Fp448.mulN(Fp448.mulN(INVSQRT_MINUS_D, ratio), Z), T); // 4
+        let s = Fp448.mul(Fp448.mulN(Fp448.mulN(ONE_MINUS_D, invsqrt), X), u2); // 5
+        if (Fp448.isOdd(s))
+            s = Fp448.neg(s);
+        return Fp448.toBytes(s);
     }
@@ -503,3 +530,3 @@ /**
         // (x1 * y2 == y1 * x2)
-        return Fp448.create(X1 * Y2) === Fp448.create(Y1 * X2);
+        return Fp448.eql(Fp448.mul(X1, Y2), Fp448.mul(Y1, X2));
     }
@@ -510,8 +537,10 @@ is0() {
 }
-Object.freeze(_DecafPoint.BASE);
-Object.freeze(_DecafPoint.ZERO);
-Object.freeze(_DecafPoint.prototype);
-Object.freeze(_DecafPoint);
 /** Prime-order Decaf448 group bundle. */
-export const decaf448 = /* @__PURE__ */ Object.freeze({ Point: _DecafPoint });
+export const decaf448 = /* @__PURE__ */ (() => {
+    Object.freeze(_DecafPoint.BASE);
+    Object.freeze(_DecafPoint.ZERO);
+    Object.freeze(_DecafPoint.prototype);
+    Object.freeze(_DecafPoint);
+    return Object.freeze({ Point: _DecafPoint });
+})();
 /**
@@ -529,3 +558,3 @@ * Hashing to decaf448 points / field. RFC 9380 methods.
  */
-export const decaf448_hasher = Object.freeze({
+export const decaf448_hasher = /* @__PURE__ */ Object.freeze({
     Point: _DecafPoint,
@@ -542,5 +571,6 @@ hashToCurve(msg, options) {
      */
-    hashToScalar(msg, options = { DST: _DST_scalar }) {
+    hashToScalar(msg, options) {
+        const DST = options?.DST === undefined ? _DST_scalar : options.DST;
         // Can't use `Fn448.fromBytes()`. 64-byte input => 56-byte field element
-        const xof = expand_message_xof(msg, options.DST, 64, 256, shake256);
+        const xof = expand_message_xof(msg, DST, 64, 256, shake256);
         return Fn448.create(bytesToNumberLE(xof));
@@ -594,3 +624,3 @@ },
  * Instead, the torsion subgroup here is cyclic of order 4, generated by
- * `(1, 0)`, and the array below lists that subgroup set (Klein four-group).
+ * `(1, 0)`, and the array below lists that subgroup set.
  * @example
@@ -610,2 +640,1 @@ * Decode one known torsion point for debugging.
 ]);
-//# sourceMappingURL=ed448.js.map

index.d.ts

 export {};
-//# sourceMappingURL=index.d.ts.map

index.js

@@ -39,2 +39,1 @@ /**
 export {};
-//# sourceMappingURL=index.js.map

misc.d.ts

@@ -114,2 +114,1 @@ import { type EdDSA, type EdwardsPoint } from './abstract/edwards.ts';
 export declare const brainpoolP512r1: ECDSA;
-//# sourceMappingURL=misc.d.ts.map

misc.js

@@ -104,4 +104,5 @@ /**
     let p = jubjub.Point.fromBytes(h.digest());
-    // NOTE: cannot replace with isSmallOrder, returns Point*8
-    p = p.multiply(jubjub_CURVE.h);
+    // NOTE: cannot replace with isSmallOrder, we need the Point*8 result itself.
+    // clearCofactor (three doublings for h=8) is fine here: inputs are public.
+    p = p.clearCofactor();
     if (p.equals(jubjub.Point.ZERO))
@@ -135,13 +136,12 @@ throw new Error('Point has small order');
     const tag = concatBytes(m, Uint8Array.of(0));
-    const hashes = [];
+    // Return the first tag byte whose hash decodes to a non-small-order point; later candidates
+    // were never used, so there is no reason to compute them.
     for (let i = 0; i < 256; i++) {
         tag[tag.length - 1] = i;
         try {
-            hashes.push(jubjub_groupHash(tag, personalization));
+            return jubjub_groupHash(tag, personalization);
         }
         catch (e) { }
     }
-    if (!hashes.length)
-        throw new Error('findGroupHash tag overflow');
-    return hashes[0];
+    throw new Error('findGroupHash tag overflow');
 }
@@ -214,2 +214,1 @@ const brainpoolP256r1_CURVE = /* @__PURE__ */ (() => ({
 export const brainpoolP512r1 = /* @__PURE__ */ (() => ecdsa(weierstrass(brainpoolP512r1_CURVE), sha512))();
-//# sourceMappingURL=misc.js.map

nist.d.ts

@@ -16,5 +16,7 @@ import { type FROST } from './abstract/frost.ts';
  * const { secretKey, publicKey } = p256.keygen();
- * // const publicKey = p256.getPublicKey(secretKey);
+ * const recovered = p256.getPublicKey(secretKey);
+ * const peer = p256.keygen();
+ * const shared = p256.getSharedSecret(secretKey, peer.publicKey);
  * const msg = new TextEncoder().encode('hello noble');
- * const sig = p256.sign(msg, secretKey);
+ * const sig = p256.sign(msg, secretKey, { lowS: true, prehash: true });
  * const isValid = p256.verify(sig, msg, publicKey);
@@ -138,2 +140,1 @@ * // const sigKeccak = p256.sign(keccak256(msg), secretKey, { prehash: false });
 export declare const p521_oprf: TRet<OPRF>;
-//# sourceMappingURL=nist.d.ts.map

nist.js

 /**
- * Internal module for NIST P256, P384, P521 curves.
- * Do not use for now.
+ * NIST P256, P384, P521 curves.
+ * https://www.secg.org/sec2-v2.pdf, https://neuromancer.sk/std/nist/P-256
  * @module
@@ -9,5 +9,5 @@ */
 import { createFROST } from "./abstract/frost.js";
-import { createHasher } from "./abstract/hash-to-curve.js";
+import { createHasher, mapToCurveSimpleSWU } from "./abstract/hash-to-curve.js";
 import { createOPRF } from "./abstract/oprf.js";
-import { ecdsa, mapToCurveSimpleSWU, weierstrass, } from "./abstract/weierstrass.js";
+import { ecdsa, weierstrass, } from "./abstract/weierstrass.js";
 import {} from "./utils.js";
@@ -64,5 +64,7 @@ // p = 2n**224n * (2n**32n-1n) + 2n**192n + 2n**96n - 1n
  * const { secretKey, publicKey } = p256.keygen();
- * // const publicKey = p256.getPublicKey(secretKey);
+ * const recovered = p256.getPublicKey(secretKey);
+ * const peer = p256.keygen();
+ * const shared = p256.getSharedSecret(secretKey, peer.publicKey);
  * const msg = new TextEncoder().encode('hello noble');
- * const sig = p256.sign(msg, secretKey);
+ * const sig = p256.sign(msg, secretKey, { lowS: true, prehash: true });
  * const isValid = p256.verify(sig, msg, publicKey);
@@ -86,3 +88,3 @@ * // const sigKeccak = p256.sign(keccak256(msg), secretKey, { prehash: false });
         B: p256_CURVE.b,
-        Z: p256_Point.Fp.create(BigInt('-10')),
+        Z: p256_Point.Fp.neg(BigInt(10)),
     }), {
@@ -136,3 +138,2 @@ DST: 'P256_XMD:SHA-256_SSWU_RO_',
 }))();
-// NIST P384
 const p384_Point = /* @__PURE__ */ weierstrass(p384_CURVE);
@@ -165,3 +166,3 @@ /**
         B: p384_CURVE.b,
-        Z: p384_Point.Fp.create(BigInt('-12')),
+        Z: p384_Point.Fp.neg(BigInt(12)),
     }), {
@@ -213,2 +214,4 @@ DST: 'P384_XMD:SHA-384_SSWU_RO_',
 // default exact-66-byte scalar field path.
+// A dedicated MersenneField primitive would allow speed-ups here: +40% getPublicKey, +23% sign,
+// +53% verify, +53% getSharedSecret.
 const p521_Point = /* @__PURE__ */ weierstrass(p521_CURVE);
@@ -243,3 +246,3 @@ /**
         B: p521_CURVE.b,
-        Z: p521_Point.Fp.create(BigInt('-4')),
+        Z: p521_Point.Fp.neg(BigInt(4)),
     }), {
@@ -275,2 +278,1 @@ DST: 'P521_XMD:SHA-512_SSWU_RO_',
 }))();
-//# sourceMappingURL=nist.js.map

package.json

 {
   "name": "@noble/curves",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Audited & minimal JS implementation of elliptic curve cryptography",
   "files": [
     "*.js",
-    "*.js.map",
     "*.d.ts",
-    "*.d.ts.map",
     "abstract",
@@ -14,6 +12,6 @@ "src"
   "dependencies": {
-    "@noble/hashes": "2.2.0"
+    "@noble/hashes": "2.3.0"
   },
   "devDependencies": {
-    "@paulmillr/jsbt": "0.5.0",
+    "@paulmillr/jsbt": "0.6.5",
     "@types/node": "25.3.0",
@@ -25,17 +23,11 @@ "fast-check": "4.2.0",
   "scripts": {
-    "bench": "cd test/benchmark; node secp256k1.ts; node curves.ts; node utils.ts; node bls.ts",
-    "bench:install": "cd test/benchmark; npm install; npm install ../.. --install-links",
+    "benchmark": "node benchmark/main.ts",
+    "benchmark:ct": "node benchmark/ct.ts",
     "build": "tsc",
-    "build:release": "npx --no @paulmillr/jsbt esbuild test/build",
-    "check": "npm run check:readme && npm run check:treeshake && npm run check:jsdoc",
-    "check:readme": "npx --no @paulmillr/jsbt readme package.json",
-    "check:treeshake": "npx --no @paulmillr/jsbt treeshake package.json test/build/out-treeshake",
-    "check:jsdoc": "npx --no @paulmillr/jsbt tsdoc package.json",
-    "build:clean": "rm {.,abstract}/*.{js,d.ts,d.ts.map,js.map} 2> /dev/null",
+    "build:clean": "rm {.,abstract}/*.{js,d.ts} 2> /dev/null",
+    "check": "jsbt-check",
     "format": "prettier --write 'src/**/*.{js,ts}' 'test/*.{js,ts}'",
-    "test": "node test/index.ts",
-    "test:bun": "bun test/index.ts",
+    "test": "node --no-warnings test/index.ts",
     "test:deno": "deno --allow-env --allow-read test/index.ts",
-    "test:node20": "cd test; npx tsc; node compiled/test/index.js",
-    "test:coverage": "npm install --no-save c8@10.1.2 && npx c8 npm test"
+    "test:bun": "bun test/index.ts"
   },
@@ -46,2 +38,3 @@ "exports": {
     "./abstract/curve.js": "./abstract/curve.js",
+    "./abstract/der.js": "./abstract/der.js",
     "./abstract/edwards.js": "./abstract/edwards.js",
@@ -48,0 +41,0 @@ "./abstract/fft.js": "./abstract/fft.js",

README.md

@@ -6,10 +6,9 @@ # noble-curves
 - 🔒 [**Audited**](#security) by independent security firms
-- 🔻 Tree-shakeable: unused code is excluded from your builds
+- 🪶 Minimal: 15KB (gzipped) secp256k1, unused code is excluded from your builds
 - 🏎 Fast: hand-optimized for caveats of JS engines
-- 🔍 Reliable: cross-library / wycheproof tests and fuzzing ensure correctness
-- ➰ Weierstrass, Edwards, Montgomery curves; ECDSA, EdDSA, Schnorr, BLS signatures
+- 🔍 Reliable: cross-library / wycheproof tests ensure correctness
+- ➰ Weierstrass, Edwards curves; ECDSA, EdDSA, Schnorr, BLS signatures
 - ✍️ ECDH, hash-to-curve, OPRF, FROST, Poseidon hash, FFT
 - 🔖 Non-repudiation (SUF-CMA, SBS) & consensus-friendliness (ZIP215) in ed25519, ed448
-- 🥈 Optional, friendly wrapper over native WebCrypto
-- 🪶 32KB (gzipped) including bundled hashes, 11KB for single-curve build
+- 🥈 Wrapper with identical API over native WebCrypto
 
@@ -20,4 +19,2 @@ Curves have 5kb sister projects
 
-Take a glance at [GitHub Discussions](https://github.com/paulmillr/noble-curves/discussions) for questions and support.
-
 ### This library belongs to _noble_ cryptography
@@ -37,2 +34,3 @@
   [ed25519](https://github.com/paulmillr/noble-ed25519)
+- WASM version: [awasm-noble](https://github.com/paulmillr/awasm-noble)
 - [Check out the homepage](https://paulmillr.com/noble/)
@@ -814,2 +812,26 @@ for reading resources, documentation, and apps built with noble
 
+Within those limits, secret-scalar multiplication provides specific, measurable properties:
+
+- **Fixed operation sequence:** `multiply()` uses signed fixed-window tables with
+  data-oblivious table scans — the number and order of point operations
+  is independent of the scalar value.
+- **Scalar blinding:** secret scalars are additionally masked as `s + r·n` with a random
+  128-bit `r` before multiplication. This applies to all multiplications on cofactor-1
+  curves (p256, p384, p521, secp256k1), and to base-point multiplications everywhere.
+- **Statistical validation:** a dudect-style Welch t-test harness (`benchmark/ct.ts`)
+  compares timing across adversarial scalar classes (sparse vs dense, low vs high bits,
+  near-order, bit patterns). Base-point multiplication shows no distinguishable timing on any
+  curve, and random-point multiplication shows none on the Weierstrass curves
+  (max |t| ≤ 2.8 at 1000 samples; threshold 4.5).
+
+Known limitation: on cofactored Edwards curves (ed25519, ed448), multiplying a **non-base**
+point by a secret scalar is not blinded. The same harness detects this reliably. EdDSA signing is
+unaffected (it only multiplies the blinded base point), and X25519/X448 use a separate
+Montgomery-ladder implementation (also unaffected). It matters for protocols that multiply arbitrary
+Edwards/Ristretto points by long-lived secret scalars; prefer scalars that are
+full-width by construction there. Note that detectability in an isolated harness does not
+imply practical exploitability: we attempted scalar extraction in a realistic
+cross-tenant / in-browser setting and were unable to recover Edwards scalars
+even with 100,000 timing samples.
+
 ### Memory dumping
@@ -890,97 +912,97 @@
 # secp256k1
-init 10ms
-getPublicKey x 9,099 ops/sec @ 109μs/op
-sign x 7,182 ops/sec @ 139μs/op
-verify x 1,188 ops/sec @ 841μs/op
-recoverPublicKey x 1,265 ops/sec @ 790μs/op
-getSharedSecret x 735 ops/sec @ 1ms/op
-schnorr.sign x 957 ops/sec @ 1ms/op
-schnorr.verify x 1,210 ops/sec @ 825μs/op
+init 11ms
+getPublicKey x 4,909 ops/sec @ 203μs/op
+sign x 4,319 ops/sec @ 231μs/op
+verify x 1,391 ops/sec @ 718μs/op
+recoverPublicKey x 1,377 ops/sec @ 725μs/op
+getSharedSecret x 793 ops/sec @ 1ms/op
+schnorr.sign x 895 ops/sec @ 1ms/op
+schnorr.verify x 1,418 ops/sec @ 704μs/op
 
 # ed25519
-init 14ms
-getPublicKey x 14,216 ops/sec @ 70μs/op
-sign x 6,849 ops/sec @ 145μs/op
-verify x 1,400 ops/sec @ 713μs/op
+init 9ms
+getPublicKey x 7,161 ops/sec @ 139μs/op
+sign x 3,541 ops/sec @ 282μs/op
+verify x 1,483 ops/sec @ 674μs/op
 
 # ed448
-init 37ms
-getPublicKey x 5,273 ops/sec @ 189μs/op
-sign x 2,494 ops/sec @ 400μs/op
-verify x 476 ops/sec @ 2ms/op
+init 19ms
+getPublicKey x 3,125 ops/sec @ 319μs/op
+sign x 1,549 ops/sec @ 645μs/op
+verify x 518 ops/sec @ 1ms/op ± 6.59% (1ms..15ms)
 
 # p256
-init 17ms
-getPublicKey x 8,977 ops/sec @ 111μs/op
-sign x 7,236 ops/sec @ 138μs/op
-verify x 877 ops/sec @ 1ms/op
+init 9ms
+getPublicKey x 4,799 ops/sec @ 208μs/op
+sign x 4,262 ops/sec @ 234μs/op
+verify x 943 ops/sec @ 1ms/op
 
 # p384
-init 42ms
-getPublicKey x 4,084 ops/sec @ 244μs/op
-sign x 3,247 ops/sec @ 307μs/op
-verify x 331 ops/sec @ 3ms/op
+init 20ms
+getPublicKey x 2,208 ops/sec @ 452μs/op
+sign x 1,949 ops/sec @ 512μs/op
+verify x 371 ops/sec @ 2ms/op
 
 # p521
-init 83ms
-getPublicKey x 2,049 ops/sec @ 487μs/op
-sign x 1,748 ops/sec @ 571μs/op
-verify x 170 ops/sec @ 5ms/op
+init 37ms
+getPublicKey x 1,215 ops/sec @ 822μs/op
+sign x 1,116 ops/sec @ 895μs/op
+verify x 186 ops/sec @ 5ms/op
 
 # ristretto255
-add x 931,966 ops/sec @ 1μs/op
-multiply x 15,444 ops/sec @ 64μs/op
-encode x 21,367 ops/sec @ 46μs/op
-decode x 21,715 ops/sec @ 46μs/op
+add x 719,424 ops/sec @ 1μs/op
+multiply x 7,214 ops/sec @ 138μs/op
+encode x 21,337 ops/sec @ 46μs/op
+decode x 20,682 ops/sec @ 48μs/op
 
 # decaf448
-add x 478,011 ops/sec @ 2μs/op
-multiply x 416 ops/sec @ 2ms/op
-encode x 8,562 ops/sec @ 116μs/op
-decode x 8,636 ops/sec @ 115μs/op
+add x 467,945 ops/sec @ 2μs/op
+multiply x 682 ops/sec @ 1ms/op
+encode x 8,279 ops/sec @ 120μs/op
+decode x 8,044 ops/sec @ 124μs/op
 
 # ECDH
-x25519 x 1,981 ops/sec @ 504μs/op
-x448 x 743 ops/sec @ 1ms/op
-secp256k1 x 728 ops/sec @ 1ms/op
-p256 x 705 ops/sec @ 1ms/op
-p384 x 268 ops/sec @ 3ms/op
-p521 x 137 ops/sec @ 7ms/op
+x25519 x 1,631 ops/sec @ 612μs/op
+x448 x 584 ops/sec @ 1ms/op
+secp256k1 x 791 ops/sec @ 1ms/op
+p256 x 757 ops/sec @ 1ms/op
+p384 x 329 ops/sec @ 3ms/op
+p521 x 175 ops/sec @ 5ms/op
 
 # hash-to-curve
-hashToPrivateScalar x 1,754,385 ops/sec @ 570ns/op
-hash_to_field x 135,703 ops/sec @ 7μs/op
-hashToCurve secp256k1 x 3,194 ops/sec @ 313μs/op
-hashToCurve p256 x 5,962 ops/sec @ 167μs/op
-hashToCurve p384 x 2,230 ops/sec @ 448μs/op
-hashToCurve p521 x 1,063 ops/sec @ 940μs/op
-hashToCurve ed25519 x 4,047 ops/sec @ 247μs/op
-hashToCurve ed448 x 1,691 ops/sec @ 591μs/op
-hash_to_ristretto255 x 8,733 ops/sec @ 114μs/op
-hash_to_decaf448 x 3,882 ops/sec @ 257μs/op
+hashToScalar x 212,404 ops/sec @ 4μs/op
+hash_to_field x 239,578 ops/sec @ 4μs/op
+hashToCurve secp256k1 x 5,101 ops/sec @ 196μs/op
+hashToCurve p256 x 7,651 ops/sec @ 130μs/op
+hashToCurve p384 x 3,275 ops/sec @ 305μs/op
+hashToCurve p521 x 1,642 ops/sec @ 608μs/op
+hashToCurve ed25519 x 6,679 ops/sec @ 149μs/op
+hashToCurve ed448 x 2,911 ops/sec @ 343μs/op
+hash_to_ristretto255 x 9,284 ops/sec @ 107μs/op
+hash_to_decaf448 x 3,764 ops/sec @ 265μs/op
 
 # modular over secp256k1 P field
-invert a x 866,551 ops/sec @ 1μs/op
-invert b x 693,962 ops/sec @ 1μs/op
-sqrt p = 3 mod 4 x 25,738 ops/sec @ 38μs/op
-sqrt tonneli-shanks x 847 ops/sec @ 1ms/op
+invert a x 868,809 ops/sec @ 1μs/op
+invert b x 662,251 ops/sec @ 1μs/op
+sqrt p = 3 mod 4 x 24,440 ops/sec @ 40μs/op
+sqrt tonneli-shanks x 803 ops/sec @ 1ms/op
 
 # bls12-381
-init 22ms
-getPublicKey x 1,325 ops/sec @ 754μs/op
-sign x 80 ops/sec @ 12ms/op
-verify x 62 ops/sec @ 15ms/op
-pairing x 166 ops/sec @ 6ms/op
-pairing10 x 54 ops/sec @ 18ms/op ± 23.48% (15ms..36ms)
-MSM 4096 scalars x points 3286ms
-aggregatePublicKeys/8 x 173 ops/sec @ 5ms/op
-aggregatePublicKeys/32 x 46 ops/sec @ 21ms/op
-aggregatePublicKeys/128 x 11 ops/sec @ 84ms/op
-aggregatePublicKeys/512 x 2 ops/sec @ 335ms/op
-aggregatePublicKeys/2048 x 0 ops/sec @ 1346ms/op
-aggregateSignatures/8 x 82 ops/sec @ 12ms/op
-aggregateSignatures/32 x 21 ops/sec @ 45ms/op
-aggregateSignatures/128 x 5 ops/sec @ 178ms/op
-aggregateSignatures/512 x 1 ops/sec @ 705ms/op
-aggregateSignatures/2048 x 0 ops/sec @ 2823ms/op
+init 90ms
+getPublicKey x 2,315 ops/sec @ 431μs/op
+sign x 222 ops/sec @ 4ms/op
+verify x 113 ops/sec @ 8ms/op
+pairing x 160 ops/sec @ 6ms/op
+pairing10 x 42 ops/sec @ 23ms/op ± 7.14% (22ms..36ms)
+MSM 4096 scalars x points 564ms
+aggregatePublicKeys/8 x 1,862 ops/sec @ 536μs/op
+aggregatePublicKeys/32 x 1,589 ops/sec @ 629μs/op
+aggregatePublicKeys/128 x 988 ops/sec @ 1ms/op
+aggregatePublicKeys/512 x 396 ops/sec @ 2ms/op
+aggregatePublicKeys/2048 x 115 ops/sec @ 8ms/op
+aggregateSignatures/8 x 87 ops/sec @ 11ms/op
+aggregateSignatures/32 x 23 ops/sec @ 43ms/op
+aggregateSignatures/128 x 5 ops/sec @ 170ms/op
+aggregateSignatures/512 x 1 ops/sec @ 680ms/op
+aggregateSignatures/2048 x 0 ops/sec @ 2737ms/op
 ```
@@ -1119,3 +1141,3 @@
 - `npm run bench` will run benchmarks
-- `npm run build:release` will build single file
+- `npm run bundle` will build single file
 
@@ -1122,0 +1144,0 @@ See [paulmillr.com/noble](https://paulmillr.com/noble/)

secp256k1.d.ts

 import { type CurveLengths } from './abstract/curve.ts';
-import { type FROST } from './abstract/frost.ts';
+import { type FROST, type FrostPublic, type FrostSecret } from './abstract/frost.ts';
 import { type H2CHasher } from './abstract/hash-to-curve.ts';
@@ -48,2 +48,4 @@ import { type ECDSA, type WeierstrassPoint as PointType, type WeierstrassPointCons } from './abstract/weierstrass.ts';
     lift_x: typeof lift_x;
+    frostTweakPublic: typeof frostTweakPublic;
+    frostTweakSecret: typeof frostTweakSecret;
 };
@@ -138,2 +140,4 @@ /** Schnorr-specific secp256k1 API from BIP340. */
 export declare const secp256k1_FROST: TRet<FROST>;
+declare function frostTweakSecret(s: TArg<FrostSecret>, pub: TArg<FrostPublic>, merkleRoot?: TArg<Uint8Array>): TRet<FrostSecret>;
+declare function frostTweakPublic(pub: TArg<FrostPublic>, merkleRoot?: TArg<Uint8Array>): TRet<FrostPublic>;
 /**
@@ -155,2 +159,1 @@ * FROST threshold signatures over secp256k1-schnorr-taproot. RFC 9591.
 export {};
-//# sourceMappingURL=secp256k1.d.ts.map

secp256k1.js

@@ -13,5 +13,5 @@ /**
 import { createFROST, } from "./abstract/frost.js";
-import { createHasher, isogenyMap } from "./abstract/hash-to-curve.js";
+import { createHasher, isogenyMap, mapToCurveSimpleSWU, } from "./abstract/hash-to-curve.js";
 import { Field, mapHashToField, pow2 } from "./abstract/modular.js";
-import { ecdsa, mapToCurveSimpleSWU, weierstrass, } from "./abstract/weierstrass.js";
+import { ecdsa, weierstrass, } from "./abstract/weierstrass.js";
 import { abytes, asciiToBytes, bytesToNumberBE, concatBytes, } from "./utils.js";
@@ -67,3 +67,3 @@ // Seems like generator was produced from some seed:
 }
-const Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
+const Fpk1 = /* @__PURE__ */ Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
 const Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
@@ -96,3 +96,3 @@ Fp: Fpk1,
 /** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */
-const TAGGED_HASH_PREFIXES = {};
+const TAGGED_HASH_PREFIXES = Object.create(null);
 // BIP-340 phrases tags as UTF-8, but all current standardized names here are 7-bit ASCII.
@@ -110,10 +110,12 @@ function taggedHash(tag, ...messages) {
 const pointToBytes = (point) => point.toBytes(true).slice(1);
-const hasEven = (y) => y % _2n === _0n;
+const affineXToBytes = ({ x }) => Fpk1.toBytes(x);
+const hasEven = (y) => !Fpk1.isOdd(y);
 // Calculate point, scalar and bytes
 function schnorrGetExtPubKey(priv) {
     const { Fn, BASE } = Pointk1;
-    const d_ = Fn.fromBytes(priv);
+    const d_ = Fn.fromBytes(abytes(priv, 32, 'secretKey'));
     const p = BASE.multiply(d_); // P = d'⋅G; 0 < d' < n check is done inside
-    const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);
-    return { scalar, bytes: pointToBytes(p) };
+    const affine = p.toAffine();
+    const scalar = hasEven(affine.y) ? d_ : Fn.neg(d_);
+    return { scalar, bytes: affineXToBytes(affine) };
 }
@@ -128,4 +130,4 @@ /**
         throw new Error('invalid x: Fail if x ≥ p');
-    const xx = Fp.create(x * x);
-    const c = Fp.create(xx * x + BigInt(7)); // Let c = x³ + 7 mod p.
+    const xx = Fp.sqr(x);
+    const c = Fp.add(Fp.mulN(xx, x), BigInt(7)); // Let c = x³ + 7 mod p.
     let y = Fp.sqrt(c); // Let y = c^(p+1)/4 mod p. Same as sqrt().
@@ -170,7 +172,8 @@ // Return the unique point P such that x(P) = x and
     // BIP-340: "Let k' = int(rand) mod n. Fail if k' = 0. Let R = k'⋅G."
-    if (k_ === 0n)
+    if (k_ === _0n)
         throw new Error('sign failed: k is zero');
     const p = BASE.multiply(k_); // Rejects zero; only the raw nonce hash needs reduction.
-    const k = hasEven(p.y) ? k_ : Fn.neg(k_);
-    const rx = pointToBytes(p);
+    const affine = p.toAffine();
+    const k = hasEven(affine.y) ? k_ : Fn.neg(k_);
+    const rx = affineXToBytes(affine);
     const e = challenge(rx, px, m); // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.
@@ -196,3 +199,4 @@ const sig = new Uint8Array(64); // Let sig = bytes(R) || bytes((k + ed) mod n).
         const P = lift_x(num(pub)); // P = lift_x(int(pk)); fail if that fails
-        const r = num(sig.subarray(0, 32)); // Let r = int(sig[0:32]); fail if r ≥ p.
+        const rBytes = sig.subarray(0, 32);
+        const r = num(rBytes); // Let r = int(sig[0:32]); fail if r ≥ p.
         if (!Fp.isValidNot0(r))
@@ -207,8 +211,8 @@ return false;
         // int(challenge(bytes(r) || bytes(P) || m)) % n
-        const e = challenge(Fn.toBytes(r), pointToBytes(P), m);
+        const e = challenge(rBytes, pointToBytes(P), m);
         // R = s⋅G - e⋅P, where -eP == (n-e)P
-        const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));
+        const R = BASE.mulAddUnsafe(s, P, Fn.neg(e)); // s⋅G + (-e)⋅P, joint Strauss–Shamir
         const { x, y } = R.toAffine();
         // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.
-        if (R.is0() || !hasEven(y) || x !== r)
+        if (R.is0() || !hasEven(y) || !Fp.eql(x, r))
             return false;
@@ -221,3 +225,3 @@ return true;
 }
-export const __TEST = /* @__PURE__ */ Object.freeze({ lift_x });
+export const __TEST = /* @__PURE__ */ Object.freeze({ lift_x, frostTweakPublic, frostTweakSecret });
 /**
@@ -243,3 +247,3 @@ * Schnorr signatures over secp256k1.
         seed = seed === undefined ? randomBytes(seedLength) : seed;
-        return mapHashToField(seed, secp256k1_CURVE.n);
+        return mapHashToField(abytes(seed, seedLength, 'seed'), secp256k1_CURVE.n);
     };
@@ -386,4 +390,4 @@ return Object.freeze({
 }
-function frostNoncesToEvenY(PK, nonces) {
-    if (hasEven(PK.y))
+function frostNoncesToEvenY(groupCommitment, nonces) {
+    if (hasEven(groupCommitment.y))
         return nonces;
@@ -410,2 +414,6 @@ const Fn = Pointk1.Fn;
     const t = tweak(Pointk1.fromBytes(PKPackage.commitments[0]), merkleRoot);
+    // Disabled TapTweak (t=0): return the even-Y-normalized package as-is. multiply() rejects
+    // zero scalars, and adding [0]G would be a no-op anyway.
+    if (t === _0n)
+        return PKPackage;
     const tp = Pointk1.BASE.multiply(t);
@@ -478,2 +486,1 @@ const commitments = PKPackage.commitments.map((c, i) => (i === 0 ? Pointk1.fromBytes(c).add(tp) : Pointk1.fromBytes(c)).toBytes());
 }))();
-//# sourceMappingURL=secp256k1.js.map

src/abstract/bls.ts

@@ -18,3 +18,11 @@ /**
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { abytes, notImplemented, randomBytes, type TArg, type TRet } from '../utils.ts';
+import {
+  aarray,
+  abytes,
+  notImplemented,
+  randomBytes,
+  validateObject,
+  type TArg,
+  type TRet,
+} from '../utils.ts';
 import { type CurveLengths } from './curve.ts';
@@ -164,3 +172,3 @@ import {
    * Build Miller-loop precomputes for one G2 point.
-   * @param p - G2 point to precompute.
+   * @param p - Valid non-ZERO G2 point to precompute.
    * @returns Pairing precompute table.
@@ -220,3 +228,4 @@ */
    * Optional RNG override used by helper constructors.
-   * Receives the requested byte length and returns random bytes.
+   * @param len - Requested byte length.
+   * @returns Random bytes.
    */
@@ -302,3 +311,5 @@ randomBytes?: (len?: number) => TRet<Uint8Array>;
     ateLoopSize: bigint;
+    xNegative: boolean;
     twistType: BlsTwistType;
+    postPrecompute?: BlsPostPrecomputeFn;
   };
@@ -352,2 +363,4 @@ }
    * Verify one signature against one public key and hashed message.
+   * Malformed encoded signatures or keys may throw during point decoding; `false` means
+   * well-formed inputs failed the pairing equation.
    * @param signature - Signature point or encoded signature.
@@ -376,2 +389,4 @@ * @param message - Hashed message point.
    * Add many public keys into one aggregate point.
+   * Encoded inputs are decoded through `fromBytes()`; point instances are treated as already
+   * validated caller-owned objects to keep aggregation linear in additions.
    * @param publicKeys - Public keys to aggregate.
@@ -384,2 +399,4 @@ * @returns Aggregated public-key point. This is raw point addition and does not add proof of
    * Add many signatures into one aggregate point.
+   * Encoded inputs are decoded through `fromBytes()`; point instances are treated as already
+   * validated caller-owned objects to keep aggregation linear in additions.
    * @param signatures - Signatures to aggregate.
@@ -430,6 +447,124 @@ * @returns Aggregated signature point. This is raw point addition and does not change the proof
 ): BlsPairing {
-  const { Fr, Fp2, Fp12 } = fields;
+  validateObject(
+    fields as any,
+    { Fp: 'object', Fr: 'object', Fp2: 'object', Fp12: 'object' },
+    { Fp6: 'object' },
+    'fields'
+  );
+  if (typeof G1 !== 'function')
+    throw new TypeError('"G1_Point" expected point constructor, got type=' + typeof G1);
+  if (typeof G2 !== 'function')
+    throw new TypeError('"G2_Point" expected point constructor, got type=' + typeof G2);
+  validateObject(
+    params as any,
+    { ateLoopSize: 'bigint', xNegative: 'boolean', twistType: 'string' },
+    { randomBytes: 'function', postPrecompute: 'function' },
+    'params'
+  );
+  const { Fp, Fr, Fp2, Fp12 } = fields;
   const { twistType, ateLoopSize, xNegative, postPrecompute } = params;
   type G1 = typeof G1.BASE;
   type G2 = typeof G2.BASE;
+  const fp2 = (c0: Fp, c1: Fp): Fp2 => ({ c0, c1 });
+  const fp2f = ({ c0, c1 }: Fp2): Fp2 => Object.freeze({ c0, c1 });
+  const add2 = (a: Fp2, b: Fp2) => fp2(Fp.add(a.c0, b.c0), Fp.add(a.c1, b.c1));
+  const sub2 = (a: Fp2, b: Fp2) => fp2(Fp.sub(a.c0, b.c0), Fp.sub(a.c1, b.c1));
+  const mul2 = (a: Fp2, b: Fp2) => {
+    const t0 = Fp.mul(a.c0, b.c0);
+    const t1 = Fp.mul(a.c1, b.c1);
+    return fp2(
+      Fp.sub(t0, t1),
+      Fp.sub(Fp.mul(Fp.add(a.c0, a.c1), Fp.add(b.c0, b.c1)), Fp.add(t0, t1))
+    );
+  };
+  const mul2ByFp = (a: Fp2, rhs: Fp) => fp2(Fp.mul(a.c0, rhs), Fp.mul(a.c1, rhs));
+  // Delegates to the tower's mulByNonresidue: it has fast paths for ξ = u+1 / ξ = a+u
+  // (adds/scalar-muls instead of a full Karatsuba Fp2 multiplication).
+  const mul2ByNonresidue = (a: Fp2): Fp2 => Fp2.mulByNonresidue(a);
+  const mul014ByLine = ({ c0: f0, c1: f1 }: Fp12, o0: Fp2, l1: Fp2, l4: Fp2, Px: Fp, Py: Fp) => {
+    const o1 = mul2ByFp(l1, Px);
+    const o4 = mul2ByFp(l4, Py);
+    const { c0: a0, c1: a1, c2: a2 } = f0;
+    const { c0: b0, c1: b1, c2: b2 } = f1;
+
+    // t0 = Fp6.mul01(f0, o0, o1)
+    const t0_0 = mul2(a0, o0);
+    const t0_1 = mul2(a1, o1);
+    const t0_c0 = add2(mul2ByNonresidue(sub2(mul2(add2(a1, a2), o1), t0_1)), t0_0);
+    const t0_c1 = sub2(sub2(mul2(add2(o0, o1), add2(a0, a1)), t0_0), t0_1);
+    const t0_c2 = add2(sub2(mul2(add2(a0, a2), o0), t0_0), t0_1);
+
+    // t1 = Fp6.mul1(f1, o4)
+    const t1_c0 = mul2ByNonresidue(mul2(b2, o4));
+    const t1_c1 = mul2(b0, o4);
+    const t1_c2 = mul2(b1, o4);
+
+    // t2 = Fp6.mul01(Fp6.add(f0, f1), o0, Fp2.add(o1, o4))
+    const s0 = add2(a0, b0);
+    const s1 = add2(a1, b1);
+    const s2 = add2(a2, b2);
+    const o14 = add2(o1, o4);
+    const t2_0 = mul2(s0, o0);
+    const t2_1 = mul2(s1, o14);
+    const t2_c0 = add2(mul2ByNonresidue(sub2(mul2(add2(s1, s2), o14), t2_1)), t2_0);
+    const t2_c1 = sub2(sub2(mul2(add2(o0, o14), add2(s0, s1)), t2_0), t2_1);
+    const t2_c2 = add2(sub2(mul2(add2(s0, s2), o0), t2_0), t2_1);
+
+    return Object.freeze({
+      c0: Object.freeze({
+        c0: fp2f(add2(mul2ByNonresidue(t1_c2), t0_c0)),
+        c1: fp2f(add2(t1_c0, t0_c1)),
+        c2: fp2f(add2(t1_c1, t0_c2)),
+      }),
+      c1: Object.freeze({
+        c0: fp2f(sub2(sub2(t2_c0, t0_c0), t1_c0)),
+        c1: fp2f(sub2(sub2(t2_c1, t0_c1), t1_c1)),
+        c2: fp2f(sub2(sub2(t2_c2, t0_c2), t1_c2)),
+      }),
+    });
+  };
+  // Like mul014ByLine, params are named after the sparse slot they end up in: l0 is scaled by
+  // Py into o0, l3 is scaled by Px into o3, o4 is used as-is.
+  const mul034ByLine = ({ c0: f0, c1: f1 }: Fp12, l0: Fp2, l3: Fp2, o4: Fp2, Px: Fp, Py: Fp) => {
+    const o0 = mul2ByFp(l0, Py);
+    const o3 = mul2ByFp(l3, Px);
+    const { c0: a0, c1: a1, c2: a2 } = f0;
+    const { c0: b0, c1: b1, c2: b2 } = f1;
+
+    // a = f0 * o0
+    const a_c0 = mul2(a0, o0);
+    const a_c1 = mul2(a1, o0);
+    const a_c2 = mul2(a2, o0);
+
+    // b = Fp6.mul01(f1, o3, o4)
+    const b0m = mul2(b0, o3);
+    const b1m = mul2(b1, o4);
+    const b_c0 = add2(mul2ByNonresidue(sub2(mul2(add2(b1, b2), o4), b1m)), b0m);
+    const b_c1 = sub2(sub2(mul2(add2(o3, o4), add2(b0, b1)), b0m), b1m);
+    const b_c2 = add2(sub2(mul2(add2(b0, b2), o3), b0m), b1m);
+
+    // e = Fp6.mul01(Fp6.add(f0, f1), Fp2.add(o0, o3), o4)
+    const s0 = add2(a0, b0);
+    const s1 = add2(a1, b1);
+    const s2 = add2(a2, b2);
+    const o03 = add2(o0, o3);
+    const e0m = mul2(s0, o03);
+    const e1m = mul2(s1, o4);
+    const e_c0 = add2(mul2ByNonresidue(sub2(mul2(add2(s1, s2), o4), e1m)), e0m);
+    const e_c1 = sub2(sub2(mul2(add2(o03, o4), add2(s0, s1)), e0m), e1m);
+    const e_c2 = add2(sub2(mul2(add2(s0, s2), o03), e0m), e1m);
+
+    return Object.freeze({
+      c0: Object.freeze({
+        c0: fp2f(add2(mul2ByNonresidue(b_c2), a_c0)),
+        c1: fp2f(add2(b_c0, a_c1)),
+        c2: fp2f(add2(b_c1, a_c2)),
+      }),
+      c1: Object.freeze({
+        c0: fp2f(sub2(sub2(e_c0, a_c0), b_c0)),
+        c1: fp2f(sub2(sub2(e_c1, a_c1), b_c1)),
+        c2: fp2f(sub2(sub2(e_c2, a_c2), b_c2)),
+      }),
+    });
+  };
   // Applies sparse multiplication as line function
@@ -439,3 +574,3 @@ let lineFunction: (c0: Fp2, c1: Fp2, c2: Fp2, f: Fp12, Px: Fp, Py: Fp) => Fp12;
     lineFunction = (c0: Fp2, c1: Fp2, c2: Fp2, f: Fp12, Px: Fp, Py: Fp) =>
-      Fp12.mul014(f, c0, Fp2.mul(c1, Px), Fp2.mul(c2, Py));
+      mul014ByLine(f, c0, c1, c2, Px, Py);
   } else if (twistType === 'divisive') {
@@ -445,3 +580,3 @@ // NOTE: it should be [c0, c1, c2], but we use different order here to reduce complexity of
     lineFunction = (c0: Fp2, c1: Fp2, c2: Fp2, f: Fp12, Px: Fp, Py: Fp) =>
-      Fp12.mul034(f, Fp2.mul(c2, Py), Fp2.mul(c1, Px), c0);
+      mul034ByLine(f, c2, c1, c0, Px, Py);
   } else throw new Error('bls: unknown twist type');
@@ -496,2 +631,4 @@
   const calcPairingPrecomputes = (point: G2) => {
+    if (!(point instanceof G2))
+      throw new TypeError('"point" expected G2 point, got type=' + typeof point);
     const p = point;
@@ -521,2 +658,7 @@ const { x, y } = p.toAffine();
   function millerLoopBatch(pairs: MillerInput, withFinalExponent: boolean = false) {
+    aarray<MillerInput[number]>(pairs, 'pairs', (pair, title) => {
+      aarray(pair, title);
+      if (pair.length !== 3) throw new TypeError(`"${title}" expected precompute tuple`);
+      aarray(pair[0], title + '[0]');
+    });
     let f12 = Fp12.ONE;
@@ -526,3 +668,4 @@ if (pairs.length) {
       for (let i = 0; i < ellLen; i++) {
-        f12 = Fp12.sqr(f12); // This allows us to do sqr only one time for all pairings
+        // sqr only one time for all pairings; skip sqr(ONE) at i=0
+        if (i !== 0) f12 = Fp12.sqr(f12);
         // NOTE: we apply multiple pairings in parallel here
@@ -541,4 +684,12 @@ for (const [ell, Px, Py] of pairs) {
   function pairingBatch(pairs: PairingInput[], withFinalExponent: boolean = true) {
+    aarray<PairingInput>(pairs, 'pairs');
     const res: MillerInput = [];
-    for (const { g1, g2 } of pairs) {
+    for (let i = 0; i < pairs.length; i++) {
+      const pair = pairs[i];
+      validateObject(pair as any, { g1: 'object', g2: 'object' }, {}, 'pairs[' + i + ']');
+      const { g1, g2 } = pair;
+      if (!(g1 instanceof G1))
+        throw new TypeError('"pairs[' + i + '].g1" expected G1 point, got type=' + typeof g1);
+      if (!(g2 instanceof G2))
+        throw new TypeError('"pairs[' + i + '].g2" expected G2 point, got type=' + typeof g2);
       // Mathematically, a zero pairing term contributes GT.ONE. We still reject it here because
@@ -559,2 +710,4 @@ // this API mainly backs BLS verification, where ZERO inputs usually mean broken hash /
   function pairing(Q: G1, P: G2, withFinalExponent: boolean = true): Fp12 {
+    if (!(Q instanceof G1)) throw new TypeError('"Q" expected G1 point, got type=' + typeof Q);
+    if (!(P instanceof G2)) throw new TypeError('"P" expected G2 point, got type=' + typeof P);
     return pairingBatch([{ g1: Q, g2: P }], withFinalExponent);
@@ -603,2 +756,3 @@ }
   }
+  const sigCoder = SignatureCoder;
   type PubPoint = WeierstrassPoint<P>;
@@ -610,3 +764,3 @@ type SigPoint = WeierstrassPoint<S>;
   function normSig(point: SigPoint | BLSInput): SigPoint {
-    return point instanceof SigPoint ? (point as SigPoint) : SigPoint.fromBytes(point);
+    return point instanceof SigPoint ? (point as SigPoint) : sigCoder.fromBytes(point);
   }
@@ -651,2 +805,3 @@ // Sign/verify here take points already hashed onto the signature subgroup.
       const sec = PubPoint.Fn.fromBytes(secretKey);
+      // BLS/BN point APIs allow infinity for compatibility; raw message bytes still fail amsg().
       amsg(message).assertValidity();
@@ -691,3 +846,3 @@ return message.multiply(sec);
       const sig = normSig(signature);
-      const nMessages = items.map((i) => i.message);
+      const nMessages = items.map((i) => amsg(i.message));
       const nPublicKeys = items.map((i) => normPub(i.publicKey));
@@ -741,6 +896,7 @@ // NOTE: this works only for exact same object
       abytes(messageBytes);
-      const opts = DST ? { DST } : undefined;
+      // Only omitted DST uses the default; explicit empty DST must reach normDST validation.
+      const opts = DST === undefined ? undefined : { DST };
       return hashToSigCurve(messageBytes, opts);
     },
-    Signature: Object.freeze({ ...SignatureCoder }),
+    Signature: Object.freeze({ ...sigCoder }),
   }) /*satisfies Signer */;
@@ -770,4 +926,5 @@ }
  * import { bn254 } from '@noble/curves/bn254.js';
- * // Pair a G1 point with a G2 point without the higher-level signer helpers.
- * const gt = bn254.pairing(bn254.G1.Point.BASE, bn254.G2.Point.BASE);
+ * // Rebuild the pairing-only helper from a concrete curve's public pieces.
+ * const pair = blsBasic(bn254.fields, bn254.G1.Point, bn254.G2.Point, bn254.params);
+ * const gt = pair.pairing(pair.G1.Point.BASE, pair.G2.Point.BASE);
  * ```
@@ -812,3 +969,5 @@ */
       ateLoopSize: params.ateLoopSize,
+      xNegative: params.xNegative,
       twistType: params.twistType,
+      postPrecompute: params.postPrecompute,
     }),
@@ -831,2 +990,8 @@ utils: Object.freeze({
   const base = blsBasic(fields, G1_Point, G2_Point, params);
+  validateObject(
+    hasherParams as any,
+    { hasherOpts: 'object', hasherOptsG1: 'object', hasherOptsG2: 'object' },
+    { mapToG1: 'function', mapToG2: 'function' },
+    'hasherParams'
+  );
   // Missing map hooks intentionally fail closed via notImplemented on first hash use.
@@ -869,8 +1034,17 @@ const G1Hasher = createHasher(
  * import { bls12_381 } from '@noble/curves/bls12-381.js';
- * const sigs = bls12_381.longSignatures;
- * // Use the full BLS helper set when you need hashing, keygen, signing, and verification.
- * const { secretKey, publicKey } = sigs.keygen();
- * const msg = sigs.hash(new TextEncoder().encode('hello noble'));
- * const sig = sigs.sign(msg, secretKey);
- * const isValid = sigs.verify(sig, msg, publicKey);
+ * // Rebuild a signer namespace from a concrete curve.
+ * // Applications usually import bls12_381 directly.
+ * const rebuilt = bls(
+ *   bls12_381.fields,
+ *   bls12_381.G1.Point,
+ *   bls12_381.G2.Point,
+ *   bls12_381.params,
+ *   {
+ *     hasherOpts: bls12_381.G2.defaults,
+ *     hasherOptsG1: bls12_381.G1.defaults,
+ *     hasherOptsG2: bls12_381.G2.defaults,
+ *   },
+ *   {}
+ * );
+ * const { secretKey, publicKey } = rebuilt.longSignatures.keygen();
  * ```
@@ -877,0 +1051,0 @@ */

src/abstract/curve.ts

 /**
  * Methods for elliptic curve multiplication by scalars.
- * Contains wNAF, pippenger.
+ * Contains wNAF-based ScalarMultiplier, pippenger.
  * @module
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { bitLen, bitMask, validateObject, type Signer, type TArg, type TRet } from '../utils.ts';
+import {
+  aarray,
+  abool,
+  afunction,
+  aobject,
+  bitLen,
+  bitMask,
+  bytesToNumberBE,
+  inRange,
+  isBytes,
+  isPosBig,
+  validateObject,
+  type Signer,
+  type TArg,
+  type TRet,
+} from '../utils.ts';
 import { Field, FpInvertBatch, validateField, type IField } from './modular.ts';
@@ -12,2 +27,13 @@
 const _1n = /* @__PURE__ */ BigInt(1);
+const _4n = /* @__PURE__ */ BigInt(4);
+const BLIND_BYTES = 16;
+const BLIND_BITS = 128;
+// Fixed-window width for the constant-time multiply of un-precomputed points (W===1).
+// A flat 2^FW_WINDOW table has a small, scalar-independent build cost that amortizes over a single
+// multiply, unlike the larger per-point wNAF tables that only pay off when cached.
+const FW_WINDOW = 5;
+// Precompute tables are capped at ~2 GiB of estimated heap. Rejecting larger windows up front
+// turns a typo'd window size into an immediate error instead of a multi-GB allocation (or an
+// effective hang) when the lazy table is built on first multiply.
+const TABLE_BYTES_MAX = /* @__PURE__ */ (() => 2 ** 31)();
 
@@ -105,3 +131,4 @@ /** Affine point coordinates without projective fields. */
   /**
-   * Massively speeds up `p.multiply(n)` by using precompute tables (caching). See {@link wNAF}.
+   * Massively speeds up `p.multiply(n)` by using precompute tables (caching).
+   * See {@link ScalarMultiplier}.
    * Cache state lives in internal WeakMaps keyed by point identity, not on the point object.
@@ -236,20 +263,11 @@ * Repeating `precompute(...)` for the same point identity replaces the remembered window size
   const pc = Point as unknown as CurvePointCons<any>;
-  if (typeof (pc as unknown) !== 'function') throw new TypeError('Point must be a constructor');
-  // validateObject only accepts plain objects, so copy the constructor statics into one bag first.
-  validateObject(
-    {
-      Fp: pc.Fp,
-      Fn: pc.Fn,
-      fromAffine: pc.fromAffine,
-      fromBytes: pc.fromBytes,
-      fromHex: pc.fromHex,
-    },
-    {
-      Fp: 'object',
-      Fn: 'object',
-      fromAffine: 'function',
-      fromBytes: 'function',
-      fromHex: 'function',
-    }
-  );
+  if (typeof (pc as unknown) !== 'function')
+    throw new TypeError('"Point" expected constructor, got type=' + typeof Point);
+  afunction(pc.fromAffine, 'Point.fromAffine');
+  afunction(pc.fromBytes, 'Point.fromBytes');
+  afunction(pc.fromHex, 'Point.fromHex');
+  // Generic helpers (ScalarMultiplier, normalizeZ, MSM) dereference BASE / ZERO:
+  // fail here with a typed error instead of an `undefined` access later.
+  aobject(pc.BASE, 'Point.BASE');
+  aobject(pc.ZERO, 'Point.ZERO');
   validateField(pc.Fp);
@@ -279,22 +297,2 @@ validateField(pc.Fn);
 /**
- * Computes both candidates first, but the final selection still branches on `condition`, so this
- * is not a strict constant-time CMOV primitive.
- * @param condition - Whether to negate the point.
- * @param item - Point-like value.
- * @returns Original or negated value.
- * @example
- * Keep the point or return its negation based on one boolean branch.
- *
- * ```ts
- * import { negateCt } from '@noble/curves/abstract/curve.js';
- * import { p256 } from '@noble/curves/nist.js';
- * const maybeNegated = negateCt(true, p256.Point.BASE);
- * ```
- */
-export function negateCt<T extends { negate: () => T }>(condition: boolean, item: T): T {
-  const neg = item.negate();
-  return condition ? neg : item;
-}
-
-/**
  * Takes a bunch of Projective Points but executes only one
@@ -321,2 +319,8 @@ * inversion on all of them. Inversion is very slow operation,
 ): P[] {
+  // Match MSM helpers: reject malformed public inputs before reading projective internals.
+  validatePointCons(c);
+  validateMSMPoints(points, c);
+  // Identity points (Z=0) rely on an implicit contract: FpInvertBatch without `passZero`
+  // yields `undefined` for zero inputs, and `toAffine(undefined)` falls back to its internal
+  // is0 handling instead of using the batch inverse.
   const invertedZs = FpInvertBatch(
@@ -329,56 +333,66 @@ c.Fp,
 
-function validateW(W: number, bits: number) {
-  if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
-    throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);
+function validateW(W: number, bits: number, min: number = 1) {
+  if (!Number.isSafeInteger(W) || W < min || W > bits)
+    throw new Error('invalid window size, expected [' + min + '..' + bits + '], got W=' + W);
 }
 
-/** Internal wNAF opts for specific W and scalarBits.
- * Zero digits are skipped, so tables store only the positive half-window and callers reserve one
- * extra carry window.
- */
-type WOpts = {
-  windows: number;
-  windowSize: number;
-  mask: bigint;
-  maxNumber: number;
-  shiftBy: bigint;
-};
-
-function calcWOpts(W: number, scalarBits: number): WOpts {
-  validateW(W, scalarBits);
-  const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero
-  const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero
-  const maxNumber = 2 ** W; // W=8 256
-  const mask = bitMask(W); // W=8 255 == mask 0b11111111
-  const shiftBy = BigInt(W); // W=8 8
-  return { windows, windowSize, mask, maxNumber, shiftBy };
+// Rough per-point heap estimate for the {@link TABLE_BYTES_MAX} cap: up to 4 projective/extended
+// coordinates of Fp.BYTES each, plus bigint/object overhead. Callers pass the point count of the
+// largest table the checked parameters can produce.
+function validateTableBytes(numPoints: number, fpBytes: number): void {
+  const bytes = numPoints * (4 * fpBytes + 128);
+  if (bytes > TABLE_BYTES_MAX)
+    throw new Error(
+      'invalid window size: table would need ~' +
+        Math.ceil(bytes / 2 ** 20) +
+        ' MiB, max ' +
+        TABLE_BYTES_MAX / 2 ** 20 +
+        ' MiB'
+    );
 }
 
-function calcOffsets(n: bigint, window: number, wOpts: WOpts) {
-  const { windowSize, mask, maxNumber, shiftBy } = wOpts;
-  let wbits = Number(n & mask); // extract W bits.
-  let nextN = n >> shiftBy; // shift number by W bits.
+/** RNG interface used for scalar / nonce blinding. */
+export type RandomBytes = (bytesLength?: number) => TRet<Uint8Array>;
 
-  // What actually happens here:
-  // const highestBit = Number(mask ^ (mask >> 1n));
-  // let wbits2 = wbits - 1; // skip zero
-  // if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);
-
-  // split if bits > max: +224 => 256-32
-  if (wbits > windowSize) {
-    // we skip zero, which means instead of `>= size-1`, we do `> size`
-    wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.
-    nextN += _1n; // +256 (carry)
+/**
+ * Probes an RNG once, at construction time: returns `undefined` when it is unavailable —
+ * throws or returns malformed bytes — so callers can downgrade to their unblinded /
+ * deterministic constant-time fallback. Blinding is defense-in-depth (DPA/template
+ * hardening), not a correctness or key-secrecy requirement, so availability-based
+ * downgrade is acceptable.
+ *
+ * The downgrade decision is deliberately static. After a successful probe the RNG becomes
+ * part of the trusted contract: later misbehavior must fail closed in per-call validation
+ * (throw), never downgrade — a dynamic fallback would let a tampered RNG silently strip
+ * blinding on demand. A probe can only ever classify broken environments, not adversarial
+ * RNGs: a stateful RNG can always behave while probed and misbehave later.
+ * @param randomBytes - RNG to probe, or `undefined` when the environment provides none.
+ * @param length - Byte length requested from the probe call.
+ * @returns The RNG when the probe produced `length` valid bytes; `undefined` otherwise.
+ * @example
+ * Probe an RNG once before enabling scalar blinding.
+ *
+ * ```ts
+ * import { probeRandomBytes } from '@noble/curves/abstract/curve.js';
+ * import { randomBytes } from '@noble/hashes/utils.js';
+ * const rng = probeRandomBytes(randomBytes, 16);
+ * ```
+ */
+export function probeRandomBytes(
+  randomBytes: TArg<RandomBytes | undefined>,
+  length: number
+): TRet<RandomBytes | undefined> {
+  if (randomBytes === undefined) return undefined;
+  afunction(randomBytes, 'randomBytes');
+  try {
+    const probe = randomBytes(length);
+    if (!isBytes(probe) || probe.length !== length) return undefined;
+  } catch {
+    return undefined;
   }
-  const offsetStart = window * windowSize;
-  const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero; ignore when isZero
-  const isZero = wbits === 0; // is current window slice a 0?
-  const isNeg = wbits < 0; // is current window slice negative?
-  const isNegF = window % 2 !== 0; // fake branch noise only
-  const offsetF = offsetStart; // fake branch noise only
-  return { nextN, offset, isZero, isNeg, isNegF, offsetF };
+  return randomBytes as TRet<RandomBytes>;
 }
 
 function validateMSMPoints(points: any[], c: any) {
-  if (!Array.isArray(points)) throw new Error('array expected');
+  aarray(points, 'points');
   points.forEach((p, i) => {
@@ -388,6 +402,9 @@ if (!(p instanceof c)) throw new Error('invalid point at index ' + i);
 }
-function validateMSMScalars(scalars: any[], field: any) {
+// Default bound is field membership (0 <= s < field.ORDER); a `maxScalar` override widens it
+// to 0 <= s < maxScalar for callers that accept oversized scalars.
+function validateMSMScalars(scalars: any[], field: any, maxScalar?: bigint) {
   if (!Array.isArray(scalars)) throw new Error('array of scalars expected');
   scalars.forEach((s, i) => {
-    if (!field.isValid(s)) throw new Error('invalid scalar at index ' + i);
+    const ok = maxScalar === undefined ? field.isValid(s) : isPosBig(s) && s < maxScalar;
+    if (!ok) throw new Error('invalid scalar at index ' + i);
   });
@@ -397,39 +414,113 @@ }
 // Since points in different groups cannot be equal (different object constructor),
-// we can have single place to store precomputes.
+// we can have single place to store window sizes.
 // Allows to make points frozen / immutable.
-const pointPrecomputes = new WeakMap<any, any[]>();
+type WnafPrecomputeEntry<T> = { W: number; bits: number; windows: number; comp: T[] };
+/** Result of a constant-time multiply: real point `p`, fake accumulator `f` (discarded). */
+type MulResult<P> = { p: P; f: P };
 const pointWindowSizes = new WeakMap<any, number>();
 
-function getW(P: any): number {
-  // To disable precomputes:
-  // return 1;
-  // `1` is also the uncached sentinel: use the ladder / non-precomputed path.
+function getWindowSize(P: any): number {
+  // `1` is the uncached sentinel: use the non-precomputed (wNAF / fixed-window) path.
   return pointWindowSizes.get(P) || 1;
 }
 
-function assert0(n: bigint): void {
-  // Internal invariant: a non-zero remainder here means the wNAF window decomposition or loop
-  // count is inconsistent, not that the original caller provided a bad scalar.
-  if (n !== _0n) throw new Error('invalid wNAF');
+/** Table of odd multiples [1P, 3P, ..., (2⋅size−1)P]; width-W wNAF uses size = 2^(W−2). */
+function oddMultiples<P extends { double(): P; add(other: P): P }>(p: P, size: number): P[] {
+  const dbl = p.double();
+  const t = [p];
+  for (let j = 1; j < size; j++) t.push(t[j - 1].add(dbl));
+  return t;
 }
 
 /**
- * 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.
+ * Width-W wNAF signed-digit recoding (W >= 2), LSB-first: digits are 0 or odd with
+ * |digit| < 2^(W−1); nonzero density ~1/(W+1) (a nonzero digit is followed by W−1 zeros).
+ */
+function wnafDigits(n: bigint, W: number): number[] {
+  const size = 2 ** W;
+  const half = size / 2;
+  const mask = BigInt(size - 1);
+  const d: number[] = [];
+  while (n > _0n) {
+    let w = 0;
+    if (n & _1n) {
+      w = Number(n & mask); // n mod 2^W, odd
+      if (w >= half) w -= size; // signed residue
+      n -= BigInt(w); // n - w ≡ 0 mod 2^W: next W−1 digits are zero
+    }
+    d.push(w);
+    n >>= _1n;
+  }
+  return d;
+}
+
+/**
+ * Fixed-position signed-window recoding for precomputed wNAF: `n = Σ digits[w]⋅2^(w⋅W)` with
+ * digits in `[−2^(W−1)+1, 2^(W−1)]`. Digit count is fixed by `windows` (callers reserve one
+ * extra window for the final carry), so recoding length does not depend on the scalar.
+ */
+function signedWindowDigits(n: bigint, W: number, windows: number): number[] {
+  const size = 2 ** W;
+  const half = size / 2;
+  const mask = BigInt(size - 1);
+  const shiftBy = BigInt(W);
+  const d: number[] = [];
+  for (let w = 0; w < windows; w++) {
+    let v = Number(n & mask);
+    n >>= shiftBy;
+    if (v > half) {
+      v -= size; // negative digit, carry into the next window
+      n += _1n;
+    }
+    d.push(v);
+  }
+  // Internal invariant: leftover bits mean the window count did not cover the scalar.
+  if (n !== _0n) throw new Error('invalid wnaf');
+  return d;
+}
+
+/**
+ * Shared vartime walk over per-scalar wNAF digit streams: one doubling of a single shared
+ * accumulator per bit position of the longest recoding, one signed table addition per
+ * nonzero digit. `tables[i]` must hold the odd multiples of the i-th point.
+ */
+function wnafWalk<P extends { double(): P; add(other: P): P; negate(): P }>(
+  zero: P,
+  tables: P[][],
+  digits: number[][]
+): P {
+  let max = 0;
+  for (const d of digits) max = Math.max(max, d.length);
+  let acc = zero;
+  for (let bit = max - 1; bit >= 0; bit--) {
+    if (bit !== max - 1) acc = acc.double();
+    for (let i = 0; i < digits.length; i++) {
+      const w = digits[i][bit]; // reads past shorter recodings yield undefined, skipped below
+      if (w) {
+        const item = tables[i][(Math.abs(w) - 1) >> 1];
+        acc = acc.add(w < 0 ? item.negate() : item);
+      }
+    }
+  }
+  return acc;
+}
+
+/**
+ * Elliptic curve multiplication of Point by scalar.
+ * Routes between cached-table, fixed-window, and one-shot wNAF paths; entry points validate
+ * their own scalars (`mulCT`/`mulCTBlinded`: `1 <= s < Fn.ORDER`; `mulUnsafe`: up to the
+ * `Fn.ORDER^4` DoS cap via {@link mulAddUnsafe}).
+ * Table generation is expensive and happens on first call of `multiply()`
+ * (or eagerly via `precompute(W, false)`). 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 a 2d JS array of windows instead of a single window.
- * This would allow windows to be in different memory locations.
+ * Cached algorithm is signed fixed-window wNAF:
+ * - table stores, for every window w, the multiples `[1..2^(W−1)]⋅2^(w⋅W)⋅P` — all doublings
+ *   are baked in, so a multiplication is exactly one table addition per window
+ * - window count is fixed (`ceil(bits/W) + 1`), so the point-operation count is scalar-independent
+ *   (basis of the constant-time path)
+ * - for a 256-bit curve and W=6: 44⋅32 = 1408 table points, 44 additions per multiply
+ * - secret scalars are additionally blinded (see {@link ScalarMultiplier.mulCTBlinded}), which
+ *   widens tables by 128 bits
  * @param Point - Point constructor.
- * @param bits - Scalar bit length.
+ * @param randomBytes - RNG used for scalar blinding; required by the blinded secret path.
  * @example
@@ -439,171 +530,269 @@ * Elliptic curve multiplication of Point by scalar.
  * ```ts
- * import { wNAF } from '@noble/curves/abstract/curve.js';
+ * import { ScalarMultiplier } from '@noble/curves/abstract/curve.js';
  * import { p256 } from '@noble/curves/nist.js';
- * const ladder = new wNAF(p256.Point, p256.Point.Fn.BITS);
+ * const mul = new ScalarMultiplier(p256.Point);
  * ```
  */
-export class wNAF<PC extends PC_ANY> {
+export class ScalarMultiplier<PC extends PC_ANY> {
+  private readonly Point: PC;
   private readonly BASE: PC_P<PC>;
   private readonly ZERO: PC_P<PC>;
-  private readonly Fn: PC['Fn'];
+  private readonly randomBytes?: RandomBytes;
+  private readonly wnafPrecomputes = new WeakMap<PC_P<PC>, WnafPrecomputeEntry<PC_P<PC>>[]>();
+  private baseCanBeBlinded: boolean | undefined;
   readonly bits: number;
 
   // Parametrized with a given Point class (not individual point)
-  constructor(Point: PC, bits: number) {
+  constructor(Point: PC, randomBytes?: RandomBytes) {
+    validatePointCons(Point);
+    // Probe the RNG once (see {@link probeRandomBytes}): in environments without working
+    // randomness (e.g. no WebCrypto), shouldBlind() then routes secret multiplication to the
+    // unblinded constant-time path instead of throwing on every multiply(). The shape of
+    // returned bytes is still validated on every blinded call, where breakage fails closed.
+    this.randomBytes = probeRandomBytes(randomBytes, BLIND_BYTES);
+    this.Point = Point;
     this.BASE = Point.BASE;
     this.ZERO = Point.ZERO;
-    this.Fn = Point.Fn;
-    this.bits = bits;
+    this.bits = Point.Fn.BITS;
   }
 
-  // non-const time multiplication ladder
-  _unsafeLadder(elm: PC_P<PC>, n: bigint, p: PC_P<PC> = this.ZERO): PC_P<PC> {
-    let d: PC_P<PC> = 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.
+   * Creates a signed fixed-window wNAF precomputation table: for every window w, the
+   * multiples `[1..2^(W−1)]⋅2^(w⋅W)⋅P`, flattened. All doublings are baked into the table,
+   * so cached multiplication is additions-only. `windows = ceil(bits/W) + 1`: the extra
+   * window absorbs the final carry of signed-digit recoding.
+   * For a 256-bit curve and W=6, the table is 44⋅32 = 1408 points.
    * @param point - Point instance
    * @param W - window size
-   * @returns precomputed point tables flattened to a single array
+   * @param bits - scalar bitlength the table must cover
    */
-  private precomputeWindow(point: PC_P<PC>, W: number): PC_P<PC>[] {
-    const { windows, windowSize } = calcWOpts(W, this.bits);
-    const points: PC_P<PC>[] = [];
-    let p: PC_P<PC> = point;
-    let base = p;
-    for (let window = 0; window < windows; window++) {
-      base = p;
-      points.push(base);
-      // i=1, bc we skip 0
-      for (let i = 1; i < windowSize; i++) {
-        base = base.add(p);
-        points.push(base);
+  private buildWnafTable(point: PC_P<PC>, W: number, bits: number): WnafPrecomputeEntry<PC_P<PC>> {
+    // W needs no re-validation: its only source is setWindowSize(), which enforces
+    // 1 <= W <= Fn.BITS <= bits (the blinded path only ever widens bits) and caps the
+    // resulting table at ~2 GiB (sized against the wider blinded layout).
+    const windows = Math.ceil(bits / W) + 1;
+    const half = 2 ** (W - 1);
+    const comp: PC_P<PC>[] = [];
+    let base = point;
+    for (let w = 0; w < windows; w++) {
+      let acc = base;
+      for (let i = 0; i < half; i++) {
+        comp.push(acc);
+        acc = acc.add(base);
       }
-      p = base.double();
+      base = comp[comp.length - 1].double(); // 2⋅(2^(W−1)⋅base) = next window's base
     }
-    return points;
+    return { W, bits, windows, comp };
   }
 
   /**
-   * 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
+   * Implements ec multiplication using precomputed signed fixed-window wNAF tables.
+   * Constant-time: fixed window count with one table addition per window — zero digits feed
+   * the fake accumulator — and no doublings; the lookup scans the whole window slice.
+   * Scalar bounds are validated by the public entry points ({@link ScalarMultiplier.mulCT},
+   * {@link ScalarMultiplier.mulCTBlinded}, {@link ScalarMultiplier.mulUnsafe});
+   * signedWindowDigits throws if `n` exceeds the table.
    * @returns real and fake (for const-time) points
    */
-  private wNAF(W: number, precomputes: PC_P<PC>[], n: bigint): { p: PC_P<PC>; f: PC_P<PC> } {
-    // Scalar should be smaller than field order
-    if (!this.Fn.isValid(n)) throw new Error('invalid scalar');
-    // Accumulators
+  private wnafCachedCT(precomputes: WnafPrecomputeEntry<PC_P<PC>>, n: bigint): MulResult<PC_P<PC>> {
+    const { W, windows, comp } = precomputes;
+    const half = 2 ** (W - 1);
+    const digits = signedWindowDigits(n, W, windows);
     let p = this.ZERO;
     let f = this.BASE;
-    // This code was first written with assumption that 'f' and 'p' will never be infinity point:
-    // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,
-    // there is negate now: it is possible that negated element from low value
-    // would be the same as high element, which will create carry into next window.
-    // It's not obvious how this can fail, but still worth investigating later.
-    const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
-      // (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise
-      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
-      n = nextN;
-      if (isZero) {
-        // bits are 0: add garbage to fake point
-        // Important part for const-time getPublicKey: add random "noise" point to f.
-        f = f.add(negateCt(isNegF, precomputes[offsetF]));
-      } else {
-        // bits are 1: add to result point
-        p = p.add(negateCt(isNeg, precomputes[offset]));
-      }
+    for (let w = 0; w < windows; w++) {
+      const digit = digits[w];
+      const start = w * half;
+      // Data-oblivious select: touch every entry of the window before the digit branch.
+      const idx = Math.abs(digit) - 1; // -1 for zero digits: matches nothing, `sel` unused
+      let sel = comp[start];
+      for (let i = 1; i < half; i++) sel = i === idx ? comp[start + i] : sel;
+      const neg = sel.negate(); // compute both signs; the digit only picks one
+      if (digit === 0) f = f.add(comp[start]);
+      else p = p.add(digit < 0 ? neg : sel);
     }
-    assert0(n);
-    // Return both real and fake points so JIT keeps the noise path alive.
-    // Known caveat: negate/carry interactions can still drive `f` to infinity even when `p` is not,
-    // which weakens the noise path and leaves this only "less const-time" by about one bigint mul.
     return { p, f };
   }
 
-  /**
-   * Implements unsafe EC multiplication using precomputed tables
-   * and w-ary non-adjacent form.
-   * @param acc - accumulator point to add result of multiplication
-   * @returns point
-   */
-  private wNAFUnsafe(
+  // Cache key is point identity plus (W, bits); at most two entries exist per point (public-width
+  // `Fn.BITS` and blinded `Fn.BITS + BLIND_BITS`). Callers must not reuse the same point with
+  // incompatible `transform(...)` layouts and expect a separate cache entry.
+  private getWnafPrecomputes(
     W: number,
-    precomputes: PC_P<PC>[],
-    n: bigint,
-    acc: PC_P<PC> = this.ZERO
-  ): PC_P<PC> {
-    const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
-      if (n === _0n) break; // Early-exit, skip 0 value
-      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
-      n = nextN;
-      if (isZero) {
-        // Window bits are 0: skip processing.
-        // Move to next window.
-        continue;
-      } else {
-        const item = precomputes[offset];
-        acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM
+    point: PC_P<PC>,
+    bits: number,
+    transform?: Mapper<PC_P<PC>>
+  ): WnafPrecomputeEntry<PC_P<PC>> {
+    let entries = this.wnafPrecomputes.get(point);
+    let comp = entries?.find((entry) => entry.W === W && entry.bits === bits);
+    if (!comp) {
+      comp = this.buildWnafTable(point, W, bits);
+      if (typeof transform === 'function') comp = { ...comp, comp: transform(comp.comp) };
+      if (!entries) {
+        entries = [];
+        this.wnafPrecomputes.set(point, entries);
       }
+      entries.push(comp);
     }
-    assert0(n);
-    return acc;
+    return comp;
   }
 
-  private getPrecomputes(W: number, point: PC_P<PC>, transform?: Mapper<PC_P<PC>>): PC_P<PC>[] {
-    // Cache key is only point identity plus the remembered window size; callers must not reuse the
-    // same point with incompatible `transform(...)` layouts and expect a separate cache entry.
-    let comp = pointPrecomputes.get(point);
-    if (!comp) {
-      comp = this.precomputeWindow(point, W) as PC_P<PC>[];
-      if (W !== 1) {
-        // Doing transform outside of if brings 15% perf hit
-        if (typeof transform === 'function') comp = transform(comp);
-        pointPrecomputes.set(point, comp);
-      }
+  private assertPoint(point: PC_P<PC>): void {
+    if (!(point instanceof this.Point))
+      throw new TypeError('"point" expected Point instance, got type=' + typeof point);
+  }
+
+  // Shared prologue of the constant-time entry points. Rejects scalar 0: in key/signature-style
+  // callers a zero scalar means broken upstream plumbing, and concrete Points already reject it.
+  // Uses inRange instead of Fn.isValidNot0: validateField() only certifies the arithmetic subset.
+  private validateMulInput(point: PC_P<PC>, scalar: bigint): void {
+    this.assertPoint(point);
+    if (!inRange(scalar, _1n, this.Point.Fn.ORDER)) throw new Error('invalid scalar');
+  }
+
+  // Constant-time dispatch shared by mulCT / mulCTBlinded. Un-precomputed points (W===1, e.g.
+  // ECDH peer keys) skip building a throwaway cached table in favor of a small fixed-window
+  // multiply. `n` must be < 2^bits.
+  private runCT(
+    point: PC_P<PC>,
+    n: bigint,
+    bits: number,
+    transform?: Mapper<PC_P<PC>>
+  ): MulResult<PC_P<PC>> {
+    const W = getWindowSize(point);
+    if (W === 1) return this.fixedWindowCT(point, n, bits);
+    return this.wnafCachedCT(this.getWnafPrecomputes(W, point, bits, transform), n);
+  }
+
+  mulCT(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>): MulResult<PC_P<PC>> {
+    this.validateMulInput(point, scalar);
+    return this.runCT(point, scalar, this.bits, transform);
+  }
+
+  mulCTBlinded(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>): MulResult<PC_P<PC>> {
+    this.validateMulInput(point, scalar);
+    // Blinding computes n = scalar + blind*Fn.ORDER, then n*P via a constant-time multiply. This
+    // equals scalar*P only when Fn.ORDER*P == O; callers guarantee that via shouldBlind() (always
+    // for cofactor-1 curves; for cofactored curves only BASE, and only after checking BASE*n == O).
+    // Fail before building the (large) precompute table if randomness is unavailable.
+    if (this.randomBytes === undefined)
+      throw new Error('randomBytes is required for scalar blinding');
+    const bits = this.Point.Fn.BITS + BLIND_BITS;
+    const blind = this.randomBytes(BLIND_BYTES);
+    if (!isBytes(blind) || blind.length !== BLIND_BYTES)
+      throw new Error('randomBytes returned invalid byte array');
+    // Force the top two bits of the 128-bit blind to 10xxxxxx, so blind is in [2^127, 1.5*2^127):
+    // * `| 0x80` (bit 127 = 1) is the load-bearing part: it guarantees blind >= 2^127, so the blind
+    //   is always a full-width, nonzero factor and the scalar is masked even with a degenerate RNG.
+    // * `& 0x3f` (bit 126 = 0) is a safety margin: it caps blind < 1.5*2^127, keeping
+    //   blind*Fn.ORDER + scalar < 0.75*2^(nBits+128), i.e. ~half a window below the 2^(nBits+128)
+    //   ceiling. Not strictly required for the bound (see below), but it reserves headroom so the
+    //   guarantee does not rest on the tight `Fn.ORDER < 2^Fn.BITS` fact and the final carry window
+    //   only ever holds a small carry, never a full digit.
+    blind[0] = (blind[0] & 0x3f) | 0x80;
+    // Even at the extreme (blind < 2^128, scalar < Fn.ORDER < 2^nBits): n <= 2^128*Fn.ORDER - 1 <
+    // 2^(nBits+128), so n stays below 2^bits and within the blinded table's
+    // window count. Both cached CT kernels run a fixed number of windows/rows with one point-add
+    // each, so the add count is independent of scalar (constant-time).
+    const n = scalar + bytesToNumberBE(blind) * this.Point.Fn.ORDER;
+    return this.runCT(point, n, bits, transform);
+  }
+
+  /**
+   * Constant-time multiplication `n*point` for an un-precomputed point, via a small fixed window.
+   * A cached wNAF table only pays off when reused; a flat 2^FW_WINDOW table (`size-1` adds) is
+   * far cheaper to build for a single use. The point-operation sequence is independent of `n`:
+   * build the table, then per window exactly FW_WINDOW doublings, a data-oblivious scan over
+   * every table entry, and one addition (adds the identity when the window digit is 0 — never
+   * skipped).
+   *
+   * `n` must be `< 2^bits`. Assumes complete addition (adding the identity costs the same as any
+   * add), which holds for the Weierstrass/Edwards point types used here. The table is left in
+   * projective form (no normalizeZ): normalizing this small a table costs more than the
+   * mixed-add savings it would buy for a single multiply.
+   * @returns real point `p`; `f` duplicates it only to match {@link wnafCachedCT}'s return shape
+   * (this path needs no fake accumulator — its op-count is already scalar-independent).
+   */
+  private fixedWindowCT(point: PC_P<PC>, n: bigint, bits: number): MulResult<PC_P<PC>> {
+    const W = FW_WINDOW;
+    const size = 1 << W;
+    const mask = bitMask(W);
+    // Flat table [O, point, 2*point, ..., (size-1)*point].
+    const table: PC_P<PC>[] = new Array(size);
+    table[0] = this.ZERO;
+    for (let i = 1; i < size; i++) table[i] = table[i - 1].add(point);
+    // Horner MSB->LSB. windows*W >= bits and n < 2^bits, so every bit of n is consumed.
+    const windows = Math.ceil(bits / W);
+    let acc = this.ZERO;
+    for (let window = windows - 1; window >= 0; window--) {
+      // W doublings per window; skipped for the first (topmost) window, where acc is still the
+      // identity. The skip is scalar-independent: it depends only on the loop index.
+      if (window !== windows - 1) for (let d = 0; d < W; d++) acc = acc.double();
+      const digit = Number((n >> BigInt(window * W)) & mask);
+      // Data-oblivious select: touch every entry, same as wnafCachedCT.
+      let sel = table[0];
+      for (let i = 1; i < size; i++) sel = i === digit ? table[i] : sel;
+      acc = acc.add(sel); // one add per window, even for digit 0
     }
-    return comp;
+    return { p: acc, f: acc };
   }
 
-  cached(
+  private shouldBlind(point: PC_P<PC>, cofactor: bigint): boolean {
+    // No usable RNG (probed in the constructor): blinding is impossible, use the plain CT path.
+    if (this.randomBytes === undefined) return false;
+    if (cofactor === _1n) return true;
+    if (point !== this.BASE) return false;
+    if (this.baseCanBeBlinded === undefined)
+      this.baseCanBeBlinded = this.mulUnsafe(this.BASE, this.Point.Fn.ORDER).is0();
+    return this.baseCanBeBlinded;
+  }
+
+  mulSecret(
     point: PC_P<PC>,
     scalar: bigint,
+    cofactor: bigint,
     transform?: Mapper<PC_P<PC>>
-  ): { p: PC_P<PC>; f: PC_P<PC> } {
-    const W = getW(point);
-    return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+  ): MulResult<PC_P<PC>> {
+    return this.shouldBlind(point, cofactor)
+      ? this.mulCTBlinded(point, scalar, transform)
+      : this.mulCT(point, scalar, transform);
   }
 
-  unsafe(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>, prev?: PC_P<PC>): PC_P<PC> {
-    const W = getW(point);
-    if (W === 1) return this._unsafeLadder(point, scalar, prev); // For W=1 ladder is ~x2 faster
-    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+  mulUnsafe(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>): PC_P<PC> {
+    this.assertPoint(point);
+    if (!isPosBig(scalar)) throw new Error('invalid scalar');
+    const W = getWindowSize(point);
+    // W === 1 (un-precomputed): one-shot width-4 wNAF via {@link mulAddUnsafe} with L=1 —
+    // a cached table would be thrown away after one use. `allowOversized` swaps the
+    // `s < Fn.ORDER` check for mulAddUnsafe's `Fn.ORDER^4` DoS cap.
+    //
+    // Oversized scalar could happen when:
+    // a) user passes large scalar on their own (rare)
+    // b) `assertValidity()` calls `isTorsionFree()`, which multiplies point by `Fn.ORDER`
+    if (W === 1 || scalar >= this.Point.Fn.ORDER)
+      return mulAddUnsafe(this.Point, [point], [scalar], true);
+    // Precomputed points reuse the CT kernel (fake accumulator discarded): with W=6 only
+    // ~1/64 of window-adds are skippable, so a dedicated vartime kernel saved just ~6% on
+    // this path while doubling the cached-table code surface.
+    const precomputes = this.getWnafPrecomputes(W, point, this.bits, transform);
+    return this.wnafCachedCT(precomputes, scalar).p;
   }
 
-  // We calculate precomputes for elliptic curve point multiplication
-  // using windowed method. This specifies window size and
-  // stores precomputed values. Usually only base point would be precomputed.
-  createCache(P: PC_P<PC>, W: number): void {
+  // Remembers the window size used for precomputed wNAF multiplication of the given point
+  // and drops any previously built tables. Usually only the base point is precomputed.
+  // W=1 resets the point to the un-precomputed (table-less) paths.
+  // W is additionally capped so tables stay under ~2 GiB ({@link TABLE_BYTES_MAX}).
+  setWindowSize(point: PC_P<PC>, W: number): void {
+    this.assertPoint(point);
     validateW(W, this.bits);
-    pointWindowSizes.set(P, W);
-    pointPrecomputes.delete(P);
+    // Size against the widest table this W can produce: the blinded path adds BLIND_BITS.
+    const windows = Math.ceil((this.bits + BLIND_BITS) / W) + 1;
+    validateTableBytes(windows * 2 ** (W - 1), this.Point.Fp.BYTES);
+    pointWindowSizes.set(point, W);
+    this.wnafPrecomputes.delete(point);
   }
 
-  hasCache(elm: PC_P<PC>): boolean {
-    return getW(elm) !== 1;
+  // True when a window size is set: tables themselves are built lazily on first multiply.
+  hasWindowSize(point: PC_P<PC>): boolean {
+    return getWindowSize(point) !== 1;
   }
@@ -613,35 +802,45 @@ }
 /**
- * Endomorphism-specific multiplication for Koblitz curves.
- * Cost: 128 dbl, 0-256 adds.
- * @param Point - Point constructor.
- * @param point - Input point.
- * @param k1 - First non-negative absolute scalar chunk.
- * @param k2 - Second non-negative absolute scalar chunk.
- * @returns Partial multiplication results.
+ * Combined multi-scalar multiplication `Σ scalars[i]⋅points[i]` via interleaved width-4 wNAF
+ * (Strauss–Shamir). Every input gets its own table of odd multiples `[1P, 3P, 5P, 7P]` and
+ * signed-digit recoding, but all walks share one doubling chain, so total cost is
+ * `~bits` doublings + `L⋅bits/5` additions instead of `L⋅bits` doublings for separate
+ * multiplications. Intended for the 2-4 point shapes of signature verification
+ * (`R = u1⋅G + u2⋅P`); use {@link pippenger} for larger batches.
+ *
+ * Not constant-time: only for public inputs. Scalars must satisfy `0 <= s < Fn.ORDER`;
+ * fold negative signs into the points before calling.
+ * @param c - Point constructor.
+ * @param points - Array of curve points.
+ * @param scalars - Array of non-negative scalars, same length as points.
+ * @param allowOversized - Replace the `s < Fn.ORDER` scalar check with a `Fn.ORDER^4` DoS cap.
+ *   Off by default. For scalars that must NOT be reduced mod ORDER: torsion checks
+ *   (`Fn.ORDER⋅P ≟ O`) and cofactor-clearing multiples. Walk length grows with `bitLen(s)`.
+ * @returns Combined multiplication result; identity for empty input.
+ * @throws If the point set or scalar set is invalid. {@link Error}
  * @example
- * Endomorphism-specific multiplication for Koblitz curves.
+ * Combined multi-scalar multiplication via Strauss–Shamir.
  *
  * ```ts
- * import { mulEndoUnsafe } from '@noble/curves/abstract/curve.js';
- * import { secp256k1 } from '@noble/curves/secp256k1.js';
- * const parts = mulEndoUnsafe(secp256k1.Point, secp256k1.Point.BASE, 3n, 5n);
+ * import { mulAddUnsafe } from '@noble/curves/abstract/curve.js';
+ * import { p256 } from '@noble/curves/nist.js';
+ * const G = p256.Point.BASE;
+ * const R = mulAddUnsafe(p256.Point, [G, G.double()], [2n, 3n]); // 2⋅G + 3⋅(2⋅G)
  * ```
  */
-export function mulEndoUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(
-  Point: PC,
-  point: P,
-  k1: bigint,
-  k2: bigint
-): { p1: P; p2: P } {
-  let acc = point;
-  let p1 = Point.ZERO;
-  let p2 = Point.ZERO;
-  while (k1 > _0n || k2 > _0n) {
-    if (k1 & _1n) p1 = p1.add(acc);
-    if (k2 & _1n) p2 = p2.add(acc);
-    acc = acc.double();
-    k1 >>= _1n;
-    k2 >>= _1n;
-  }
-  return { p1, p2 };
+export function mulAddUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(
+  c: PC,
+  points: P[],
+  scalars: bigint[],
+  allowOversized: boolean = false
+): P {
+  validatePointCons(c);
+  validateMSMPoints(points, c);
+  abool(allowOversized, 'allowOversized');
+  // Oversized cap is ORDER^4: hard bound to mitigate DoS, walk length grows with bitLen(s).
+  validateMSMScalars(scalars, c.Fn, allowOversized ? c.Fn.ORDER ** _4n : undefined);
+  if (points.length !== scalars.length)
+    throw new Error('arrays of points and scalars must have equal length');
+  const tables = points.map((p) => oddMultiples(p, 4));
+  const digits = scalars.map((n) => wnafDigits(n, 4));
+  return wnafWalk(c.ZERO, tables, digits);
 }
@@ -653,3 +852,9 @@
  * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.
- * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.
+ * Point-operation count is scalar-independent (for same L), even when 1 point + scalar, or when
+ * scalar = 0 — but bucket indices are scalar windows, so the memory-access pattern is
+ * scalar-dependent: do not rely on this for secret scalars.
+ *
+ * A repaired LFG bucket-set variant from ePrint 2024/750 was benchmarked on BLS12-381 G1
+ * against this implementation: ~1.4x faster at 2048 points and ~1.1-1.25x faster at
+ * 4096-32768 points, at the cost of extra recoding and multiplier-table complexity.
  * @param c - Curve Point constructor
@@ -674,8 +879,4 @@ * @param points - array of L curve points
 ): P {
-  // If we split scalars by some window (let's say 8 bits), every chunk will only
-  // take 256 buckets even if there are 4096 scalars, also re-uses double.
-  // TODO:
-  // - https://eprint.iacr.org/2024/750.pdf
-  // - https://tches.iacr.org/index.php/TCHES/article/view/10287
   // 0 is accepted in scalars
+  validatePointCons(c);
   const fieldN = c.Fn;
@@ -687,4 +888,5 @@ validateMSMPoints(points, c);
   if (plength !== slength) throw new Error('arrays of points and scalars must have equal length');
-  // if (plength === 0) throw new Error('array must be of length >= 2');
   const zero = c.ZERO;
+  // Without this, the window loop below would still run ~Fn.BITS doublings of ZERO.
+  if (plength === 0) return zero as P;
   const wbits = bitLen(BigInt(plength));
@@ -718,20 +920,33 @@ let windowSize = 1; // bits
 /**
- * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
+ * Interleaved wNAF multi-scalar multiplication (MSM, Pa + Qb + Rc + ...) over a FIXED set
+ * of points: each point gets a one-time table of odd multiples
+ * `[1P, 3P, ..., (2^(W−1)−1)P]`, and the returned closure evaluates MSMs against those
+ * tables. All scalars share one doubling chain (Straus 1964) — one doubling per scalar bit
+ * plus one signed table addition per nonzero width-W wNAF digit (density ~1/(W+1)) — the
+ * "interleaving" method of Möller, "Algorithms for multi-exponentiation" (SAC 2001).
+ *
+ * Table memory is `L⋅2^(W−2)` points, capped at ~2 GiB. Prefer this over {@link pippenger}
+ * when the same points are reused across many MSMs (fixed-base commitments etc.) and up to a
+ * few hundred points; prefer pippenger for one-shot MSMs or thousands of points, where
+ * bucketing beats per-point tables.
+ *
+ * Not constant-time (zero digits are skipped): public inputs only.
  * @param c - Curve Point constructor
- * @param points - array of L curve points
- * @param windowSize - Precompute window size.
- * @returns Function which multiplies points with scalars. The closure accepts
- *   `scalars.length <= points.length`, and omitted trailing scalars are treated as zero.
+ * @param points - array of L curve points, captured by the returned closure
+ * @param windowSize - window width W in bits, from 2 to Fn.BITS; also capped so the
+ *   per-closure tables stay under ~2 GiB
+ * @returns Function which multiplies points with scalars. The closure accepts at most
+ *   `points.length` scalars, and omitted trailing scalars are treated as zero.
  * @throws If the point set or precompute window is invalid. {@link Error}
  * @example
- * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
+ * Interleaved wNAF multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
  *
  * ```ts
- * import { precomputeMSMUnsafe } from '@noble/curves/abstract/curve.js';
+ * import { interleavedMSMUnsafe } from '@noble/curves/abstract/curve.js';
  * import { p256 } from '@noble/curves/nist.js';
- * const msm = precomputeMSMUnsafe(p256.Point, [p256.Point.BASE], 4);
+ * const msm = interleavedMSMUnsafe(p256.Point, [p256.Point.BASE], 4);
  * const point = msm([3n]);
  * ```
  */
-export function precomputeMSMUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(
+export function interleavedMSMUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(
   c: PC,
@@ -741,69 +956,18 @@ points: P[],
 ): (scalars: bigint[]) => P {
-  /**
-   * Performance Analysis of Window-based Precomputation
-   *
-   * Base Case (256-bit scalar, 8-bit window):
-   * - Standard precomputation requires:
-   *   - 31 additions per scalar × 256 scalars = 7,936 ops
-   *   - Plus 255 summary additions = 8,191 total ops
-   *   Note: Summary additions can be optimized via accumulator
-   *
-   * Chunked Precomputation Analysis:
-   * - Using 32 chunks requires:
-   *   - 255 additions per chunk
-   *   - 256 doublings
-   *   - Total: (255 × 32) + 256 = 8,416 ops
-   *
-   * Memory Usage Comparison:
-   * Window Size | Standard Points | Chunked Points
-   * ------------|-----------------|---------------
-   *     4-bit   |     520         |      15
-   *     8-bit   |    4,224        |     255
-   *    10-bit   |   13,824        |   1,023
-   *    16-bit   |  557,056        |  65,535
-   *
-   * Key Advantages:
-   * 1. Enables larger window sizes due to reduced memory overhead
-   * 2. More efficient for smaller scalar counts:
-   *    - 16 chunks: (16 × 255) + 256 = 4,336 ops
-   *    - ~2x faster than standard 8,191 ops
-   *
-   * Limitations:
-   * - Not suitable for plain precomputes (requires 256 constant doublings)
-   * - Performance degrades with larger scalar counts:
-   *   - Optimal for ~256 scalars
-   *   - Less efficient for 4096+ scalars (Pippenger preferred)
-   */
+  validatePointCons(c);
   const fieldN = c.Fn;
-  validateW(windowSize, fieldN.BITS);
+  // Signed odd digits need at least width 2 (W=2 is plain NAF with a single-entry table).
+  validateW(windowSize, fieldN.BITS, 2);
   validateMSMPoints(points, c);
-  const zero = c.ZERO;
-  const tableSize = 2 ** windowSize - 1; // table size (without zero)
-  const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item
-  const MASK = bitMask(windowSize);
-  const tables = points.map((p: P) => {
-    const res = [];
-    for (let i = 0, acc = p; i < tableSize; i++) {
-      res.push(acc);
-      acc = acc.add(p);
-    }
-    return res;
-  });
+  validateTableBytes(points.length * 2 ** (windowSize - 2), c.Fp.BYTES);
+  const tables = points.map((p) => oddMultiples(p, 2 ** (windowSize - 2)));
   return (scalars: bigint[]): P => {
     validateMSMScalars(scalars, fieldN);
     if (scalars.length > points.length)
-      throw new Error('array of scalars must be smaller than array of points');
-    let res = zero;
-    for (let i = 0; i < chunks; i++) {
-      // No need to double if accumulator is still zero.
-      if (res !== zero) for (let j = 0; j < windowSize; j++) res = res.double();
-      const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);
-      for (let j = 0; j < scalars.length; j++) {
-        const n = scalars[j];
-        const curr = Number((n >> shiftBy) & MASK);
-        if (!curr) continue; // skip zero scalars chunks
-        res = res.add(tables[j][curr - 1]);
-      }
-    }
-    return res;
+      throw new Error('array of scalars must not be larger than array of points');
+    return wnafWalk(
+      c.ZERO,
+      tables,
+      scalars.map((n) => wnafDigits(n, windowSize))
+    );
   };
@@ -858,3 +1022,3 @@ }
  * @param CURVE - Curve parameters.
- * @param curveOpts - Optional field overrides:
+ * @param curveOpts - Optional field overrides. See {@link FpFn}:
  *   - `Fp` (optional): Optional base-field override.
@@ -886,8 +1050,11 @@ *   - `Fn` (optional): Optional scalar-field override.
 ): TRet<FpFn<T> & { CURVE: ValidCurveParams<T> }> {
+  if (type !== 'weierstrass' && type !== 'edwards')
+    throw new Error('expected curve type "weierstrass" or "edwards"');
   if (FpFnLE === undefined) FpFnLE = type === 'edwards';
   if (!CURVE || typeof CURVE !== 'object') throw new Error(`expected valid ${type} CURVE object`);
+  // Validate before reading Fp/Fn so explicit null fails with an options-object error.
+  validateObject(curveOpts);
   for (const p of ['p', 'n', 'h'] as const) {
     const val = CURVE[p];
-    if (!(typeof val === 'bigint' && val > _0n))
-      throw new Error(`CURVE.${p} must be positive bigint`);
+    if (!(isPosBig(val) && val !== _0n)) throw new Error(`CURVE.${p} must be positive bigint`);
   }
@@ -907,6 +1074,3 @@ const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);
 
-type KeygenFn = (
-  seed?: Uint8Array,
-  isCompressed?: boolean
-) => { secretKey: Uint8Array; publicKey: Uint8Array };
+type KeygenFn = (seed?: Uint8Array) => { secretKey: Uint8Array; publicKey: Uint8Array };
 /**
@@ -913,0 +1077,0 @@ * @param randomSecretKey - Secret-key generator.

src/abstract/edwards.ts

@@ -31,3 +31,4 @@ /**
   normalizeZ,
-  wNAF,
+  ScalarMultiplier,
+  validatePointCons,
   type AffinePoint,
@@ -38,7 +39,7 @@ type CurveLengths,
 } from './curve.ts';
-import { type IField } from './modular.ts';
+import { FpLegendre, type IField } from './modular.ts';
 
 // Be friendly to bad ECMAScript parsers by not using bigint literals
 // prettier-ignore
-const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _8n = /* @__PURE__ */ BigInt(8);
+const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _4n = /* @__PURE__ */ BigInt(4), _8n = /* @__PURE__ */ BigInt(8);
 
@@ -125,2 +126,4 @@ /** Extended Edwards point with X/Y/Z/T coordinates. */
   uvRatio: (u: bigint, v: bigint) => { isValid: boolean; value: bigint };
+  /** RNG override used for scalar blinding. */
+  randomBytes: (bytesLength?: number) => TRet<Uint8Array>;
 }>;
@@ -145,2 +148,6 @@
   mapToCurve: (scalar: bigint[]) => AffinePoint<bigint>;
+  /** Optional conversion from this Edwards curve to a birational/isogenous Montgomery curve. */
+  toMontgomery: (point: EdwardsPoint) => TRet<Uint8Array>;
+  /** Optional secret-key conversion for the same Montgomery curve as `toMontgomery`. */
+  toMontgomerySecret: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
   /** Optional prehash function used before signing or verifying messages. */
@@ -192,2 +199,4 @@ prehash: FHash;
    *   - `zip215` (optional): Whether to accept ZIP-215 encodings.
+   * @throws Malformed argument or option types may throw; `false` means well-formed inputs
+   *   failed verification. {@link Error}
    * @returns Whether the signature is valid.
@@ -217,2 +226,3 @@ */
      * Converts ed public key to x public key.
+     * Throws when the Edwards curve has no supported Montgomery conversion.
      *
@@ -237,2 +247,3 @@ * There is NO `fromMontgomery`:
      * Converts ed secret key to x secret key.
+     * Throws when the Edwards curve has no supported Montgomery conversion.
      * @example
@@ -280,3 +291,3 @@ * Converts ed secret key to x secret key.
  *   validation here adds about 10-15ms to heavyweight imports like ed448.
- *   The returned constructor also eagerly marks `Point.BASE` for W=8
+ *   The returned constructor also eagerly marks `Point.BASE` for W=6
  *   precompute caching. Some code paths still assume
@@ -298,2 +309,3 @@ *   `Fp.BYTES === Fn.BYTES`, so mismatched byte lengths are not fully audited here.
 ): EdwardsPointCons {
+  validateObject(extraOpts as any, {}, {}, 'extraOpts');
   const opts = extraOpts as EdwardsExtraOpts;
@@ -304,11 +316,22 @@ const validated = createCurveFields('edwards', params as EdwardsOpts, opts, opts.FpFnLE);
   const { h: cofactor } = CURVE;
-  validateObject(opts, {}, { uvRatio: 'function' });
+  // The unified add-2008-hwcd formulas (see EdwardsPoint.add/double) are complete —
+  // exception-free for every input pair — only when a is a square and d a non-square in Fp
+  // (Bernstein–Birkner–Joye–Lange–Peters, "Twisted Edwards curves", thm 3.3). The constant-time
+  // kernels in curve.ts assume completeness, so an incomplete curve could silently produce
+  // wrong results on exceptional inputs. Fail construction instead.
+  if (FpLegendre(Fp, CURVE.a) !== 1)
+    throw new Error('edwards: CURVE.a must be a square in Fp for complete addition formulas');
+  if (FpLegendre(Fp, CURVE.d) !== -1)
+    throw new Error('edwards: CURVE.d must be a non-square in Fp for complete addition formulas');
+  validateObject(opts, {}, { uvRatio: 'function', randomBytes: 'function' });
+  const randomBytes = opts.randomBytes === undefined ? wcRandomBytes : opts.randomBytes;
 
-  // Important:
-  // There are some places where Fp.BYTES is used instead of nByteLength.
-  // So far, everything has been tested with curves of Fp.BYTES == nByteLength.
-  // TODO: test and find curves which behave otherwise.
-  const MASK = _2n << (BigInt(Fn.BYTES * 8) - _1n);
-  const modP = (n: bigint) => Fp.create(n); // Function overrides
+  // Coordinate and ZIP-215 bounds follow the base-field byte container, not scalar bytes.
+  const MASK = _2n << (BigInt(Fp.BYTES * 8) - _1n);
 
+  function isOdd(n: bigint): boolean {
+    if (!Fp.isOdd) throw new Error('Field does not have .isOdd()');
+    return Fp.isOdd(n);
+  }
+
   // sqrt(u/v)
@@ -331,2 +354,10 @@ const uvRatio =
 
+  // Multiplication by param `a` sits on the double() / add() hot paths. For the common twists
+  // a=-1 (ed25519, jubjub) and a=1 (ed448) the full field multiplication is replaced with
+  // negation / identity. Selection depends only on public curve constants.
+  const mulA =
+    Fp.eql(CURVE.a, Fp.neg(Fp.ONE)) ? (x: bigint): bigint => Fp.neg(x)
+    : Fp.eql(CURVE.a, Fp.ONE) ? (x: bigint): bigint => x
+    : (x: bigint): bigint => Fp.mul(CURVE.a, x); // prettier-ignore
+
   /**
@@ -349,9 +380,5 @@ * Asserts coordinate is valid: 0 <= n < MASK.
   class Point implements EdwardsPoint {
-    // base / generator point
-    static readonly BASE = new Point(CURVE.Gx, CURVE.Gy, _1n, modP(CURVE.Gx * CURVE.Gy));
-    // zero / infinity / identity point
-    static readonly ZERO = new Point(_0n, _1n, _1n, _0n); // 0, 1, 1, 0
-    // math field
+    static readonly BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE, Fp.mul(CURVE.Gx, CURVE.Gy));
+    static readonly ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ONE, Fp.ZERO);
     static readonly Fp = Fp;
-    // scalar field
     static readonly Fn = Fn;
@@ -386,3 +413,3 @@
       acoord('y', y);
-      return new Point(x, y, _1n, modP(x * y));
+      return new Point(x, y, Fp.ONE, Fp.mul(x, y));
     }
@@ -410,13 +437,13 @@
       // ax²+y²=1+dx²y² => y²-1=dx²y²-ax² => y²-1=x²(dy²-a) => x²=(y²-1)/(dy²-a)
-      const y2 = modP(y * y); // denominator is always non-0 mod p.
-      const u = modP(y2 - _1n); // u = y² - 1
-      const v = modP(d * y2 - a); // v = d y² + 1.
+      const y2 = Fp.sqr(y); // denominator is always non-0 mod p.
+      const u = Fp.sub(y2, Fp.ONE); // u = y² - 1
+      const v = Fp.sub(Fp.mulN(d, y2), a); // v = d y² - a.
       let { isValid, value: x } = uvRatio(u, v); // √(u/v)
       if (!isValid) throw new Error('bad point: invalid y coordinate');
-      const isXOdd = (x & _1n) === _1n; // There are 2 square roots. Use x_0 bit to select proper
+      const isXOdd = isOdd(x); // There are 2 square roots. Use x_0 bit to select proper
       const isLastByteOdd = (lastByte & 0x80) !== 0; // x_0, last bit
-      if (!zip215 && x === _0n && isLastByteOdd)
+      if (!zip215 && Fp.is0(x) && isLastByteOdd)
         // if x=0 and x_0 = 1, fail
         throw new Error('bad point: x=0 and x_0=1');
-      if (isLastByteOdd !== isXOdd) x = modP(-x); // if x_0 != x mod 2, set x = p-x
+      if (isLastByteOdd !== isXOdd) x = Fp.neg(x); // if x_0 != x mod 2, set x = p-x
       return Point.fromAffine({ x, y });
@@ -436,4 +463,4 @@ }
 
-    precompute(windowSize: number = 8, isLazy = true) {
-      wnaf.createCache(this, windowSize);
+    precompute(windowSize: number = 6, isLazy = true) {
+      wnaf.setWindowSize(this, windowSize);
       if (!isLazy) this.multiply(_2n); // random number
@@ -455,14 +482,14 @@ return this;
       const { X, Y, Z, T } = p;
-      const X2 = modP(X * X); // X²
-      const Y2 = modP(Y * Y); // Y²
-      const Z2 = modP(Z * Z); // Z²
-      const Z4 = modP(Z2 * Z2); // Z⁴
-      const aX2 = modP(X2 * a); // aX²
-      const left = modP(Z2 * modP(aX2 + Y2)); // (aX² + Y²)Z²
-      const right = modP(Z4 + modP(d * modP(X2 * Y2))); // Z⁴ + dX²Y²
-      if (left !== right) throw new Error('bad point: equation left != right (1)');
+      const X2 = Fp.sqr(X); // X²
+      const Y2 = Fp.sqr(Y); // Y²
+      const Z2 = Fp.sqr(Z); // Z²
+      const Z4 = Fp.sqr(Z2); // Z⁴
+      const aX2 = Fp.mul(X2, a); // aX²
+      const left = Fp.mul(Fp.add(aX2, Y2), Z2); // (aX² + Y²)Z²
+      const right = Fp.add(Z4, Fp.mul(d, Fp.mul(X2, Y2))); // Z⁴ + dX²Y²
+      if (!Fp.eql(left, right)) throw new Error('bad point: equation left != right (1)');
       // In Extended coordinates we also have T, which is x*y=T/Z: check X*Y == Z*T
-      const XY = modP(X * Y);
-      const ZT = modP(Z * T);
-      if (XY !== ZT) throw new Error('bad point: equation left != right (2)');
+      const XY = Fp.mul(X, Y);
+      const ZT = Fp.mul(Z, T);
+      if (!Fp.eql(XY, ZT)) throw new Error('bad point: equation left != right (2)');
     }
@@ -475,7 +502,7 @@
       const { X: X2, Y: Y2, Z: Z2 } = other;
-      const X1Z2 = modP(X1 * Z2);
-      const X2Z1 = modP(X2 * Z1);
-      const Y1Z2 = modP(Y1 * Z2);
-      const Y2Z1 = modP(Y2 * Z1);
-      return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+      const X1Z2 = Fp.mul(X1, Z2);
+      const X2Z1 = Fp.mul(X2, Z1);
+      const Y1Z2 = Fp.mul(Y1, Z2);
+      const Y2Z1 = Fp.mul(Y2, Z1);
+      return Fp.eql(X1Z2, X2Z1) && Fp.eql(Y1Z2, Y2Z1);
     }
@@ -489,3 +516,3 @@
       // Flips point sign to a negative one (-x, y in affine coords)
-      return new Point(modP(-this.X), this.Y, this.Z, modP(-this.T));
+      return new Point(Fp.neg(this.X), this.Y, this.Z, Fp.neg(this.T));
     }
@@ -497,17 +524,16 @@
     double(): Point {
-      const { a } = CURVE;
       const { X: X1, Y: Y1, Z: Z1 } = this;
-      const A = modP(X1 * X1); // A = X12
-      const B = modP(Y1 * Y1); // B = Y12
-      const C = modP(_2n * modP(Z1 * Z1)); // C = 2*Z12
-      const D = modP(a * A); // D = a*A
-      const x1y1 = X1 + Y1;
-      const E = modP(modP(x1y1 * x1y1) - A - B); // E = (X1+Y1)2-A-B
-      const G = D + B; // G = D+B
-      const F = G - C; // F = G-C
-      const H = D - B; // H = D-B
-      const X3 = modP(E * F); // X3 = E*F
-      const Y3 = modP(G * H); // Y3 = G*H
-      const T3 = modP(E * H); // T3 = E*H
-      const Z3 = modP(F * G); // Z3 = F*G
+      const A = Fp.sqr(X1); // A = X12
+      const B = Fp.sqr(Y1); // B = Y12
+      const C = Fp.mul(Fp.sqr(Z1), _2n); // C = 2*Z12
+      const D = mulA(A); // D = a*A
+      const x1y1 = Fp.addN(X1, Y1);
+      const E = Fp.sub(Fp.subN(Fp.sqr(x1y1), A), B); // E = (X1+Y1)2-A-B
+      const G = Fp.addN(D, B); // G = D+B
+      const F = Fp.subN(G, C); // F = G-C
+      const H = Fp.subN(D, B); // H = D-B
+      const X3 = Fp.mul(E, F); // X3 = E*F
+      const Y3 = Fp.mul(G, H); // Y3 = G*H
+      const T3 = Fp.mul(E, H); // T3 = E*H
+      const Z3 = Fp.mul(F, G); // Z3 = F*G
       return new Point(X3, Y3, Z3, T3);
@@ -521,17 +547,18 @@ }
       aedpoint(other);
-      const { a, d } = CURVE;
+      const { d } = CURVE;
       const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
       const { X: X2, Y: Y2, Z: Z2, T: T2 } = other;
-      const A = modP(X1 * X2); // A = X1*X2
-      const B = modP(Y1 * Y2); // B = Y1*Y2
-      const C = modP(T1 * d * T2); // C = T1*d*T2
-      const D = modP(Z1 * Z2); // D = Z1*Z2
-      const E = modP((X1 + Y1) * (X2 + Y2) - A - B); // E = (X1+Y1)*(X2+Y2)-A-B
-      const F = D - C; // F = D-C
-      const G = D + C; // G = D+C
-      const H = modP(B - a * A); // H = B-a*A
-      const X3 = modP(E * F); // X3 = E*F
-      const Y3 = modP(G * H); // Y3 = G*H
-      const T3 = modP(E * H); // T3 = E*H
-      const Z3 = modP(F * G); // Z3 = F*G
+      const A = Fp.mul(X1, X2); // A = X1*X2
+      const B = Fp.mul(Y1, Y2); // B = Y1*Y2
+      const C = Fp.mul(Fp.mulN(T1, d), T2); // C = T1*d*T2
+      const D = Fp.mul(Z1, Z2); // D = Z1*Z2
+      // E = (X1+Y1)*(X2+Y2)-A-B
+      const E = Fp.sub(Fp.subN(Fp.mulN(Fp.addN(X1, Y1), Fp.addN(X2, Y2)), A), B);
+      const F = Fp.subN(D, C); // F = D-C
+      const G = Fp.addN(D, C); // G = D+C
+      const H = Fp.sub(B, mulA(A)); // H = B-a*A
+      const X3 = Fp.mul(E, F); // X3 = E*F
+      const Y3 = Fp.mul(G, H); // Y3 = G*H
+      const T3 = Fp.mul(E, H); // T3 = E*H
+      const Z3 = Fp.mul(F, G); // Z3 = F*G
       return new Point(X3, Y3, Z3, T3);
@@ -555,4 +582,4 @@ }
         throw new RangeError('invalid scalar: expected 1 <= sc < curve.n');
-      const { p, f } = wnaf.cached(this, scalar, (p) => normalizeZ(Point, p));
-      return normalizeZ(Point, [p, f])[0];
+      const { p, f } = wnaf.mulSecret(this, scalar, cofactor, normalize);
+      return normalize([p, f])[0];
     }
@@ -570,3 +597,3 @@
       if (this.is0() || scalar === _1n) return this;
-      return wnaf.unsafe(this, scalar, (p) => normalizeZ(Point, p));
+      return wnaf.mulUnsafe(this, scalar, normalize);
     }
@@ -585,3 +612,3 @@
     isTorsionFree(): boolean {
-      return wnaf.unsafe(this, CURVE.n).is0();
+      return wnaf.mulUnsafe(this, CURVE.n).is0();
     }
@@ -594,10 +621,12 @@
       let iz = invertedZ;
+      if (iz != null && typeof iz !== 'bigint')
+        throw new TypeError('"invertedZ" expected bigint, got type=' + typeof iz);
       const { X, Y, Z } = p;
       const is0 = p.is0();
-      if (iz == null) iz = is0 ? _8n : (Fp.inv(Z) as bigint); // 8 was chosen arbitrarily
-      const x = modP(X * iz);
-      const y = modP(Y * iz);
+      if (iz == null) iz = is0 ? Fp.create(_8n) : (Fp.inv(Z) as bigint);
+      const x = Fp.mul(X, iz);
+      const y = Fp.mul(Y, iz);
       const zz = Fp.mul(Z, iz);
-      if (is0) return { x: _0n, y: _1n };
-      if (zz !== _1n) throw new Error('invZ was invalid');
+      if (is0) return { x: Fp.ZERO, y: Fp.ONE };
+      if (!Fp.eql(zz, Fp.ONE)) throw new Error('invZ was invalid');
       return { x, y };
@@ -608,2 +637,6 @@ }
       if (cofactor === _1n) return this;
+      // 2.8-3.8x speed-up vs naive
+      if (cofactor === _2n) return this.double();
+      if (cofactor === _4n) return this.double().double();
+      if (cofactor === _8n) return this.double().double().double();
       return this.multiplyUnsafe(cofactor);
@@ -618,3 +651,3 @@ }
       // When compressing, it's enough to store y and use the last byte to encode sign of x
-      bytes[bytes.length - 1] |= x & _1n ? 0x80 : 0;
+      bytes[bytes.length - 1] |= isOdd(x) ? 0x80 : 0;
       return bytes;
@@ -630,3 +663,2 @@ }
   }
-  const wnaf = new wNAF(Point, Fn.BITS);
   // Keep constructor work cheap: subgroup/generator validation belongs to the caller's curve
@@ -641,5 +673,7 @@ // parameters, and doing the extra checks here adds about 10-15ms to heavy module imports.
   // }
-  // Tiny toy curves can have scalar fields narrower than 8 bits. Skip the
-  // eager W=8 cache there instead of rejecting an otherwise valid constructor.
-  if (Fn.BITS >= 8) Point.BASE.precompute(8); // Enable precomputes. Slows down first publicKey computation by 20ms.
+  const normalize = (points: TArg<Point[]>) => normalizeZ(Point, points);
+  const wnaf = new ScalarMultiplier(Point, randomBytes);
+  // Enable W=6 wNAF precomputes. Slows down first publicKey computation.
+  // Disable for tiny toy curves, with scalar fields < 6 bits.
+  if (wnaf.bits >= 6) Point.BASE.precompute(6);
   Object.freeze(Point.prototype);
@@ -811,2 +845,3 @@ Object.freeze(Point);
 ): EdDSA {
+  validatePointCons(Point);
   if (typeof cHash !== 'function') throw new Error('"hash" function param is required');
@@ -825,2 +860,4 @@ const hash = cHash as FHash;
       mapToCurve: 'function',
+      toMontgomery: 'function',
+      toMontgomerySecret: 'function',
     }
@@ -842,2 +879,4 @@ );
   const randomBytes = opts.randomBytes === undefined ? wcRandomBytes : opts.randomBytes;
+  const toMontgomery = opts.toMontgomery;
+  const toMontgomerySecret = opts.toMontgomerySecret;
   const adjustScalarBytes =
@@ -905,2 +944,3 @@ opts.adjustScalarBytes === undefined
   ): TRet<Uint8Array> {
+    validateObject(options as any, {}, {}, 'options');
     msg = abytes(msg, undefined, 'message');
@@ -938,2 +978,4 @@ if (prehash) msg = prehash(msg); // for ed25519ph etc.
   ): boolean {
+    // Validate before destructuring so explicit null follows the standard options error.
+    validateObject(options);
     // Preserve the wrapper-selected default for `{}` / `{ zip215: undefined }`, not just omitted opts.
@@ -1010,24 +1052,12 @@ const { context } = options;
     isValidPublicKey,
-    /**
-     * Converts ed public key to x public key. Uses formula:
-     * - ed25519:
-     *   - `(u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x)`
-     *   - `(x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1))`
-     * - ed448:
-     *   - `(u, v) = ((y-1)/(y+1), sqrt(156324)*u/x)`
-     *   - `(x, y) = (sqrt(156324)*u/v, (1+u)/(1-u))`
-     */
+    /** Converts an Edwards public key to a companion Montgomery public key. */
     toMontgomery(publicKey: TArg<Uint8Array>): TRet<Uint8Array> {
-      const { y } = Point.fromBytes(publicKey);
-      const size = lengths.publicKey;
-      const is25519 = size === 32;
-      if (!is25519 && size !== 57) throw new Error('only defined for 25519 and 448');
-      const u = is25519 ? Fp.div(_1n + y, _1n - y) : Fp.div(y - _1n, y + _1n);
-      return Fp.toBytes(u) as TRet<Uint8Array>;
+      if (toMontgomery === undefined)
+        throw new Error('Montgomery conversion is not supported for this curve');
+      return toMontgomery(Point.fromBytes(publicKey));
     },
     toMontgomerySecret(secretKey: TArg<Uint8Array>): TRet<Uint8Array> {
-      const size = lengths.secretKey;
-      abytes(secretKey, size);
-      const hashed = hash(secretKey.subarray(0, size));
-      return adjustScalarBytes(hashed).subarray(0, size) as TRet<Uint8Array>;
+      if (toMontgomerySecret === undefined)
+        throw new Error('Montgomery conversion is not supported for this curve');
+      return toMontgomerySecret(secretKey);
     },
@@ -1034,0 +1064,0 @@ };

src/abstract/fft.ts

@@ -6,4 +6,4 @@ /**
  */
-import type { TArg } from '../utils.ts';
-import type { IField } from './modular.ts';
+import { aarray, validateObject, type TArg } from '../utils.ts';
+import { validateField, type IField } from './modular.ts';
 
@@ -37,6 +37,8 @@ /** Array-like coefficient storage that can be mutated in place. */
 
-function checkU32(n: number) {
+function checkU32(n: number, title = 'n') {
   // 0xff_ff_ff_ff
+  if (typeof n !== 'number')
+    throw new TypeError(`wrong u32 integer "${title}": expected number, got type=${typeof n}`);
   if (!Number.isSafeInteger(n) || n < 0 || n > 0xffffffff)
-    throw new Error('wrong u32 integer:' + n);
+    throw new RangeError(`wrong u32 integer "${title}": expected 0..4294967295, got ${n}`);
   return n;
@@ -49,3 +51,2 @@ }
  * @returns `true` when the value is a power of two.
- * @throws If `x` is not a valid unsigned 32-bit integer. {@link Error}
  * @example
@@ -59,3 +60,3 @@ * Validate that an FFT size is a power of two.
 export function isPowerOfTwo(x: number): boolean {
-  checkU32(x);
+  checkU32(x, 'x');
   return (x & (x - 1)) === 0 && x !== 0;
@@ -98,2 +99,4 @@ }
   checkU32(n);
+  if (typeof bits !== 'number')
+    throw new TypeError('"bits" expected number, got type=' + typeof bits);
   if (!Number.isSafeInteger(bits) || bits < 0 || bits > 32)
@@ -111,3 +114,2 @@ throw new Error(`expected integer 0 <= bits <= 32, got ${bits}`);
  * @returns Base-2 logarithm. For `n = 0`, the current implementation returns `-1`.
- * @throws If `n` is not a valid unsigned 32-bit integer. {@link Error}
  * @example
@@ -141,2 +143,8 @@ * Compute the radix-2 stage count for one transform size.
 export function bitReversalInplace<T extends MutableArrayLike<any>>(values: T): T {
+  if (
+    !values ||
+    typeof values !== 'object' ||
+    typeof (values as MutableArrayLike<any>).length !== 'number'
+  )
+    throw new TypeError('"values" expected array-like, got type=' + typeof values);
   const n = values.length;
@@ -169,2 +177,3 @@ // Size-1 FFT is the identity, so bit-reversal must stay a no-op there instead of rejecting it.
 export function bitReversalPermutation<T>(values: T[]): T[] {
+  aarray(values, 'values');
   return bitReversalInplace(values.slice()) as T[];
@@ -215,5 +224,5 @@ }
 /**
- * We limit roots up to 2**31, which is a lot: 2-billion polynomimal should be rare.
+ * We limit roots up to 2**31, which is a lot: 2-billion polynomial should be rare.
  * @param field - Field implementation.
- * @param generator - Optional generator override.
+ * @param generator - Optional trusted non-quadratic-residue override for callers that already know the field.
  * @returns Roots-of-unity cache.
@@ -231,2 +240,5 @@ * @example
 export function rootsOfUnity(field: TArg<IField<bigint>>, generator?: bigint): RootsOfUnity {
+  validateField(field);
+  if (generator !== undefined && typeof generator !== 'bigint')
+    throw new TypeError('"generator" expected bigint, got type=' + typeof generator);
   // Factor field.ORDER-1 as oddFactor * 2^powerOfTwo
@@ -246,3 +258,3 @@ let oddFactor = field.ORDER - _1n;
   const checkBits = (bits: number) => {
-    checkU32(bits);
+    checkU32(bits, 'bits');
     if (bits > 31 || bits > powerOfTwo)
@@ -256,5 +268,12 @@ throw new Error('rootsOfUnity: wrong bits ' + bits + ' powerOfTwo=' + powerOfTwo);
       if (rootsCache[power]) continue; // Skip if we've already computed roots for this power
+      const above = rootsCache[power + 1];
       const rootsAtPower: bigint[] = [];
-      for (let j = 0, cur = field.ONE; j < 2 ** power; j++, cur = field.mul(cur, omegas[power]))
-        rootsAtPower.push(cur);
+      if (above) {
+        // ω_{2^p} = ω_{2^{p+1}}², so the smaller table is the even-index stride of the bigger
+        // one: only the largest requested power pays for the multiplication chain.
+        for (let j = 0; j < 2 ** power; j++) rootsAtPower.push(above[2 * j]);
+      } else {
+        for (let j = 0, cur = field.ONE; j < 2 ** power; j++, cur = field.mul(cur, omegas[power]))
+          rootsAtPower.push(cur);
+      }
       rootsCache[power] = rootsAtPower;
@@ -269,3 +288,3 @@ }
   // NOTE: we use bits instead of power, because power = 2**bits,
-  // but power is not neccesary isPowerOfTwo(power)!
+  // but power is not necessarily isPowerOfTwo(power)!
   return {
@@ -290,3 +309,6 @@ info: { G, powerOfTwo, oddFactor },
       else {
-        const res = field.invertBatch(this.roots(b));
+        // ωᴺ = 1, so inv(ωᵏ) = ωᴺ⁻ᵏ: the inverse table is the reversed roots table.
+        // Value-identical to field.invertBatch(roots), but skips its 3N muls + inversion.
+        const r = this.roots(b);
+        const res = [r[0]].concat(r.slice(1).reverse());
         inverseCache.set(b, res);
@@ -372,3 +394,3 @@ return res;
  *
- * - DIT (Decimation-in-Time): Bottom-Up (leaves to root), Cool-Turkey
+ * - DIT (Decimation-in-Time): Bottom-Up (leaves to root), Cooley-Tukey
  * - DIF (Decimation-in-Frequency): Top-Down (root to leaves), Gentleman-Sande
@@ -385,4 +407,12 @@ *
  * Negacyclic NTT: Rq = Zq[x]/(x^n+1). butterfly_DIT+loop_DIF, at least for mlkem / mldsa
+ *
+ * `invertButterflies` indexes roots by a per-butterfly-group counter (`grp`): forward
+ * (`dit: false`) reads `roots[grp]` with grp = 1..; inverse (`dit: true`) reads `roots[N - grp]`
+ * with grp restarting at 1. With `skipStages: 0` one table serves both directions (ωᴺ = 1 makes
+ * the reversed walk self-inverse). With `skipStages > 0` the inverse walk starts at `N - 1`
+ * instead of continuing where the skipped stages would have left off, so the caller must supply
+ * a table shaped for that (ML-KEM: `ζ^BitRev7(i)` over all N=256 indices, whose aliased upper
+ * half is exactly the FIPS 203 inverse walk).
  * @param F - Field operations.
- * @param coreOpts - FFT configuration:
+ * @param coreOpts - FFT configuration. See {@link FFTCoreOpts}:
  *   - `N`: Transform size. Must be a power of two.
@@ -409,5 +439,17 @@ *   - `roots`: Stage roots for the selected transform size.
 export const FFTCore = <T, R>(F: FFTOpts<T, R>, coreOpts: FFTCoreOpts<R>): FFTCoreLoop<T> => {
+  validateObject(
+    coreOpts as unknown as Record<string, any>,
+    { N: 'number', roots: 'object', dit: 'boolean' },
+    { invertButterflies: 'boolean', skipStages: 'number', brp: 'boolean' },
+    'coreOpts'
+  );
   const { N, roots, dit, invertButterflies = false, skipStages = 0, brp = true } = coreOpts;
+  checkU32(N, 'coreOpts.N');
   const bits = log2(N);
   if (!isPowerOfTwo(N)) throw new Error('FFT: Polynomial size should be power of two');
+  checkU32(skipStages, 'coreOpts.skipStages');
+  const maxSkipStages = bits === 0 ? 0 : bits - 1;
+  // Skipping every stage leaves only boundary layout changes, not a valid FFT loop shape.
+  if (skipStages > maxSkipStages)
+    throw new Error(`FFT: wrong skipStages: expected 0 <= skipStages <= ${maxSkipStages}`);
   // Wrong-sized root tables can stay in-bounds for some loop shapes and silently compute nonsense.
@@ -417,3 +459,2 @@ if (roots.length !== N)
   const isDit = dit !== invertButterflies;
-  isDit;
   return <P extends Polynomial<T>>(values: P): P => {
@@ -496,17 +537,29 @@ if (values.length !== N) throw new Error('FFT: wrong Polynomial length');
 export function FFT<T>(roots: RootsOfUnity, opts: FFTOpts<T, bigint>): FFTMethods<T> {
+  // Loops are cached per (size, direction, brp flags): FFTCore construction validates options
+  // and allocates closures, which costs more than a small transform itself. The cached loop
+  // closes over the root table active at first use; `roots.clear()` rebuilds value-identical
+  // tables, so a stale reference stays correct.
+  const loops = new Map<number, FFTCoreLoop<T>>();
   const getLoop = (
     N: number,
-    roots: Polynomial<bigint>,
-    brpInput = false,
-    brpOutput = false
+    rootsTable: Polynomial<bigint>,
+    key: number
   ): (<P extends Polynomial<T>>(values: P) => P) => {
+    const cached = loops.get(key);
+    if (cached) return cached;
+    const brpInput = !!(key & 2);
+    const brpOutput = !!(key & 1);
+    let loop: FFTCoreLoop<T>;
     if (brpInput && brpOutput) {
       // we cannot optimize this case, but lets support it anyway
-      return (values) =>
-        FFTCore(opts, { N, roots, dit: false, brp: false })(bitReversalInplace(values));
-    }
-    if (brpInput) return FFTCore(opts, { N, roots, dit: true, brp: false });
-    if (brpOutput) return FFTCore(opts, { N, roots, dit: false, brp: false });
-    return FFTCore(opts, { N, roots, dit: true, brp: true }); // all natural
+      const core = FFTCore(opts, { N, roots: rootsTable, dit: false, brp: false });
+      loop = (values) => core(bitReversalInplace(values));
+    } else if (brpInput) loop = FFTCore(opts, { N, roots: rootsTable, dit: true, brp: false });
+    else if (brpOutput) loop = FFTCore(opts, { N, roots: rootsTable, dit: false, brp: false });
+    else loop = FFTCore(opts, { N, roots: rootsTable, dit: true, brp: true }); // all natural
+    loops.set(key, loop);
+    return loop;
   };
+  const loopKey = (bits: number, isInverse: boolean, brpInput: boolean, brpOutput: boolean) =>
+    (bits << 3) | (isInverse ? 4 : 0) | (brpInput ? 2 : 0) | (brpOutput ? 1 : 0);
   return {
@@ -517,3 +570,4 @@ direct<P extends Polynomial<T>>(values: P, brpInput = false, brpOutput = false): P {
       const bits = log2(N);
-      return getLoop(N, roots.roots(bits), brpInput, brpOutput)<P>(values.slice());
+      const key = loopKey(bits, false, brpInput, brpOutput);
+      return getLoop(N, roots.roots(bits), key)<P>(values.slice());
     },
@@ -524,3 +578,4 @@ inverse<P extends Polynomial<T>>(values: P, brpInput = false, brpOutput = false): P {
       const bits = log2(N);
-      const res = getLoop(N, roots.inverse(bits), brpInput, brpOutput)(values.slice());
+      const key = loopKey(bits, true, brpInput, brpOutput);
+      const res = getLoop(N, roots.inverse(bits), key)(values.slice());
       const ivm = opts.inv(BigInt(values.length)); // scale
@@ -697,2 +752,3 @@ // we can get brp output if we use dif instead of dit!
 ): PolyFn<any, T> {
+  validateField(field);
   const F = field as IField<T>;
@@ -715,8 +771,13 @@ const _create =
   };
-  const checkLength = (...lst: P[]): number => {
-    if (!lst.length) return 0;
-    for (const i of lst) if (!isPoly(i)) throw new Error('poly: not polynomial: ' + i);
-    const L = lst[0].length;
-    for (let i = 1; i < lst.length; i++)
-      if (lst[i].length !== L) throw new Error(`poly: mismatched lengths ${L} vs ${lst[i].length}`);
+  const checkPoly = (title: string, value: P): void => {
+    if (!isPoly(value))
+      throw new TypeError(`"${title}" expected polynomial, got type=${typeof value}`);
+  };
+  const checkLength = (a: P, b?: P): number => {
+    checkPoly('a', a);
+    const L = a.length;
+    if (b !== undefined) {
+      checkPoly('b', b);
+      if (b.length !== L) throw new Error(`poly: mismatched lengths ${L} vs ${b.length}`);
+    }
     if (length !== undefined && L !== length)
@@ -726,5 +787,6 @@ throw new Error(`poly: expected fixed length ${length}, got ${L}`);
   };
-  function findOmegaIndex(x: T, n: number, brp = false): number {
-    const bits = log2(n);
-    const omega = brp ? roots.brp(bits) : roots.roots(bits);
+  function findOmegaIndex(x: T, n: number, brp = false, weights?: P): number {
+    if (!isPowerOfTwo(n)) throw new Error('poly.lagrange: expected power of two length, got ' + n);
+    // Explicit weights define the interpolation domain, including the Kronecker-δ shortcut.
+    const omega = weights || (brp ? roots.brp(log2(n)) : roots.roots(log2(n)));
     for (let i = 0; i < n; i++) if (F.eql(x, omega[i] as T)) return i;
@@ -795,2 +857,4 @@ return -1;
     convolve(a: P, b: P): P {
+      checkPoly('a', a);
+      checkPoly('b', b);
       const len = nextPowerOfTwo(a.length + b.length - 1);
@@ -800,3 +864,7 @@ return this.mul(this.extend(a, len), this.extend(b, len));
     shift(p: P, factor: bigint): P {
-      const out = _create(checkLength(p));
+      checkPoly('p', p);
+      const out = _create(p.length);
+      if (length !== undefined && p.length !== length)
+        throw new Error(`poly: expected fixed length ${length}, got ${p.length}`);
+      if (!p.length) return out;
       out[0] = p[0];
@@ -841,2 +909,4 @@ for (let i = 1, power = F.ONE; i < p.length; i++) {
       basis: (x: T, n: number, brp = false, weights?: P): P => {
+        if (!isPowerOfTwo(n))
+          throw new Error('poly.lagrange: expected power of two length, got ' + n);
         const bits = log2(n);
@@ -846,3 +916,3 @@ const cache = weights || (brp ? roots.brp(bits) : roots.roots(bits)); // [ω⁰, ω¹, ..., ωⁿ⁻¹]
         // Fast Kronecker-δ shortcut
-        const idx = findOmegaIndex(x, n, brp);
+        const idx = findOmegaIndex(x, n, brp, weights);
         if (idx !== -1) {
@@ -871,3 +941,5 @@ out[idx] = F.ONE;
     vanishing(roots: P): P {
-      checkLength(roots);
+      checkPoly('roots', roots);
+      if (length !== undefined && roots.length !== length)
+        throw new Error(`poly: expected fixed length ${length}, got ${roots.length}`);
       const out = _create(roots.length + 1, F.ZERO);
@@ -874,0 +946,0 @@ out[0] = F.ONE;

src/abstract/frost.ts

 /**
  * FROST: Flexible Round-Optimized Schnorr Threshold Protocol for Two-Round Schnorr Signatures.
  *
- * See [RFC 9591](https://datatracker.ietf.org/doc/rfc9591/) and [frost.zfnd.org](https://frost.zfnd.org).
+ * See {@link https://datatracker.ietf.org/doc/rfc9591/ | RFC 9591} and
+ * {@link https://frost.zfnd.org | frost.zfnd.org}.
  * @module
@@ -9,2 +10,6 @@ */
 import {
+  aarray,
+  abytes,
+  asafenumber,
+  astring,
   bytesToHex,
@@ -20,3 +25,3 @@ bytesToNumberBE,
 } from '../utils.ts';
-import { pippenger, validatePointCons, type CurvePoint, type CurvePointCons } from './curve.ts';
+import { mulAddUnsafe, validatePointCons, type CurvePoint, type CurvePointCons } from './curve.ts';
 import { poly, type RootsOfUnity } from './fft.ts';
@@ -26,12 +31,26 @@ import { type H2CDSTOpts } from './hash-to-curve.ts';
 
+/** Cryptographically secure random byte generator. */
 export type RNG = typeof randomBytes;
-export type Identifier = string; // Identifiers are hex to make comparison easier
-export type Commitment = Uint8Array; // serialized point
-export type Coefficient = Uint8Array; // serialized scalar
+/** Serialized participant identifier. Identifiers are hex to make comparison easier. */
+export type Identifier = string;
+/** Serialized point commitment. */
+export type Commitment = Uint8Array;
+/** Serialized scalar coefficient. */
+export type Coefficient = Uint8Array;
+/** Serialized Schnorr signature. */
 export type Signature = Uint8Array;
-export type Signers = { min: number; max: number };
-export type SecretKey = Uint8Array; // Secret key
+/** Threshold participant counts. */
+export type Signers = {
+  /** Minimum number of signers required to produce a signature. */
+  min: number;
+  /** Maximum number of participants in the key set. */
+  max: number;
+};
+/** Serialized secret key bytes. */
+export type SecretKey = Uint8Array;
+/** Byte array alias used by FROST public packages. */
 export type Bytes = Uint8Array;
 type Point = Uint8Array;
 
+/** Public DKG round-1 broadcast plus proof of knowledge. */
 export type DKG_Round1 = {
@@ -41,94 +60,249 @@ // If identifiers were assigned via fromNumber before, it is worth checking
   // But we throw on duplicate identifiers.
+  /** Sender identifier. */
   identifier: Identifier;
-  commitment: TRet<Commitment[]>; // sender identifier
+  /** VSS commitment points. */
+  commitment: TRet<Commitment[]>;
+  /** Signature proving knowledge of the sender's secret coefficient. */
   proofOfKnowledge: TRet<Signature>;
 };
+/** Public DKG round-2 recipient share package. */
 export type DKG_Round2 = {
-  identifier: Identifier; // sender identifier
+  /** Sender identifier. */
+  identifier: Identifier;
+  /** Signing share for one receiver. */
   signingShare: TRet<Bytes>;
 };
 // This is internal, so we can use bigints
+/** Internal mutable DKG state package. */
 export type DKG_Secret = {
+  /** Local participant identifier as a scalar. */
   identifier: bigint;
+  /** Local secret polynomial coefficients while DKG is in progress. */
   coefficients?: bigint[];
+  /** Local VSS commitment points. */
   commitment: TRet<Point[]>;
+  /** Threshold participant counts. */
   signers: Signers;
   // Keep the local polynomial until round3 succeeds so late DKG failures can be retried.
+  /** Cached round2 packages from the first successful round2 call. */
+  round2Cache?: Record<Identifier, DKG_Round2>;
+  /** Current DKG state-machine step. */
   step?: 1 | 2 | 3;
 };
 
+/** Shared public FROST package for one key set. */
 export type FrostPublic = {
+  /** Threshold participant counts. */
   signers: Signers;
-  commitments: TRet<Bytes[]>; // Point[], where commitments[0] is the group public key
-  verifyingShares: TRet<Record<Identifier, Bytes>>; // id -> Point
+  /** Serialized commitment points; `commitments[0]` is the group public key. */
+  commitments: TRet<Bytes[]>;
+  /** Map from participant identifier to serialized verifying-share point. */
+  verifyingShares: TRet<Record<Identifier, Bytes>>;
 };
+/** Secret FROST share for one participant. */
 export type FrostSecret = {
+  /** Participant identifier. */
   identifier: Identifier;
-  signingShare: TRet<Bytes>; // Scalar
+  /** Serialized scalar signing share. */
+  signingShare: TRet<Bytes>;
 };
-export type Key = { public: FrostPublic; secret: FrostSecret };
+/** Combined public and secret FROST packages for one participant. */
+export type Key = {
+  /** Shared public package. */
+  public: FrostPublic;
+  /** Participant secret package. */
+  secret: FrostSecret;
+};
+/** Trusted-dealer output containing public data and all participant shares. */
 export type DealerShares = {
+  /** Shared public package. */
   public: FrostPublic;
+  /** Map from participant identifier to its secret share. */
   secretShares: Record<Identifier, FrostSecret>;
 };
 // Sign stuff
+/** Private nonce scalars used once during signing. */
 export type Nonces = {
-  hiding: TRet<Bytes>; // Scalar
-  binding: TRet<Bytes>; // Scalar
+  /** Serialized hiding nonce scalar. */
+  hiding: TRet<Bytes>;
+  /** Serialized binding nonce scalar. */
+  binding: TRet<Bytes>;
 };
+/** Public nonce commitments broadcast for one signing attempt. */
 export type NonceCommitments = {
+  /** Participant identifier. */
   identifier: Identifier;
-  hiding: TRet<Bytes>; // Point
-  binding: TRet<Bytes>; // Point
+  /** Serialized hiding nonce point. */
+  hiding: TRet<Bytes>;
+  /** Serialized binding nonce point. */
+  binding: TRet<Bytes>;
 };
+/** Generated nonce package containing private nonces and public commitments. */
 export type GenNonce = {
+  /** Private nonce scalars. */
   nonces: Nonces;
+  /** Public nonce commitments. */
   commitments: NonceCommitments;
 };
 
+/** Point interface required by the generic FROST implementation. */
 export interface FROSTPoint<T extends CurvePoint<any, T>> extends CurvePoint<any, T> {
+  /**
+   * Adds another point.
+   * @param rhs - Point to add.
+   * @returns Point sum.
+   */
   add(rhs: T): T;
+  /**
+   * Multiplies by a scalar.
+   * @param rhs - Scalar multiplier.
+   * @returns Scalar multiplication result.
+   */
   multiply(rhs: bigint): T;
+  /**
+   * Compares two points.
+   * @param rhs - Point to compare.
+   * @returns Whether points are equal.
+   */
   equals(rhs: T): boolean;
+  /**
+   * Serializes a point.
+   * @param compressed - Whether to use compressed encoding.
+   * @returns Encoded point bytes.
+   */
   toBytes(compressed?: boolean): Bytes;
+  /**
+   * Clears the point cofactor.
+   * @returns Cofactor-cleared point.
+   */
   clearCofactor(): T;
 }
+/** Point constructor surface required by FROST. */
 export interface FROSTPointConstructor<T extends FROSTPoint<T>> extends CurvePointCons<T> {
+  /**
+   * Parses a point from bytes.
+   * @param a - Encoded point bytes.
+   * @returns Parsed point.
+   */
   fromBytes(a: Bytes): T;
+  /** Scalar field used by the point group. */
   Fn: IField<bigint>;
 }
 
-// Opts
+/** Construction options for a concrete FROST ciphersuite. */
 export type FrostOpts<P extends FROSTPoint<P>> = {
+  /** Ciphersuite name. */
   readonly name: string;
+  /** Point constructor for the signing group. */
   readonly Point: FROSTPointConstructor<P>;
+  /** Optional scalar-field override. */
   readonly Fn?: IField<bigint>;
-  /** Optional suite hook that tightens canonical decoding with subgroup / identity checks. */
+  /**
+   * Optional suite hook that tightens canonical decoding with subgroup / identity checks.
+   * @param p - Point to validate.
+   */
   readonly validatePoint?: (p: P) => void;
-  /** Optional public-key parser. Implementations MUST preserve the same subgroup / identity policy
-   * as `validatePoint`, because this bypasses generic canonical decoding in `parsePoint()`. */
+  /**
+   * Optional public-key parser. Implementations MUST preserve the same subgroup / identity policy
+   * as `validatePoint`, because this bypasses generic canonical decoding in `parsePoint()`.
+   * @param bytes - Encoded public key.
+   * @returns Parsed public point.
+   */
   readonly parsePublicKey?: (bytes: TArg<Uint8Array>) => P;
+  /**
+   * Hash function used by the suite.
+   * @param msg - Message bytes to hash.
+   * @returns Hash output bytes.
+   */
   readonly hash: (msg: TArg<Uint8Array>) => TRet<Uint8Array>;
-  /** Custom scalar hash hook. Implementations MUST treat `msg` and `options` as read-only. */
+  /**
+   * Custom scalar hash hook. Implementations MUST treat `msg` and `options` as read-only.
+   * @param msg - Message bytes to hash.
+   * @param options - Hash-to-curve options. See {@link H2CDSTOpts}.
+   * @returns Scalar field element.
+   */
   readonly hashToScalar?: (msg: TArg<Uint8Array>, options?: TArg<H2CDSTOpts>) => bigint;
   // Hacks for taproot support
+  /**
+   * Optional scalar adjustment hook.
+   * @param n - Scalar to adjust.
+   * @returns Adjusted scalar.
+   */
   readonly adjustScalar?: (n: bigint) => bigint;
+  /**
+   * Optional point adjustment hook.
+   * @param n - Point to adjust.
+   * @returns Adjusted point.
+   */
   readonly adjustPoint?: (n: P) => P;
+  /**
+   * Optional challenge override.
+   * @param R - Group commitment point.
+   * @param PK - Group public key point.
+   * @param msg - Message bytes.
+   * @returns Challenge scalar.
+   */
   readonly challenge?: (R: P, PK: P, msg: TArg<Uint8Array>) => bigint;
-  readonly adjustNonces?: (PK: P, nonces: TArg<Nonces>) => TRet<Nonces>;
+  /**
+   * Optional nonce-package adjustment hook.
+   * @param R - Group commitment point for the current signing session.
+   * @param nonces - Nonce package.
+   * @returns Adjusted nonce package.
+   */
+  readonly adjustNonces?: (R: P, nonces: TArg<Nonces>) => TRet<Nonces>;
+  /**
+   * Optional secret-package adjustment hook.
+   * @param secret - Secret package.
+   * @param pub - Public package.
+   * @returns Adjusted secret package.
+   */
   readonly adjustSecret?: (secret: TArg<FrostSecret>, pub: TArg<FrostPublic>) => TRet<FrostSecret>;
+  /**
+   * Optional public-package adjustment hook.
+   * @param pub - Public package.
+   * @returns Adjusted public package.
+   */
   readonly adjustPublic?: (pub: TArg<FrostPublic>) => TRet<FrostPublic>;
+  /**
+   * Optional group commitment-share adjustment hook.
+   * @param GC - Group commitment.
+   * @param GCShare - Participant commitment share.
+   * @returns Adjusted group commitment share.
+   */
   readonly adjustGroupCommitmentShare?: (GC: P, GCShare: P) => P;
+  /** Optional transaction encoder / decoder adjustment. */
   readonly adjustTx?: {
+    /**
+     * Encode transaction bytes before signing.
+     * @param tx - Transaction bytes.
+     * @returns Encoded transaction bytes.
+     */
     readonly encode: (tx: TArg<Uint8Array>) => TRet<Uint8Array>;
+    /**
+     * Decode transaction bytes after verification.
+     * @param tx - Encoded transaction bytes.
+     * @returns Decoded transaction bytes.
+     */
     readonly decode: (tx: TArg<Uint8Array>) => TRet<Uint8Array>;
   };
+  /**
+   * Optional DKG output adjustment hook.
+   * @param k - DKG key package.
+   * @returns Adjusted DKG key package.
+   */
   readonly adjustDKG?: (k: TArg<Key>) => TRet<Key>;
   // Hash function prefixes
+  /** Prefix for RFC 9591 H1. */
   readonly H1?: string;
+  /** Prefix for RFC 9591 H2. */
   readonly H2?: string;
+  /** Prefix for RFC 9591 H3. */
   readonly H3?: string;
+  /** Prefix for RFC 9591 H4. */
   readonly H4?: string;
+  /** Prefix for RFC 9591 H5. */
   readonly H5?: string;
+  /** Prefix for DKG hashing. */
   readonly HDKG?: string;
+  /** Prefix for identifier derivation. */
   readonly HID?: string;
@@ -139,8 +313,6 @@ };
  * FROST: Threshold Protocol for Two‑Round Schnorr Signatures
- * from [RFC 9591](https://datatracker.ietf.org/doc/rfc9591/).
+ * from {@link https://datatracker.ietf.org/doc/rfc9591/ | RFC 9591}.
  */
 export type FROST = {
-  /**
-   * Methods to construct participant identifiers.
-   */
+  /** Methods to construct participant identifiers. */
   Identifier: {
@@ -328,5 +500,3 @@ /**
   combineSecret(shares: TArg<FrostSecret[]>, signers: Signers): TRet<Uint8Array>;
-  /**
-   * Low-level helper utilities (field arithmetic and polynomial tools).
-   */
+  /** Low-level helper utilities (field arithmetic and polynomial tools). */
   utils: {
@@ -367,5 +537,6 @@ /**
 
-const validateSigners = (signers: Signers) => {
-  if (!Number.isSafeInteger(signers.min) || !Number.isSafeInteger(signers.max))
-    throw new Error('Wrong signers info: min=' + signers.min + ' max=' + signers.max);
+const validateSigners = (signers: Signers, title: string = 'signers') => {
+  validateObject(signers as any, { min: 'number', max: 'number' }, {}, title);
+  asafenumber(signers.min, title + '.min');
+  asafenumber(signers.max, title + '.max');
   // Compatibility with frost-rs intentionally narrows RFC 9591's positive-nonzero threshold rule
@@ -392,2 +563,19 @@ // to `min >= 2`, even though the RFC text itself allows `MIN_PARTICIPANTS = 1`.
 
+/**
+ * Builds a FROST ciphersuite API from concrete curve and hash hooks.
+ * @param opts - Ciphersuite construction options. See {@link FrostOpts}.
+ * @returns FROST API bound to the supplied ciphersuite.
+ * @example
+ * Create a suite from a curve-specific option object.
+ * ```ts
+ * import { createFROST } from '@noble/curves/abstract/frost.js';
+ * import { ed25519 } from '@noble/curves/ed25519.js';
+ * import { sha512 } from '@noble/hashes/sha2.js';
+ * const frost = createFROST({
+ *   name: 'FROST-ED25519-SHA512-v1',
+ *   Point: ed25519.Point,
+ *   hash: sha512,
+ * });
+ * ```
+ */
 export function createFROST<P extends FROSTPoint<P>>(opts: FrostOpts<P>): TRet<FROST> {
@@ -447,2 +635,4 @@ validateObject(
   const randomScalar = (rng: RNG = randomBytes) => {
+    if (typeof rng !== 'function')
+      throw new TypeError('"rng" expected function, got type=' + typeof rng);
     // Intentional divergence from RFC 9591 §4.1 / §5.1: the RFC nonce_generate helper outputs a
@@ -482,3 +672,4 @@ // Scalar in [0, p-1], but round-one commit publishes ScalarBaseMult(nonce) values and §3.1
   const serializeIdentifier = (id: bigint) => bytesToHex(Fn.toBytes(validateIdentifier(id)));
-  const parseIdentifier = (id: string) => {
+  const parseIdentifier = (id: string, title: string = 'identifier') => {
+    astring(id, title);
     const n = validateIdentifier(Fn.fromBytes(hexToBytes(id)));
@@ -501,3 +692,7 @@ // Keep string-keyed maps stable by accepting only the canonical serialized form.
       // We don't know size of point, but we know size of scalar
-      const R = parsePoint(sig.subarray(0, -Fn.BYTES));
+      const Rbytes = sig.subarray(0, -Fn.BYTES);
+      const R = parsePoint(Rbytes);
+      // RFC 9591 Section 3.1 SerializeElement is canonical: a signature must not verify under an
+      // alternative point encoding (e.g. re-encoding a weierstrass R uncompressed as 65 bytes).
+      if (serializePoint(R).length !== Rbytes.length) throw new Error('invalid signature encoding');
       const z = Fn.fromBytes(sig.subarray(-Fn.BYTES));
@@ -535,3 +730,5 @@ return { R, z };
   const Poly = poly(Fn, noRoots);
-  const msm = (points: P[], scalars: bigint[]) => pippenger(Point, points, scalars);
+  // Variable-time MSM over public inputs only (VSS / nonce commitments, binding factors).
+  // Interleaved wNAF beats pippenger ~3x at FROST-sized inputs (n <= dozens of signers).
+  const msm = (points: P[], scalars: bigint[]) => mulAddUnsafe(Point, points, scalars);
 
@@ -574,2 +771,6 @@ // Internal stuff uses bigints & Points, external Uint8Arrays
     validateSigners(signers);
+    if (secret !== undefined) abytes(secret, Fn.BYTES, 'secret');
+    if (coeffs !== undefined) aarray(coeffs, 'coeffs');
+    if (typeof rng !== 'function')
+      throw new TypeError('"rng" expected function, got type=' + typeof rng);
     // Dealer/DKG polynomial sampling reuses the same hardened scalar derivation as round-one
@@ -605,4 +806,4 @@ // nonces: overriding `rng` only swaps the entropy source, not the non-zero `1..n-1` policy.
       const c = this.challenge(id, phi, R);
-      // R === z*G - phi*c
-      if (!R.equals(Point.BASE.multiply(z).subtract(phi.multiply(c))))
+      // R === z*G - phi*c. All inputs are public: variable-time multiplication is safe here.
+      if (!R.equals(Point.BASE.multiplyUnsafe(z).subtract(phi.multiplyUnsafe(c))))
         throw new Error('invalid proof of knowledge');
@@ -626,5 +827,6 @@ },
       if (opts.adjustPoint) R = opts.adjustPoint(R);
+      // Signature, message and public key are all public: variable-time is safe on this path.
       const c = this.challenge(R, PK, msg);
-      const zB = Point.BASE.multiply(z); // z*G
-      const cA = PK.multiply(c); // c*PK
+      const zB = Point.BASE.multiplyUnsafe(z); // z*G
+      const cA = PK.multiplyUnsafe(c); // c*PK
       let check = zB.subtract(cA).subtract(R); // zB - cA - R
@@ -653,3 +855,3 @@ // No clearCoffactor on ristretto
     derive(s: string): Identifier {
-      if (typeof s !== 'string') throw new Error('wrong identifier string: ' + s);
+      astring(s, 's');
       // Derived identifiers may land anywhere in the scalar field; they are not restricted to
@@ -688,2 +890,5 @@ // sequential `1..max_signers` values.
     }
+    // Hiding commitments all carry scalar 1, so add them directly and keep only the
+    // binding commitments in the MSM: same result, half the MSM size.
+    let hidingSum = Point.ZERO;
     const points: P[] = [];
@@ -693,6 +898,7 @@ const scalars: bigint[] = [];
       if (Point.ZERO.equals(hC) || Point.ZERO.equals(bC)) throw new Error('infinity commitment');
-      points.push(hC, bC);
-      scalars.push(Fn.ONE, bindingFactors[i]);
+      hidingSum = hidingSum.add(hC);
+      points.push(bC);
+      scalars.push(bindingFactors[i]);
     }
-    const groupCommitment = msm(points, scalars); //  GC += hC + bC*bindingFactor
+    const groupCommitment = hidingSum.add(msm(points, scalars)); //  GC += hC + bC*bindingFactor
     const identifiers = CL.map((i) => i[1]);
@@ -733,4 +939,4 @@ return { identifiers, groupCommitment, bindingFactors };
       ) => {
+        const idNum = parseIdentifier(id, 'id');
         validateSigners(signers);
-        const idNum = parseIdentifier(id);
         const { coefficients, commitment } = generateSecretPolynomial(
@@ -764,2 +970,10 @@ signers,
       ): TRet<Record<string, DKG_Round2>> => {
+        validateObject(
+          secret as any,
+          { identifier: 'bigint', commitment: 'object', signers: 'object' },
+          { coefficients: 'object', round2Cache: 'object', step: 'number' },
+          'secret'
+        );
+        validateSigners(secret.signers, 'secret.signers');
+        aarray(others, 'others');
         if (others.length !== secret.signers.max - 1)
@@ -769,2 +983,4 @@ throw new Error('wrong number of round1 packages');
           throw new Error('round3 package used in round2');
+        if (secret.round2Cache !== undefined)
+          return secret.round2Cache as TRet<Record<string, DKG_Round2>>;
         const res: Record<Identifier, DKG_Round2> = {};
@@ -786,2 +1002,3 @@ for (const p of others) {
         }
+        secret.round2Cache = res;
         secret.step = 2;
@@ -795,2 +1012,11 @@ return res as TRet<Record<string, DKG_Round2>>;
       ): TRet<Key> => {
+        validateObject(
+          secret as any,
+          { identifier: 'bigint', commitment: 'object', signers: 'object' },
+          { coefficients: 'object', round2Cache: 'object', step: 'number' },
+          'secret'
+        );
+        validateSigners(secret.signers, 'secret.signers');
+        aarray(round1, 'round1');
+        aarray(round2, 'round2');
         // DKG is outside RFC 9591's signing flow; callers are expected to reuse the same
@@ -868,2 +1094,3 @@ // remote round1 packages already accepted in round2, like frost-rs documents.
         delete secret.coefficients;
+        delete secret.round2Cache;
         secret.step = 3;
@@ -873,2 +1100,8 @@ return res;
       clean(secret: TArg<DKG_Secret>) {
+        validateObject(
+          secret as any,
+          { identifier: 'bigint', commitment: 'object', signers: 'object' },
+          { coefficients: 'object', round2Cache: 'object', step: 'number' },
+          'secret'
+        );
         // Instead of replacing secret bigint with another (zero?), we subtract it from itself
@@ -883,2 +1116,3 @@ // in the hope that JIT will modify it inplace, instead of creating new value.
         // for (const c of secret.commitment) c.fill(0);
+        delete secret.round2Cache;
         secret.step = 3;
@@ -901,3 +1135,4 @@ },
       } else {
-        if (!Array.isArray(identifiers) || identifiers.length !== signers.max)
+        aarray(identifiers, 'identifiers');
+        if (identifiers.length !== signers.max)
           throw new Error('identifiers should be array of ' + signers.max);
@@ -934,2 +1169,16 @@ }
     validateSecret(secret: TArg<FrostSecret>, pub: TArg<FrostPublic>) {
+      validateObject(secret as any, { identifier: 'string', signingShare: 'object' }, {}, 'secret');
+      abytes(secret.signingShare, Fn.BYTES, 'secret.signingShare');
+      validateObject(
+        pub as any,
+        {
+          signers: 'object',
+          commitments: 'object',
+          verifyingShares: 'object',
+        },
+        {},
+        'pub'
+      );
+      validateSigners(pub.signers, 'pub.signers');
+      aarray(pub.commitments, 'pub.commitments');
       const id = parseIdentifier(secret.identifier);
@@ -948,2 +1197,6 @@ const commitment = pub.commitments.map(parsePoint);
     commit(secret: TArg<FrostSecret>, rng: RNG = randomBytes): TRet<GenNonce> {
+      validateObject(secret as any, { identifier: 'string', signingShare: 'object' }, {}, 'secret');
+      abytes(secret.signingShare, Fn.BYTES, 'secret.signingShare');
+      if (typeof rng !== 'function')
+        throw new TypeError('"rng" expected function, got type=' + typeof rng);
       const secretScalar = Fn.fromBytes(secret.signingShare);
@@ -964,2 +1217,21 @@ const hiding = generateNonce(secretScalar, rng);
     ): TRet<Uint8Array> {
+      validateObject(secret as any, { identifier: 'string', signingShare: 'object' }, {}, 'secret');
+      abytes(secret.signingShare, Fn.BYTES, 'secret.signingShare');
+      validateObject(
+        pub as any,
+        {
+          signers: 'object',
+          commitments: 'object',
+          verifyingShares: 'object',
+        },
+        {},
+        'pub'
+      );
+      validateSigners(pub.signers, 'pub.signers');
+      aarray(pub.commitments, 'pub.commitments');
+      validateObject(nonces as any, { hiding: 'object', binding: 'object' }, {}, 'nonces');
+      abytes(nonces.hiding, Fn.BYTES, 'nonces.hiding');
+      abytes(nonces.binding, Fn.BYTES, 'nonces.binding');
+      aarray(commitmentList, 'commitmentList');
+      abytes(msg, undefined, 'msg');
       validateCommitmentsNum(pub.signers, commitmentList.length);
@@ -1015,2 +1287,18 @@ const hidingNonce0 = Fn.fromBytes(nonces.hiding);
     ) {
+      validateObject(
+        pub as any,
+        {
+          signers: 'object',
+          commitments: 'object',
+          verifyingShares: 'object',
+        },
+        {},
+        'pub'
+      );
+      validateSigners(pub.signers, 'pub.signers');
+      aarray(pub.commitments, 'pub.commitments');
+      aarray(commitmentList, 'commitmentList');
+      abytes(msg, undefined, 'msg');
+      parseIdentifier(identifier);
+      abytes(sigShare, Fn.BYTES, 'sigShare');
       if (opts.adjustPublic) pub = opts.adjustPublic(pub);
@@ -1028,9 +1316,12 @@ const comm = commitmentList.find((i) => i.identifier === identifier);
       );
+      // Signature shares, commitments and verifying shares are public: vartime is safe here.
       // hC + bC * bF
-      let commShare = hidingNonceCommitment.add(bindingNonceCommitment.multiply(bindingFactor));
+      let commShare = hidingNonceCommitment.add(
+        bindingNonceCommitment.multiplyUnsafe(bindingFactor)
+      );
       if (opts.adjustGroupCommitmentShare)
         commShare = opts.adjustGroupCommitmentShare(groupCommitment, commShare);
-      const l = Point.BASE.multiply(Fn.fromBytes(sigShare)); // sigShare*G
+      const l = Point.BASE.multiplyUnsafe(Fn.fromBytes(sigShare)); // sigShare*G
       // commShare + PK * (challenge * lambda)
-      const r = commShare.add(PK.multiply(Fn.mul(challenge, lambda)));
+      const r = commShare.add(PK.multiplyUnsafe(Fn.mul(challenge, lambda)));
       return l.equals(r);
@@ -1045,2 +1336,19 @@ },
     ): TRet<Uint8Array> {
+      validateObject(
+        pub as any,
+        {
+          signers: 'object',
+          commitments: 'object',
+          verifyingShares: 'object',
+        },
+        {},
+        'pub'
+      );
+      validateSigners(pub.signers, 'pub.signers');
+      aarray(pub.commitments, 'pub.commitments');
+      aarray(commitmentList, 'commitmentList');
+      abytes(msg, undefined, 'msg');
+      validateObject(sigShares as any, {}, {}, 'sigShares');
+      // verifyShare() applies adjustPublic too, so keep the original package for attribution.
+      const rawPub = pub;
       if (opts.adjustPublic) pub = opts.adjustPublic(pub);
@@ -1053,2 +1361,8 @@ try {
       const ids = commitmentList.map((i) => i.identifier);
+      const seen = new Set<Identifier>();
+      for (const id of ids) {
+        // `sigShares` is identifier-keyed, so duplicate commitments would reuse one share twice.
+        if (seen.has(id)) throw new AggErr('aggregation failed', []);
+        seen.add(id);
+      }
       if (ids.length !== Object.keys(sigShares).length) throw new AggErr('aggregation failed', []);
@@ -1067,3 +1381,3 @@ for (const id of ids) {
         for (const id of ids) {
-          if (!this.verifyShare(pub, commitmentList, msg, id, sigShares[id])) cheaters.push(id);
+          if (!this.verifyShare(rawPub, commitmentList, msg, id, sigShares[id])) cheaters.push(id);
         }
@@ -1089,4 +1403,5 @@ throw new AggErr('aggregation failed', cheaters);
     combineSecret(shares: TArg<FrostSecret[]>, signers: Signers): TRet<Uint8Array> {
+      aarray(shares, 'shares');
       validateSigners(signers);
-      if (!Array.isArray(shares) || shares.length < signers.min)
+      if (shares.length < signers.min || shares.length > signers.max)
         throw new Error('wrong secret shares array');
@@ -1093,0 +1408,0 @@ const points = [];

src/abstract/hash-to-curve.ts

@@ -10,2 +10,3 @@ /**
 import {
+  aarray,
   abytes,
@@ -15,4 +16,4 @@ asafenumber,
   bytesToNumberBE,
+  concatBytes,
   copyBytes,
-  concatBytes,
   isBytes,
@@ -22,4 +23,7 @@ validateObject,
 import type { AffinePoint, PC_ANY, PC_F, PC_P } from './curve.ts';
-import { FpInvertBatch, mod, type IField } from './modular.ts';
+import { FpInvertBatch, FpIsSquare, mod, validateField, type IField } from './modular.ts';
 
+// prettier-ignore
+const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4);
+
 /** ASCII domain-separation tag or raw bytes. */
@@ -196,2 +200,5 @@ export type AsciiOrBytes = string | Uint8Array;
   asafenumber(lenInBytes);
+  if (typeof H !== 'function') throw new Error('expand_message_xmd: expected hash function');
+  asafenumber(H.outputLen, 'hash.outputLen');
+  asafenumber(H.blockLen, 'hash.blockLen');
   DST = normDST(DST);
@@ -258,3 +265,9 @@ // https://www.rfc-editor.org/rfc/rfc9380#section-5.3.3
   asafenumber(lenInBytes);
+  asafenumber(k, 'k');
+  if (k < 0) throw new Error('expand_message_xof: invalid k');
+  if (typeof H !== 'function') throw new Error('expand_message_xof: expected XOF function');
+  if (typeof H.create !== 'function') throw new Error('expand_message_xof: expected XOF create');
   DST = normDST(DST);
+  if (lenInBytes < 0 || lenInBytes > 65535)
+    throw new Error('expand_message_xof: invalid lenInBytes');
   // https://www.rfc-editor.org/rfc/rfc9380#section-5.3.3
@@ -266,4 +279,5 @@ // RFC 9380 §5.3.3: DST = H("H2C-OVERSIZE-DST-" || a_very_long_DST, ceil(2 * k / 8)).
   }
-  if (lenInBytes > 65535 || DST.length > 255)
-    throw new Error('expand_message_xof: invalid lenInBytes');
+  // Oversize DSTs are compressed above; fail closed if a custom XOF still returns one
+  // (possible when k > 1020 makes the compression dkLen itself exceed 255 bytes).
+  if (DST.length > 255) throw new Error('expand_message_xof: invalid DST');
   return (
@@ -319,6 +333,11 @@ H.create({ dkLen: lenInBytes })
   asafenumber(count);
-  // RFC 9380 §5.2 defines hash_to_field over a list of one or more field elements and requires
+  asafenumber(m, 'm');
+  asafenumber(k, 'k');
+  // RFC 9380 §5.2 defines hash_to_field over a list of one or more field elements and an integer
   // extension degree `m >= 1`; rejecting here avoids degenerate `[]` / `[[]]` helper outputs.
+  // The RFC also treats `p` as a finite-field characteristic; bad values degenerate log2/mod.
+  if (p <= BigInt(1)) throw new Error('hash_to_field: expected valid field characteristic');
   if (count < 1) throw new Error('hash_to_field: expected count >= 1');
   if (m < 1) throw new Error('hash_to_field: expected m >= 1');
+  if (k < 0) throw new Error('hash_to_field: invalid k');
   const log2p = p.toString(2).length;
@@ -333,3 +352,4 @@ const L = Math.ceil((log2p + k) / 8); // section 5.1 of ietf draft link above
   } else if (expand === '_internal_pass') {
-    // for internal tests only
+    // for internal tests only: msg is used as the uniform bytes directly. Short msg is allowed
+    // on purpose (subarray() slices are short): zkcrypto map_scalar vectors feed empty okm.
     prb = msg;
@@ -370,4 +390,10 @@ } else {
 export function isogenyMap<T, F extends IField<T>>(field: F, map: XYRatio<T>): XY<T> {
+  validateField(field);
   // Make same order as in spec
-  const coeff = map.map((i) => Array.from(i).reverse());
+  aarray<T[]>(map, 'map');
+  const coeff = map.map((i, row) => {
+    aarray(i, 'map[' + row + ']');
+    if (i.length < 1) throw new Error('isogenyMap: expected non-empty coefficients');
+    return Array.from(i).reverse();
+  });
   return (x: T, y: T) => {
@@ -377,4 +403,3 @@ const [xn, xd, yn, yd] = coeff.map((val) =>
     );
-    // RFC 9380 §6.6.3 / Appendix E: denominator-zero exceptional cases must
-    // return the identity on E.
+    const isZero = field.is0(xd) || field.is0(yd);
     // Shipped Weierstrass consumers encode that affine identity as all-zero
@@ -386,3 +411,5 @@ // coordinates, so `passZero=true` intentionally collapses zero
     y = field.mul(y, field.mul(yn, yd_inv)); // y * (yNum / yDev)
-    return { x, y };
+    // RFC 9380 §6.6.3: if the denominator of either isogeny rational function is
+    // zero, the exceptional case must return the identity point on E.
+    return isZero ? { x: field.ZERO, y: field.ZERO } : { x, y };
   };
@@ -402,4 +429,4 @@ }
  * @param mapToCurve - Map-to-curve function.
- * @param defaults - Default hash-to-curve options. This object is frozen in place and reused as
- *   the shared defaults bundle for the returned helpers.
+ * @param defaults - Default hash-to-curve options. A frozen detached snapshot is reused as the
+ *   shared defaults bundle for the returned helpers.
  * @returns Hash-to-curve helper namespace.
@@ -432,2 +459,3 @@ * @throws If the map-to-curve callback or default hash-to-curve options are invalid. {@link Error}
   if (typeof mapToCurve !== 'function') throw new Error('mapToCurve() must be defined');
+  validateObject(defaults);
   // `Point` is intentionally not shape-validated eagerly here: point constructors vary across
@@ -449,2 +477,7 @@ // curve families, so this helper only checks the hooks it can validate cheaply. Misconfigured
   const safeDefaults = snapshot(defaults);
+  // Per-call options are H2CDSTOpts: only DST may be overridden. Copying just that key keeps
+  // off-type option objects from silently replacing suite parameters (p/m/k/hash/expand) at
+  // runtime — same pinning hashToScalar always did for p/m.
+  const dstOverride = (options?: TArg<H2CDSTOpts>) =>
+    options && options.DST !== undefined ? { DST: options.DST } : undefined;
   function map(num: bigint[]): PC_P<PC> {
@@ -469,3 +502,3 @@ return Point.fromAffine(mapToCurve(num)) as PC_P<PC>;
     hashToCurve(msg: TArg<Uint8Array>, options?: TArg<H2CDSTOpts>): PC_P<PC> {
-      const opts = Object.assign({}, safeDefaults, options);
+      const opts = Object.assign({}, safeDefaults, dstOverride(options));
       const u = hash_to_field(msg, 2, opts);
@@ -477,4 +510,4 @@ const u0 = map(u[0]);
     encodeToCurve(msg: TArg<Uint8Array>, options?: TArg<H2CDSTOpts>): PC_P<PC> {
-      const optsDst = safeDefaults.encodeDST ? { DST: safeDefaults.encodeDST } : {};
-      const opts = Object.assign({}, safeDefaults, optsDst, options);
+      const optsDst = safeDefaults.encodeDST === undefined ? {} : { DST: safeDefaults.encodeDST };
+      const opts = Object.assign({}, safeDefaults, optsDst, dstOverride(options));
       const u = hash_to_field(msg, 1, opts);
@@ -492,2 +525,5 @@ const u0 = map(u[0]);
       if (!Array.isArray(scalars)) throw new Error('expected array of bigints');
+      // RFC 9380 represents one GF(p^m) element as exactly m base-field scalars.
+      if (scalars.length !== safeDefaults.m)
+        throw new Error(`expected array of ${safeDefaults.m} bigints`);
       for (const i of scalars)
@@ -504,3 +540,6 @@ if (typeof i !== 'bigint') throw new Error('expected array of bigints');
       const N = Point.Fn.ORDER;
-      const opts = Object.assign({}, safeDefaults, { p: N, m: 1, DST: _DST_scalar }, options);
+      const opts = Object.assign({}, safeDefaults, { DST: _DST_scalar }, dstOverride(options), {
+        p: N,
+        m: 1,
+      });
       return hash_to_field(msg, 1, opts)[0][0];
@@ -510,1 +549,188 @@ },
 }
+
+/**
+ * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.
+ * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.
+ * b = True and y = sqrt(u / v) if (u / v) is square in F, and
+ * b = False and y = sqrt(Z * (u / v)) otherwise.
+ * RFC 9380 expects callers to provide `v != 0`; this helper does not enforce it.
+ * @param Fp - Field implementation.
+ * @param Z - Simplified SWU map parameter.
+ * @returns Square-root ratio helper.
+ * @example
+ * Build the square-root ratio helper used by SWU map implementations.
+ *
+ * ```ts
+ * import { SWUFpSqrtRatio } from '@noble/curves/abstract/hash-to-curve.js';
+ * import { Field } from '@noble/curves/abstract/modular.js';
+ * const Fp = Field(17n);
+ * const sqrtRatio = SWUFpSqrtRatio(Fp, 3n);
+ * const out = sqrtRatio(4n, 1n);
+ * ```
+ */
+export function SWUFpSqrtRatio<T>(
+  Fp: TArg<IField<T>>,
+  Z: T
+): (u: T, v: T) => { isValid: boolean; value: T } {
+  // Fail with the usual field-shape error before touching pow/cmov on malformed field shims.
+  const F = validateField(Fp as IField<T>) as IField<T>;
+  // Generic implementation
+  const q = F.ORDER;
+  let l = _0n;
+  for (let o = q - _1n; o % _2n === _0n; o /= _2n) l += _1n;
+  const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.
+  // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.
+  // 2n ** c1 == 2n << (c1-1)
+  const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);
+  const _2n_pow_c1 = _2n_pow_c1_1 * _2n;
+  const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic
+  const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic
+  const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic
+  const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic
+  const c6 = F.pow(Z, c2); // 6. c6 = Z^c2
+  const c7 = F.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)
+  // RFC 9380 Appendix F.2.1.1 defines sqrt_ratio(u, v) only for v != 0.
+  // We keep v=0 on the regular result path with isValid=false instead of
+  // throwing so the helper stays closer to the RFC's fixed control flow.
+  let sqrtRatio = (u: T, v: T): { isValid: boolean; value: T } => {
+    let tv1 = c6; // 1. tv1 = c6
+    let tv2 = F.pow(v, c4); // 2. tv2 = v^c4
+    let tv3 = F.sqr(tv2); // 3. tv3 = tv2^2
+    tv3 = F.mul(tv3, v); // 4. tv3 = tv3 * v
+    let tv5 = F.mul(u, tv3); // 5. tv5 = u * tv3
+    tv5 = F.pow(tv5, c3); // 6. tv5 = tv5^c3
+    tv5 = F.mul(tv5, tv2); // 7. tv5 = tv5 * tv2
+    tv2 = F.mul(tv5, v); // 8. tv2 = tv5 * v
+    tv3 = F.mul(tv5, u); // 9. tv3 = tv5 * u
+    let tv4 = F.mul(tv3, tv2); // 10. tv4 = tv3 * tv2
+    tv5 = F.pow(tv4, c5); // 11. tv5 = tv4^c5
+    let isQR = F.eql(tv5, F.ONE); // 12. isQR = tv5 == 1
+    tv2 = F.mul(tv3, c7); // 13. tv2 = tv3 * c7
+    tv5 = F.mul(tv4, tv1); // 14. tv5 = tv4 * tv1
+    tv3 = F.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)
+    tv4 = F.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)
+    // 17. for i in (c1, c1 - 1, ..., 2):
+    for (let i = c1; i > _1n; i--) {
+      let tv5 = i - _2n; // 18.    tv5 = i - 2
+      tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5
+      let tvv5 = F.pow(tv4, tv5); // 20.    tv5 = tv4^tv5
+      const e1 = F.eql(tvv5, F.ONE); // 21.    e1 = tv5 == 1
+      tv2 = F.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1
+      tv1 = F.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1
+      tvv5 = F.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1
+      tv3 = F.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)
+      tv4 = F.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)
+    }
+    // RFC 9380 Appendix F.2.1.1 defines sqrt_ratio(u, v) for v != 0.
+    // When u = 0 and v != 0, u / v = 0 is square and the computed root is
+    // still 0, so widen only the final flag and keep the full control flow.
+    return { isValid: !F.is0(v) && (isQR || F.is0(u)), value: tv3 };
+  };
+  if (F.ORDER % _4n === _3n) {
+    // sqrt_ratio_3mod4(u, v)
+    const c1 = (F.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic
+    const c2 = F.sqrt(F.neg(Z)); // 2. c2 = sqrt(-Z)
+    sqrtRatio = (u: T, v: T) => {
+      let tv1 = F.sqr(v); // 1. tv1 = v^2
+      const tv2 = F.mul(u, v); // 2. tv2 = u * v
+      tv1 = F.mul(tv1, tv2); // 3. tv1 = tv1 * tv2
+      let y1 = F.pow(tv1, c1); // 4. y1 = tv1^c1
+      y1 = F.mul(y1, tv2); // 5. y1 = y1 * tv2
+      const y2 = F.mul(y1, c2); // 6. y2 = y1 * c2
+      const tv3 = F.mul(F.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v
+      const isQR = F.eql(tv3, u); // 9. isQR = tv3 == u
+      let y = F.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)
+      return { isValid: !F.is0(v) && isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2
+    };
+  }
+  // No curves uses that
+  // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8
+  return sqrtRatio;
+}
+/**
+ * Simplified Shallue-van de Woestijne-Ulas Method
+ * See {@link https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2 | RFC 9380 section 6.6.2}.
+ * @param Fp - Field implementation.
+ * @param opts - SWU parameters:
+ *   - `A`: Curve parameter `A`.
+ *   - `B`: Curve parameter `B`.
+ *   - `Z`: Simplified SWU map parameter.
+ * @returns Deterministic map-to-curve function.
+ * @throws If the SWU parameters are invalid or the field lacks the required helpers. {@link Error}
+ * @example
+ * Map one field element to a Weierstrass curve point with the SWU recipe.
+ *
+ * ```ts
+ * import { mapToCurveSimpleSWU } from '@noble/curves/abstract/hash-to-curve.js';
+ * import { Field } from '@noble/curves/abstract/modular.js';
+ * const Fp = Field(17n);
+ * const map = mapToCurveSimpleSWU(Fp, { A: 1n, B: 2n, Z: 3n });
+ * const point = map(5n);
+ * ```
+ */
+export function mapToCurveSimpleSWU<T>(
+  Fp: TArg<IField<T>>,
+  opts: {
+    A: T;
+    B: T;
+    Z: T;
+  }
+): (u: T) => { x: T; y: T } {
+  const F = validateField(Fp as IField<T>) as IField<T>;
+  validateObject(opts as any, {}, {}, 'opts');
+  const { A, B, Z } = opts;
+  if (!F.isValidNot0(A) || !F.isValidNot0(B) || !F.isValid(Z))
+    throw new Error('mapToCurveSimpleSWU: invalid opts');
+  // RFC 9380 §6.6.2 and Appendix H.2 require:
+  // 1. Z is non-square in F
+  // 2. Z != -1 in F
+  // 3. g(x) - Z is irreducible over F
+  // 4. g(B / (Z * A)) is square in F
+  // We can enforce 1, 2, and 4 with the current field API.
+  // Criterion 3 is not checked here because generic `IField<T>` does not expose
+  // polynomial-ring / irreducibility operations, and this helper is used for
+  // both prime and extension fields.
+  if (F.eql(Z, F.neg(F.ONE)) || FpIsSquare(F, Z))
+    throw new Error('mapToCurveSimpleSWU: invalid opts');
+  // RFC 9380 Appendix H.2 criterion 4: g(B / (Z * A)) is square in F.
+  // x = B / (Z * A)
+  const x = F.mul(B, F.inv(F.mul(Z, A)));
+  // g(x) = x^3 + A*x + B
+  const gx = F.add(F.add(F.mul(F.sqr(x), x), F.mul(A, x)), B);
+  if (!FpIsSquare(F, gx)) throw new Error('mapToCurveSimpleSWU: invalid opts');
+  const sqrtRatio = SWUFpSqrtRatio(F, Z);
+  if (!F.isOdd) throw new Error('Field does not have .isOdd()');
+  // Input: u, an element of F.
+  // Output: (x, y), a point on E.
+  return (u: T): { x: T; y: T } => {
+    // prettier-ignore
+    let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
+    tv1 = F.sqr(u); // 1.  tv1 = u^2
+    tv1 = F.mul(tv1, Z); // 2.  tv1 = Z * tv1
+    tv2 = F.sqr(tv1); // 3.  tv2 = tv1^2
+    tv2 = F.add(tv2, tv1); // 4.  tv2 = tv2 + tv1
+    tv3 = F.add(tv2, F.ONE); // 5.  tv3 = tv2 + 1
+    tv3 = F.mul(tv3, B); // 6.  tv3 = B * tv3
+    tv4 = F.cmov(Z, F.neg(tv2), !F.eql(tv2, F.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)
+    tv4 = F.mul(tv4, A); // 8.  tv4 = A * tv4
+    tv2 = F.sqr(tv3); // 9.  tv2 = tv3^2
+    tv6 = F.sqr(tv4); // 10. tv6 = tv4^2
+    tv5 = F.mul(tv6, A); // 11. tv5 = A * tv6
+    tv2 = F.add(tv2, tv5); // 12. tv2 = tv2 + tv5
+    tv2 = F.mul(tv2, tv3); // 13. tv2 = tv2 * tv3
+    tv6 = F.mul(tv6, tv4); // 14. tv6 = tv6 * tv4
+    tv5 = F.mul(tv6, B); // 15. tv5 = B * tv6
+    tv2 = F.add(tv2, tv5); // 16. tv2 = tv2 + tv5
+    x = F.mul(tv1, tv3); // 17.   x = tv1 * tv3
+    const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)
+    y = F.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1
+    y = F.mul(y, value); // 20.   y = y * y1
+    x = F.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)
+    y = F.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)
+    const e1 = F.isOdd!(u) === F.isOdd!(y); // 23.  e1 = sgn0(u) == sgn0(y)
+    y = F.cmov(F.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)
+    const tv4_inv = FpInvertBatch(F, [tv4], true)[0];
+    x = F.mul(x, tv4_inv); // 25.   x = x / tv4
+    return { x, y };
+  };
+}

src/abstract/modular.ts

@@ -9,5 +9,8 @@ /**
 import {
+  aarray,
   abool,
   abytes,
+  afunction,
   anumber,
+  aobject,
   asafenumber,
@@ -19,3 +22,2 @@ bitLen,
   numberToBytesLE,
-  validateObject,
   type TArg,
@@ -32,3 +34,7 @@ type TRet,
 const _7n = /* @__PURE__ */ BigInt(7), _8n = /* @__PURE__ */ BigInt(8), _9n = /* @__PURE__ */ BigInt(9);
-const _16n = /* @__PURE__ */ BigInt(16);
+const _15n = /* @__PURE__ */ BigInt(15),
+  _16n = /* @__PURE__ */ BigInt(16);
+// 2^64: exponents below this use plain square-and-multiply in pow()/FpPow(); the windowed path's
+// table build (14 multiplications) only pays off for longer exponents (break-even ~50 bits).
+const POW_WINDOWED_MIN = /* @__PURE__ */ BigInt('0x10000000000000000');
 
@@ -70,3 +76,45 @@ /**
 export function pow(num: bigint, power: bigint, modulo: bigint): bigint {
-  return FpPow(Field(modulo), num, power);
+  if (modulo <= _1n) throw new Error('pow: expected modulus > 1, got ' + modulo);
+  // Non-bigint exponents coerce every comparison below to false and would silently return 1.
+  if (typeof power !== 'bigint')
+    throw new TypeError('invalid exponent: expected bigint, got ' + typeof power);
+  if (power < _0n) throw new Error('invalid exponent, negatives unsupported');
+  if (power === _0n) return _1n;
+  if (power === _1n) return num;
+  let d = num % modulo;
+  if (d < _0n) d += modulo;
+  // Control flow in both branches below depends only on the exponent, never on `num` — invertCt()
+  // relies on that for its (public-exponent) secret-independence guarantee.
+  if (power < POW_WINDOWED_MIN) {
+    // Square-and-multiply: cheaper than the windowed path for short exponents.
+    let p = _1n;
+    while (power > _0n) {
+      if (power & _1n) p = (p * d) % modulo;
+      d = (d * d) % modulo;
+      power >>= _1n;
+    }
+    return p;
+  }
+  // Fixed 4-bit windows, MSB-first: a 14-multiplication table drops per-window cost to <1
+  // multiplication (vs ~2 per window for square-and-multiply), ~25-30% faster for the dense
+  // 256-bit exponents of sqrt / Legendre / invertCt.
+  const digits: number[] = [];
+  while (power > _0n) {
+    digits.push(Number(power & _15n));
+    power >>= _4n;
+  }
+  const table: bigint[] = new Array(16);
+  table[0] = _1n;
+  table[1] = d;
+  for (let i = 2; i < 16; i++) table[i] = (table[i - 1] * d) % modulo;
+  let p = table[digits[digits.length - 1]]; // top digit is nonzero: the loop above stops on 0
+  for (let w = digits.length - 2; w >= 0; w--) {
+    p = (p * p) % modulo;
+    p = (p * p) % modulo;
+    p = (p * p) % modulo;
+    p = (p * p) % modulo;
+    const digit = digits[w];
+    if (digit !== 0) p = (p * table[digit]) % modulo;
+  }
+  return p;
 }
@@ -91,2 +139,3 @@
 export function pow2(x: bigint, power: bigint, modulo: bigint): bigint {
+  if (modulo <= _1n) throw new Error('pow2: expected modulus > 1, got ' + modulo);
   if (power < _0n) throw new Error('pow2: expected non-negative exponent, got ' + power);
@@ -105,3 +154,3 @@ let res = x;
  * @param number - Value to invert.
- * @param modulo - Positive modulus.
+ * @param modulo - Modulus greater than 1.
  * @returns Multiplicative inverse.
@@ -118,8 +167,13 @@ * @throws If the modulus is invalid or the inverse does not exist. {@link Error}
   if (number === _0n) throw new Error('invert: expected non-zero number');
-  if (modulo <= _0n) throw new Error('invert: expected positive modulus, got ' + modulo);
-  // Fermat's little theorem "CT-like" version inv(n) = n^(m-2) mod m is 30x slower.
+  // modulo = 1 is the zero ring: gcd(x, 1) = 1 makes the loop below "succeed" and return the
+  // useless inverse 0. Reject it like pow() and invertCt() do.
+  if (modulo <= _1n) throw new Error('invert: expected modulus > 1, got ' + modulo);
+  // This is variable-time: the loop count depends on `number`. For a secret-independent
+  // (Fermat) alternative over a prime modulus, see {@link invertCt} (~4x slower).
   let a = mod(number, modulo);
   let b = modulo;
+  // Only the Bézout coefficient of `number` (x/u chain) is tracked; the coefficient of `modulo`
+  // never affects the output, so it is not computed.
   // prettier-ignore
-  let x = _0n, y = _1n, u = _1n, v = _0n;
+  let x = _0n, u = _1n;
   while (a !== _0n) {
@@ -129,5 +183,4 @@ const q = b / a;
     const m = x - u * q;
-    const n = y - v * q;
     // prettier-ignore
-    b = a, a = r, x = u, y = v, u = m, v = n;
+    b = a, a = r, x = u, u = m;
   }
@@ -139,2 +192,38 @@ const gcd = b;
 
+/**
+ * Inverses number over modulo using Fermat's little theorem: `a^(p-2) ≡ a⁻¹ (mod p)`.
+ *
+ * Unlike {@link invert} (extended Euclidean), the exponent `p-2` is a public constant, so the
+ * underlying square-and-multiply has the same control flow for every secret `a`: there is no
+ * data-dependent branching or loop count that could leak `a` through timing (e.g. Minerva-style
+ * ECDSA nonce-inversion attacks). This is only "algorithmically" constant-time — JS bigint
+ * multiplication/reduction is still value-dependent — and it is roughly 4x slower than
+ * {@link invert}.
+ *
+ * REQUIRES a prime modulus; Fermat's theorem does not hold otherwise. The result is verified to be
+ * a real inverse, so a non-prime modulus (or a non-invertible input) fails closed with an error
+ * instead of returning a wrong value.
+ * @param a - Value to invert.
+ * @param prime - Prime modulus.
+ * @returns Multiplicative inverse in `[1, prime)`.
+ * @throws If the modulus is below 2, the input reduces to zero, or the inverse does not exist.
+ *   {@link Error}
+ * @example
+ * Compute one modular inverse without secret-dependent branching.
+ *
+ * ```ts
+ * invertCt(3n, 11n); // 4n, since 3 * 4 = 12 ≡ 1 (mod 11)
+ * ```
+ */
+export function invertCt(a: bigint, prime: bigint): bigint {
+  if (prime <= _1n) throw new Error('invertCt: expected prime modulus > 1, got ' + prime);
+  const an = mod(a, prime);
+  if (an === _0n) throw new Error('invertCt: expected non-zero number');
+  // Exponent (prime - 2) is public, so FpPow's square-and-multiply is secret-independent.
+  const inverse = pow(an, prime - _2n, prime);
+  // O(1) safety net: verifies the inverse and rejects composite moduli where a^(p-2) is not one.
+  if (mod(an * inverse, prime) !== _1n) throw new Error('invertCt: does not exist');
+  return inverse;
+}
+
 function assertIsSquare<T>(Fp: TArg<IField<T>>, root: T, n: T): void {
@@ -145,2 +234,11 @@ const F = Fp as IField<T>;
 
+// The Legendre symbol and every sqrt variant here are only defined over an odd (prime) modulus.
+// An even ORDER makes their integer divisions — (p-1)/2, (p+1)/4, (p-5)/8, (p+7)/16 — truncate and
+// silently return a wrong result, so reject it explicitly at the entry points instead. This is a
+// cheap necessary-condition check, not a primality test (composite odd moduli are caught later by
+// the Legendre-result / assertIsSquare checks).
+function aoddModulus(order: bigint, fnName: string): void {
+  if ((order & _1n) === _0n) throw new Error(fnName + ': expected odd modulus, got ' + order);
+}
+
 // Not all roots are possible! Example which will throw:
@@ -220,2 +318,3 @@ // const NUM =
   if (P < _3n) throw new Error('sqrt is not defined for small field');
+  aoddModulus(P, 'tonelliShanks');
   // Factor P - 1 = Q * 2^S, where Q is odd
@@ -259,3 +358,5 @@ let Q = P - _1n;
     while (!F.eql(t, F.ONE)) {
-      if (F.is0(t)) return F.ZERO; // if t=0 return R=0
+      // Unreachable over a genuine field (no zero divisors; n=0 already returned above). A zero t
+      // means composite ORDER, where a fabricated root would be wrong: fail closed instead.
+      if (F.is0(t)) throw new Error('Cannot find square root: probably non-prime P');
       let i = 1;
@@ -310,2 +411,3 @@
 export function FpSqrt(P: bigint): TRet<<T>(Fp: IField<T>, n: T) => T> {
+  aoddModulus(P, 'Fp.sqrt');
   // P ≡ 3 (mod 4) => √n = n^((P+1)/4)
@@ -487,3 +589,2 @@ if (P % _4n === _3n) return sqrt3mod4 as TRet<<T>(Fp: IField<T>, n: T) => T>;
   isOdd?(num: T): boolean;
-  // legendre?(num: T): T;
   /**
@@ -545,16 +646,10 @@ * Invert many field elements in one batch.
 export function validateField<T>(field: TArg<IField<T>>): TRet<IField<T>> {
-  const initial = {
-    ORDER: 'bigint',
-    BYTES: 'number',
-    BITS: 'number',
-  } as Record<string, string>;
-  const opts = FIELD_FIELDS.reduce((map, val: string) => {
-    map[val] = 'function';
-    return map;
-  }, initial);
-  validateObject(field, opts);
+  aobject(field as any, 'field');
+  if (typeof field.ORDER !== 'bigint')
+    throw new TypeError('param "ORDER" is invalid: expected bigint, got ' + typeof field.ORDER);
   // Runtime field implementations must expose real integer byte/bit sizes; fractional / NaN /
-  // infinite metadata leaks through validateObject(type='number') but breaks encoders and caches.
+  // infinite metadata breaks encoders and caches.
   asafenumber(field.BYTES, 'BYTES');
   asafenumber(field.BITS, 'BITS');
+  for (const name of FIELD_FIELDS) afunction((field as any)[name], 'field.' + name);
   // Runtime field implementations must expose positive byte/bit sizes; zero leaks through the
@@ -587,13 +682,40 @@ // numeric shape checks above but still breaks encoding helpers and cached-length assumptions.
 export function FpPow<T>(Fp: TArg<IField<T>>, num: T, power: bigint): T {
+  validateField(Fp);
   const F = Fp as IField<T>;
+  // Non-bigint exponents (e.g. an accidental field element) coerce every comparison below to
+  // false and would silently return ONE.
+  if (typeof power !== 'bigint')
+    throw new TypeError('invalid exponent: expected bigint, got ' + typeof power);
   if (power < _0n) throw new Error('invalid exponent, negatives unsupported');
   if (power === _0n) return F.ONE;
   if (power === _1n) return num;
-  let p = F.ONE;
-  let d = num;
+  if (power < POW_WINDOWED_MIN) {
+    // Square-and-multiply: cheaper than the windowed path for short exponents (e.g. poseidon
+    // sbox x^5), which would waste the 14-multiplication table build.
+    let p = F.ONE;
+    let d = num;
+    while (power > _0n) {
+      if (power & _1n) p = F.mul(p, d);
+      d = F.sqr(d);
+      power >>= _1n;
+    }
+    return p;
+  }
+  // Fixed 4-bit windows, MSB-first — same shape as pow() above, over generic field ops.
+  // Speeds up dense long exponents (extension-field sqrt / Legendre, e.g. Fp2 decompression).
+  const digits: number[] = [];
   while (power > _0n) {
-    if (power & _1n) p = F.mul(p, d);
-    d = F.sqr(d);
-    power >>= _1n;
+    digits.push(Number(power & _15n));
+    power >>= _4n;
   }
+  const table: T[] = new Array(16);
+  table[0] = F.ONE;
+  table[1] = num;
+  for (let i = 2; i < 16; i++) table[i] = F.mul(table[i - 1], num);
+  let p = table[digits[digits.length - 1]]; // top digit is nonzero: the loop above stops on 0
+  for (let w = digits.length - 2; w >= 0; w--) {
+    p = F.sqr(F.sqr(F.sqr(F.sqr(p))));
+    const digit = digits[w];
+    if (digit !== 0) p = F.mul(p, table[digit]);
+  }
   return p;
@@ -604,7 +726,11 @@ }
  * Efficiently invert an array of Field elements.
- * Exception-free. Zero-valued field elements stay `undefined` unless `passZero` is enabled.
+ * Zero-valued inputs are not inverted: by default their slot stays `undefined` (hence the
+ * `(T | undefined)[]` return type), or becomes `0` when `passZero` is enabled. Because of that the
+ * batch never calls `inv` on a zero, so over a prime field it is exception-free. The single
+ * `Fp.inv` of the accumulated product can still throw, but only for a non-invertible product, which
+ * a prime `ORDER` cannot produce (it requires a composite / non-field `ORDER`).
  * @param Fp - Field implementation.
  * @param nums - Values to invert.
  * @param passZero - map 0 to 0 (instead of undefined)
- * @returns Inverted values.
+ * @returns Inverted values; entries for zero inputs are `undefined` unless `passZero` is set.
  * @example
@@ -619,5 +745,18 @@ * Invert several field elements with one shared inversion.
  */
-export function FpInvertBatch<T>(Fp: TArg<IField<T>>, nums: T[], passZero = false): T[] {
+export function FpInvertBatch<T>(Fp: TArg<IField<T>>, nums: T[], passZero: true): T[];
+export function FpInvertBatch<T>(
+  Fp: TArg<IField<T>>,
+  nums: T[],
+  passZero?: boolean
+): (T | undefined)[];
+export function FpInvertBatch<T>(
+  Fp: TArg<IField<T>>,
+  nums: T[],
+  passZero = false
+): (T | undefined)[] {
+  validateField(Fp);
+  aarray(nums, 'nums');
+  abool(passZero, 'passZero');
   const F = Fp as IField<T>;
-  const inverted = new Array(nums.length).fill(passZero ? F.ZERO : undefined) as T[];
+  const inverted = new Array(nums.length).fill(passZero ? F.ZERO : undefined) as (T | undefined)[];
   // Walk from first to last, multiply them by each other MOD p
@@ -634,3 +773,4 @@ const multipliedAcc = nums.reduce((acc, num, i) => {
     if (F.is0(num)) return acc;
-    inverted[i] = F.mul(acc, inverted[i]);
+    // Non-zero `num` means the forward pass already stored a defined prefix product at index i.
+    inverted[i] = F.mul(acc, inverted[i]!);
     return F.mul(acc, num);
@@ -657,2 +797,3 @@ }, invertedAcc);
 export function FpDiv<T>(Fp: TArg<IField<T>>, lhs: T, rhs: T | bigint): T {
+  validateField(Fp);
   const F = Fp as IField<T>;
@@ -673,3 +814,3 @@ return F.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, F.ORDER) : F.inv(rhs));
  * @returns Legendre symbol.
- * @throws If the field returns an invalid Legendre symbol value. {@link Error}
+ * @throws If the powered value does not match a valid Legendre symbol. {@link Error}
  * @example
@@ -685,3 +826,5 @@ * Compute the Legendre symbol of one field element.
 export function FpLegendre<T>(Fp: TArg<IField<T>>, n: T): -1 | 0 | 1 {
+  validateField(Fp);
   const F = Fp as IField<T>;
+  aoddModulus(F.ORDER, 'FpLegendre');
   // We can use 3rd argument as optional cache of this value
@@ -749,3 +892,3 @@ // but seems unneeded for now. The operation is very fast.
   if (nBitLength !== undefined && nBitLength < bits)
-    throw new Error(`invalid n length: expected bit length (${bits}) >= n.length (${nBitLength})`);
+    throw new Error(`invalid n length: expected nBitLength (${nBitLength}) >= bitLen(n) (${bits})`);
   const _nBitLength = nBitLength !== undefined ? nBitLength : bits;
@@ -840,3 +983,3 @@ const nByteLength = Math.ceil(_nBitLength / 8);
   pow(num: bigint, power: bigint): bigint {
-    return FpPow(this, num, power);
+    return pow(num, power, this.ORDER);
   }
@@ -906,3 +1049,6 @@ div(lhs: bigint, rhs: bigint) {
   invertBatch(lst: bigint[]): bigint[] {
-    return FpInvertBatch(this, lst);
+    // `passZero` keeps the `bigint[]` contract honest: zero inputs map to `0` instead of leaking
+    // `undefined` into a `bigint[]`. Callers that must distinguish non-invertible inputs should use
+    // `FpInvertBatch` directly, whose default omits `passZero` and returns `(bigint | undefined)[]`.
+    return FpInvertBatch(this, lst, true);
   }
@@ -918,5 +1064,2 @@ // We can't move this out because Fp6, Fp12 implement it
 }
-// Freeze the shared method surface too; otherwise callers can still poison every Field instance by
-// monkey-patching `_Field.prototype` even if each instance is frozen.
-Object.freeze(_Field.prototype);
 
@@ -950,19 +1093,10 @@ /**
 export function Field(ORDER: bigint, opts: FieldOpts = {}): TRet<Readonly<FpField>> {
+  // Freeze the shared method surface before any instance is reachable; otherwise callers can
+  // poison every Field instance by monkey-patching `_Field.prototype` even if each instance is
+  // frozen. Freezing here instead of module scope keeps `_Field` tree-shakeable for importers
+  // that never construct a field; the call is idempotent and cheap.
+  Object.freeze(_Field.prototype);
   return new _Field(ORDER, opts);
 }
 
-// Generic random scalar, we can do same for other fields if via Fp2.mul(Fp2.ONE, Fp2.random)?
-// This allows unsafe methods like ignore bias or zero. These unsafe, but often used in different protocols (if deterministic RNG).
-// which mean we cannot force this via opts.
-// Not sure what to do with randomBytes, we can accept it inside opts if wanted.
-// Probably need to export getMinHashLength somewhere?
-// random(bytes?: Uint8Array, unsafeAllowZero = false, unsafeAllowBias = false) {
-//   const LEN = !unsafeAllowBias ? getMinHashLength(ORDER) : BYTES;
-//   if (bytes === undefined) bytes = randomBytes(LEN); // _opts.randomBytes?
-//   const num = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
-//   // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0
-//   const reduced = unsafeAllowZero ? mod(num, ORDER) : mod(num, ORDER - _1n) + _1n;
-//   return reduced;
-// },
-
 /**
@@ -984,2 +1118,3 @@ * @param Fp - Field implementation.
 export function FpSqrtOdd<T>(Fp: TArg<IField<T>>, elm: T): T {
+  validateField(Fp);
   const F = Fp as IField<T>;
@@ -1006,2 +1141,3 @@ if (!F.isOdd) throw new Error("Field doesn't have isOdd");
 export function FpSqrtEven<T>(Fp: TArg<IField<T>>, elm: T): T {
+  validateField(Fp);
   const F = Fp as IField<T>;
@@ -1094,5 +1230,9 @@ if (!F.isOdd) throw new Error("Field doesn't have isOdd");
   const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);
-  // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0
+  // Map into the non-zero scalar range [1, fieldOrder-1]: reduce mod (fieldOrder-1) to land in
+  // [0, fieldOrder-2], then add 1. This shifts the range off zero; it is NOT equal to
+  // `mod(num, fieldOrder)` (which spans [0, fieldOrder-1] and can be 0). A residual modulo bias
+  // remains but is negligible (~2^-(nBits/2), e.g. ~2^-128 for a 256-bit order) because `key` is
+  // required to be at least `getMinHashLength(fieldOrder)` (~1.5x field size) bytes of input.
   const reduced = mod(num, fieldOrder - _1n) + _1n;
   return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
 }

src/abstract/montgomery.ts

@@ -23,5 +23,5 @@ /**
 
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _2n = BigInt(2);
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+const _2n = /* @__PURE__ */ BigInt(2);
 
@@ -48,5 +48,16 @@ /** Curve-specific hooks required to build one X25519/X448 helper. */
    * Optional randomness source for `keygen()` and `utils.randomSecretKey()`.
-   * Receives the requested byte length and returns fresh random bytes.
+   * @param bytesLength - Requested byte length.
+   * @returns Random bytes.
    */
   randomBytes?: (bytesLength?: number) => TRet<Uint8Array>;
+  /**
+   * Optional fast fixed-base multiplication, replacing the Montgomery ladder in
+   * `scalarMultBase()` / `getPublicKey()` only. Standard implementation computes `[k]B` on the
+   * equivalent Edwards curve with cached base-point tables and maps the result back to a
+   * Montgomery `u` coordinate (libsodium does the same for X25519); ~3x faster than the ladder.
+   * @param k - Decoded, clamped scalar; guaranteed to be in the RFC 7748 clamped range.
+   * @returns `u([k]G)` as an integer. Must return `0` when `[k]G` is the point at infinity
+   *   (`k ≡ 0 mod n`) so the caller can reject it exactly like the ladder path does.
+   */
+  scalarMultBase?: (k: bigint) => bigint;
 };
@@ -103,2 +114,79 @@
 
+// cswap from RFC7748 "example code", adapted to BigInt.
+//
+// RFC: "dummy = mask(swap) AND (x_2 XOR x_3), where mask(swap) is the all-1 or all-0 word of the
+// same length as x_2 and x_3". On fixed-width machine words both cases cost the same. BigInt has
+// no fixed width, so a {0n, 1n} selector does not: V8 short-circuits `0n * v` - and, identically,
+// `0n & v`, `v + 0n`, `v - 0n` - to a no-op, while `1n * v` is a real multiply. The ladder calls
+// this with swap = k_t XOR k_(t+1), which would make total running time a linear function of how
+// often adjacent bits of the secret scalar differ: remotely measurable, and worth ~4 bits of a
+// long-term key.
+//
+// So select with a full-width mask instead, and interpolate rather than mask off a dummy.
+
+/**
+ * Selector for cswap(): `P` to keep, `P + 1` to swap, chosen by the low bit of `swap`.
+ * Higher bits are ignored, and `swap` is passed in whole rather than as a {0n, 1n} bit on
+ * purpose: `P + (swap & _1n)` would short-circuit the addition whenever the bit is clear, which
+ * is the very leak this construction avoids, one round-trip further down. Subtracting `swap`
+ * with its low bit cleared keeps every operand full-width instead.
+ * @param P - Field modulus.
+ * @param swap - Value whose low bit selects; ignored above that bit.
+ * @returns `P` when the low bit is clear, `P + 1` when it is set.
+ */
+function cmask(P: bigint, swap: bigint): bigint {
+  return P + swap - ((swap >> _1n) << _1n);
+}
+
+/**
+ * Swap two field elements when `mask` is `P + 1`, keep them when it is `P`:
+ *
+ *   d    = 6P + x_3 - x_2
+ *   x_2' = d * mask + x_2   (mod P)      x_3' = (x_2 + x_3) - x_2'
+ *
+ * The extra `6P * mask` vanishes modulo P, so `mask === P` leaves x_2 and `mask === P + 1`
+ * leaves x_3. Without the offset, the reduction dividend changes sign with input order and crosses
+ * BigInt limb boundaries; those classes measured differently on the tested Node/V8 build. For
+ * canonical inputs, the deliberately left-associative `offset + x_3 - x_2` is between 5P and 7P,
+ * keeping the dividend positive and in one word-count band for both RFC fields and masks. Six is
+ * the smallest coefficient `c` for which the shared offset `cP` has that property.
+ *
+ * This reduced the tested sign/size timing ratios, but JavaScript BigInt has no constant-time
+ * contract and the contents of the multiply and remainder still vary. Valid ladder states can
+ * contain genuine zero coordinates; this construction does not mask those value-shape effects.
+ * Computing `x_3'` independently as `((6P + x_2 - x_3) * mask + x_3) % P` is more symmetric.
+ * On the tested Node/V8 build, it reduced the timing difference between keeping `(0, v)` and
+ * swapping `(v, 0)`—both return `(0, v)`—from about 10%/13% for X25519/X448 to about 3%.
+ * Successful calls cannot reach that zero-in-the-first-output case. For the case they can reach,
+ * swapping `(0, v)` and keeping `(v, 0)` both return `(v, 0)`; the difference instead grew from
+ * about 0.7%/1.1% to 2.7%/2.8%. The extra multiply/remainder also made public
+ * `getSharedSecret()` about 16% slower. The retained one-remainder form measured about 2.5%
+ * slower than the prior helper for public X25519 `getSharedSecret()` in the same environment.
+ * x_3' falls out of the sum, which a swap leaves invariant: no second multiply or reduction is
+ * needed. Bind `6P` once per field so production and the timing regression exercise the same
+ * configured helper without paying for the multiplication in every ladder round.
+ *
+ * The returned function is called twice per ladder round, so it validates nothing. Both elements
+ * MUST already be reduced mod P; unreduced input silently corrupts the kept-side output.
+ * @param P - Field modulus.
+ * @returns A field-bound swap function taking mask, x_2, and x_3.
+ */
+function cswap(
+  P: bigint
+): (mask: bigint, x_2: bigint, x_3: bigint) => { x_2: bigint; x_3: bigint } {
+  const offset = BigInt(6) * P;
+  return (mask: bigint, x_2: bigint, x_3: bigint): { x_2: bigint; x_3: bigint } => {
+    const sum = x_2 + x_3;
+    const d = offset + x_3 - x_2;
+    const a = (d * mask + x_2) % P;
+    return { x_2: a, x_3: sum - a };
+  };
+}
+
+/** Internal helpers, exported for tests only. Not part of the public API. */
+export const __TEST: { cmask: typeof cmask; cswap: typeof cswap } = /* @__PURE__ */ Object.freeze({
+  cmask,
+  cswap,
+});
+
 function validateOpts(curve: TArg<MontgomeryOpts>) {
@@ -118,2 +206,3 @@ // Validate constructor config eagerly, but do not call user-provided hooks here:
       randomBytes: 'function',
+      scalarMultBase: 'function',
     }
@@ -129,8 +218,33 @@ );
  * @example
- * Perform one X25519 key exchange through the generic Montgomery helper.
+ * Build an X25519 helper from curve parameters, then derive one public key.
  *
  * ```ts
- * import { x25519 } from '@noble/curves/ed25519.js';
- * const alice = x25519.keygen();
- * const shared = x25519.getSharedSecret(alice.secretKey, alice.publicKey);
+ * import { montgomery } from '@noble/curves/abstract/montgomery.js';
+ * const P = 2n ** 255n - 19n;
+ * const mod = (num: bigint) => {
+ *   const out = num % P;
+ *   return out >= 0n ? out : out + P;
+ * };
+ * const pow = (num: bigint, power: bigint) => {
+ *   let res = 1n;
+ *   for (; power > 0n; power >>= 1n) {
+ *     if (power & 1n) res = mod(res * num);
+ *     num = mod(num * num);
+ *   }
+ *   return res;
+ * };
+ * const x25519 = montgomery({
+ *   P,
+ *   type: 'x25519',
+ *   adjustScalarBytes(bytes: Uint8Array) {
+ *     bytes[0] &= 248;
+ *     bytes[31] &= 127;
+ *     bytes[31] |= 64;
+ *     return bytes;
+ *   },
+ *   powPminus2(x) {
+ *     return pow(x, P - 2n);
+ *   },
+ * });
+ * const publicKey = x25519.getPublicKey(new Uint8Array(32).fill(1));
  * ```
@@ -141,2 +255,3 @@ */
   const { P, type, adjustScalarBytes, powPminus2, randomBytes: rand } = CURVE;
+  const mulBaseHook = CURVE.scalarMultBase;
   const is25519 = type === 'x25519';
@@ -147,2 +262,3 @@ if (!is25519 && type !== 'x448') throw new Error('invalid type');
   const montgomeryBits = is25519 ? 255 : 448;
+  const swap = cswap(P);
   const fieldLen = is25519 ? 32 : 56;
@@ -160,4 +276,4 @@ const Gu = is25519 ? BigInt(9) : BigInt(5);
   const maxAdded = is25519
-    ? BigInt(8) * _2n ** BigInt(251) - _1n
-    : BigInt(4) * _2n ** BigInt(445) - _1n;
+    ? BigInt(8) * (_2n ** BigInt(251) - _1n)
+    : BigInt(4) * (_2n ** BigInt(445) - _1n);
   const maxScalar = minScalar + maxAdded + _1n; // (inclusive)
@@ -183,7 +299,40 @@ const modP = (n: bigint) => mod(n, P);
   }
+  /**
+   * u coordinates whose order divides the cofactor, on the curve and on its quadratic twist -
+   * the ladder sends every one of them to zero. Same blocklist libsodium and post-CVE-2017-0379
+   * Libgcrypt carry. decodeU() reduces mod P first, so the non-canonical encodings P and P + 1
+   * collapse onto 0 and 1, and `type` admits no curve beyond these two, so both lists are total.
+   *
+   * Complete by construction: x-only doubling sends u to (u^2 - 1)^2 / 4u(u^2 + a*u + 1). Order 4
+   * therefore needs (u^2 - 1)^2 === 0, i.e. u = +-1; order 2 needs u(u^2 + a*u + 1) === 0, and
+   * a^2 - 4 is a non-residue on both curves, leaving u = 0. curve448 stops there (cofactor 4);
+   * curve25519 (cofactor 8) adds the two order-8 roots below. Cross-checked by clearing the
+   * cofactor with those same doublings over 200k random u: no sixth value exists.
+   */
+  const lowOrderU = new Set(
+    is25519
+      ? [
+          _0n,
+          _1n,
+          P - _1n,
+          BigInt('325606250916557431795983626356110631294008115727848805560023387167927233504'),
+          BigInt('39382357235489614581723060781553021112529911719440698176882885853963445705823'),
+        ]
+      : [_0n, _1n, P - _1n]
+  );
   function scalarMult(scalar: TArg<Uint8Array>, u: TArg<Uint8Array>): TRet<Uint8Array> {
-    const pu = montgomeryLadder(decodeU(u), decodeScalar(scalar));
     // Some public keys are useless, of low-order. Curve author doesn't think
     // it needs to be validated, but we do it nonetheless.
     // https://cr.yp.to/ecdh.html#validate
+    //
+    // Reject them BEFORE the ladder. RFC 7748 #6.1 also permits detecting them from the
+    // all-zero output, but that first runs all 255 rounds against the long-term secret,
+    // handing an unauthenticated attacker a free timing oracle. Low-order inputs also drive
+    // the ladder into a degenerate state (x_2 + z_2 === 0) whose extra zero-operand
+    // multiplications amplify any residual key-dependent timing.
+    const pointU = decodeU(u);
+    if (lowOrderU.has(pointU)) throw new Error('invalid private or public key received');
+    const pu = montgomeryLadder(pointU, decodeScalar(scalar));
+    // Unreachable for RFC 7748 clamped scalars, which are cofactor multiples smaller than the
+    // group order; kept because adjustScalarBytes is caller-supplied.
     if (pu === _0n) throw new Error('invalid private or public key received');
@@ -193,4 +342,11 @@ return encodeU(pu);
   // Computes public key from private. By doing scalar multiplication of base point.
+  // With a curve-provided fixed-base hook (Edwards tables), the ladder is skipped, but the
+  // contract — scalar validation, low-order rejection, encoding — stays identical.
   function scalarMultBase(scalar: TArg<Uint8Array>): TRet<Uint8Array> {
-    return scalarMult(scalar, GuBytes);
+    if (mulBaseHook === undefined) return scalarMult(scalar, GuBytes);
+    const k = decodeScalar(scalar);
+    aInRange('scalar', k, minScalar, maxScalar);
+    const pu = modP(mulBaseHook(k));
+    if (pu === _0n) throw new Error('invalid private or public key received');
+    return encodeU(pu);
   }
@@ -200,13 +356,2 @@ const getPublicKey = scalarMultBase;
 
-  // cswap from RFC7748 "example code"
-  function cswap(swap: bigint, x_2: bigint, x_3: bigint): { x_2: bigint; x_3: bigint } {
-    // dummy = mask(swap) AND (x_2 XOR x_3)
-    // Where mask(swap) is the all-1 or all-0 word of the same length as x_2
-    // and x_3, computed, e.g., as mask(swap) = 0 - swap.
-    const dummy = modP(swap * (x_2 - x_3));
-    x_2 = modP(x_2 - dummy); // x_2 = x_2 XOR dummy
-    x_3 = modP(x_3 + dummy); // x_3 = x_3 XOR dummy
-    return { x_2, x_3 };
-  }
-
   /**
@@ -227,9 +372,11 @@ * Montgomery x-only multiplication ladder for the selected X25519/X448 curve.
     let z_3 = _1n;
-    let swap = _0n;
+    // The RFC tracks `swap` across rounds to hold k_t XOR k_(t+1); the low bit of `kx >> t` is
+    // the same value, without the carried state. aInRange above pins bit (montgomeryBits - 1)
+    // of k set and everything above it clear, so `kx >> t` is never zero and its width is a
+    // function of t alone - never of a secret bit.
+    const kx = k ^ (k >> _1n);
     for (let t = BigInt(montgomeryBits - 1); t >= _0n; t--) {
-      const k_t = (k >> t) & _1n;
-      swap ^= k_t;
-      ({ x_2, x_3 } = cswap(swap, x_2, x_3));
-      ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
-      swap = k_t;
+      const mask = cmask(P, kx >> t);
+      ({ x_2, x_3 } = swap(mask, x_2, x_3));
+      ({ x_2: z_2, x_3: z_3 } = swap(mask, z_2, z_3));
 
@@ -252,4 +399,6 @@ const A = x_2 + z_2;
     }
-    ({ x_2, x_3 } = cswap(swap, x_2, x_3));
-    ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
+    // trailing cswap: the RFC's `swap` holds k_0 here, which is the low bit of k
+    const mask = cmask(P, k);
+    ({ x_2, x_3 } = swap(mask, x_2, x_3));
+    ({ x_2: z_2, x_3: z_3 } = swap(mask, z_2, z_3));
     const z2 = powPminus2(z_2); // `Fp.pow(x, P - _2n)` is much slower equivalent
@@ -256,0 +405,0 @@ return modP(x_2 * z2); // Return x_2 * (z_2^(p - 2))

src/abstract/oprf.ts

@@ -60,2 +60,3 @@ /**
   concatBytes,
+  copyBytes,
   numberToBytesBE,
@@ -67,3 +68,3 @@ randomBytes,
 } from '../utils.ts';
-import { pippenger, validatePointCons, type CurvePoint, type CurvePointCons } from './curve.ts';
+import { mulAddUnsafe, validatePointCons, type CurvePoint, type CurvePointCons } from './curve.ts';
 import { _DST_scalar, type H2CDSTOpts } from './hash-to-curve.ts';
@@ -363,3 +364,3 @@ import { getMinHashLength, mapHashToField } from './modular.ts';
       blinded: TArg<PointBytes[]>,
-      rng: RNG
+      rng?: RNG
     ): TRet<OPRFBlindEvalBatch>;
@@ -457,2 +458,4 @@
   const randomScalar = (rng: RNG = randomBytes) => {
+    if (typeof rng !== 'function')
+      throw new TypeError('"rng" expected function, got type=' + typeof rng);
     // RFC 9497 §2.1 defines RandomScalar as nonzero; blind inversion and generated public keys
@@ -466,3 +469,6 @@ // both rely on keeping this helper in the `1..n-1` range.
 
-  const msm = (points: P[], scalars: bigint[]) => pippenger(Point, points, scalars);
+  // Every MSM input in this module is public (hash-derived transcript weights, wire-decoded
+  // points, proof scalars), so the vartime shared-doubling-chain walk is safe. It is also
+  // 1.6-2.5x faster than pippenger() for all realistic batch sizes (measured up to L=2048).
+  const msm = (points: P[], scalars: bigint[]) => mulAddUnsafe(Point, points, scalars);
 
@@ -557,4 +563,4 @@ const getCtx = (mode: number) =>
     );
-    const t2 = Point.BASE.multiply(s).add(B.multiply(c)); // s*G + c*B
-    const t3 = M.multiply(s).add(Z.multiply(c)); // s*M + c*Z
+    const t2 = msm([Point.BASE, B], [s, c]); // s*G + c*B
+    const t3 = msm([M, Z], [s, c]); // s*M + c*Z
     const expectedC = challengeTranscript(B, M, Z, t2, t3, ctx);
@@ -682,3 +688,10 @@ if (!Fn.eql(c, expectedC)) throw new Error('proof verification failed');
       verifyProof(ctxVOPRF, pkS, blindedPoints, evalPoints, proof);
-      return items.map((i) => oprf.finalize(i.input, i.blind, i.evaluated)) as TRet<Bytes[]>;
+      // Same unblind+hash as oprf.finalize(), but reuses the evaluated points already decoded
+      // (and identity-checked) for verifyProof instead of deserializing each one again.
+      return items.map((i, j) => {
+        const input = inputBytes('input', i.input);
+        const blind = Fn.fromBytes(i.blind);
+        const unblinded = evalPoints[j].multiply(Fn.inv(blind)).toBytes();
+        return hashInput(input, unblinded);
+      }) as TRet<Bytes[]>;
     },
@@ -700,3 +713,3 @@ finalize(
   const poprf = (info: TArg<Bytes>) => {
-    info = inputBytes('info', info);
+    info = copyBytes(inputBytes('info', info));
     const m = hashToScalarPrefixed(encode('Info', info), ctxPOPRF);
@@ -703,0 +716,0 @@ const T = Point.BASE.multiply(m);

src/abstract/poseidon.ts

@@ -10,4 +10,4 @@ /**
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { asafenumber, bitGet, validateObject, type TArg, type TRet } from '../utils.ts';
-import { FpInvertBatch, FpPow, type IField, validateField } from './modular.ts';
+import { aarray, asafenumber, bitGet, validateObject, type TArg, type TRet } from '../utils.ts';
+import { FpInvertBatch, FpPow, validateField, type IField } from './modular.ts';
 
@@ -54,2 +54,3 @@ // Grain LFSR (Linear-Feedback Shift Register): https://eprint.iacr.org/2009/109.pdf
 function assertValidPosOpts(opts: TArg<PoseidonBasicOpts>) {
+  validateObject(opts as any, {}, {}, 'opts');
   const { Fp, roundsFull } = opts;
@@ -147,2 +148,3 @@ validateField(Fp);
 ): PoseidonConstants {
+  assertValidPosOpts(opts);
   const { Fp, t, roundsFull, roundsPartial } = opts;
@@ -171,3 +173,5 @@ // `skipMDS` counts how many candidate matrices to discard before taking one.
     }
-    mds.push(FpInvertBatch(Fp, row));
+    // `row` is guaranteed non-zero (the loop throws on a zero entry above), so `passZero` only
+    // pins the `bigint[]` return type; it does not change any value here.
+    mds.push(FpInvertBatch(Fp, row, true));
   }
@@ -223,8 +227,13 @@
   // MDS is TxT matrix
-  if (!Array.isArray(mds) || mds.length !== t) throw new Error('Poseidon: invalid MDS matrix');
-  const _mds = mds.map((mdsRow) => {
-    if (!Array.isArray(mdsRow) || mdsRow.length !== t)
-      throw new Error('invalid MDS matrix row: ' + mdsRow);
-    return mdsRow.map((i) => {
-      if (typeof i !== 'bigint') throw new Error('invalid MDS matrix bigint: ' + i);
+  aarray(mds, 'opts.mds');
+  if (mds.length !== t) throw new Error('Poseidon: invalid MDS matrix');
+  const _mds = mds.map((mdsRow, row) => {
+    aarray(mdsRow, 'opts.mds[' + row + ']');
+    if (mdsRow.length !== t)
+      throw new Error('"opts.mds[' + row + ']" expected length ' + t + ', got ' + mdsRow.length);
+    return mdsRow.map((i, col) => {
+      if (typeof i !== 'bigint')
+        throw new Error(
+          '"opts.mds[' + row + '][' + col + ']" expected bigint, got type=' + typeof i
+        );
       // Hardcoded Poseidon MDS matrices often use signed entries like `-1`;
@@ -347,8 +356,13 @@ // accept bigint representatives here and reduce them into the field.
   const poseidonRound = (values: bigint[], isFull: boolean, idx: number) => {
-    values = values.map((i, j) => Fp.add(i, roundConstants[idx][j]));
-
-    if (isFull) values = values.map((i) => sboxFn(i));
-    else values[partialIdx] = sboxFn(values[partialIdx]);
-    // Matrix multiplication
-    values = mds.map((i) => i.reduce((acc, i, j) => Fp.add(acc, Fp.mulN(i, values[j])), Fp.ZERO));
+    const rc = roundConstants[idx];
+    if (isFull) values = values.map((i, j) => sboxFn(Fp.add(i, rc[j])));
+    else {
+      values = values.map((i, j) => Fp.add(i, rc[j]));
+      values[partialIdx] = sboxFn(values[partialIdx]);
+    }
+    // Matrix multiplication. Row entries and values are reduced (< p), so each product is < p²
+    // and a row sum is < t⋅p²: accumulate without mod, reduce once per row instead of per cell.
+    values = mds.map((row) =>
+      Fp.create(row.reduce((acc, m, j) => Fp.addN(acc, Fp.mulN(m, values[j])), Fp.ZERO))
+    );
     return values;
@@ -414,2 +428,8 @@ };
   constructor(Fp: IField<bigint>, rate: number, capacity: number, hash: PoseidonFn) {
+    validateField(Fp);
+    asafenumber(rate, 'rate');
+    asafenumber(capacity, 'capacity');
+    if (typeof hash !== 'function')
+      throw new TypeError('"hash" expected function, got type=' + typeof hash);
+    if (hash.roundConstants !== undefined) aarray(hash.roundConstants, 'hash.roundConstants');
     const width = spongeShape(rate, capacity);
@@ -419,6 +439,7 @@ // The direct constructor accepts an arbitrary permutation hook, but callers still
     // mismatches here instead of deferring them until the first `process()` call.
-    if (width !== hash.roundConstants[0]?.length)
+    if (width !== hash.roundConstants?.[0]?.length) {
       throw new Error(
-        `invalid sponge width: expected ${hash.roundConstants[0]?.length}, got ${width}`
+        `invalid sponge width: expected ${hash.roundConstants?.[0]?.length}, got ${width}`
       );
+    }
     this.Fp = Fp;
@@ -437,2 +458,3 @@ this.hash = hash;
   absorb(input: bigint[]): void {
+    if (!Array.isArray(input)) throw new Error('invalid input: expected array');
     for (const i of input)
@@ -535,2 +557,3 @@ if (typeof i !== 'bigint' || !this.Fp.isValid(i)) throw new Error('invalid input: ' + i);
 export function poseidonSponge(opts: TArg<PoseidonSpongeOpts>): TRet<() => PoseidonSponge> {
+  validateObject(opts as any, {}, {}, 'opts');
   const { rate, capacity } = opts;
@@ -537,0 +560,0 @@ const t = spongeShape(rate, capacity);

src/abstract/tower.ts

@@ -25,2 +25,3 @@ /**
 } from '../utils.ts';
+import { validatePointCons } from './curve.ts';
 import * as mod from './modular.ts';
@@ -124,6 +125,2 @@ import type { WeierstrassPoint, WeierstrassPointCons } from './weierstrass.ts';
   fromBigTwelve: (t: BigintTwelve) => Fp12;
-  /** Multiply by a sparse `(o0, o1, 0, 0, o4, 0)` element. */
-  mul014(num: Fp12, o0: Fp2, o1: Fp2, o4: Fp2): Fp12;
-  /** Multiply by a sparse `(o0, 0, 0, o3, o4, 0)` element. */
-  mul034(num: Fp12, o0: Fp2, o3: Fp2, o4: Fp2): Fp12;
   /** Multiply by one quadratic-extension element. */
@@ -150,9 +147,18 @@ mulByFp2(lhs: Fp12, rhs: Fp2): Fp12;
   asafenumber(num, 'num');
+  asafenumber(degree, 'degree');
+  const divisorN = divisor === undefined ? degree : divisor;
+  asafenumber(divisorN, 'divisor');
   const F = Fp as mod.IField<T>;
-  // Generic callers can hit empty / fractional row counts through `__TEST`; fail closed instead of
-  // silently returning `[]` or deriving extra Frobenius rows from a truncated loop bound.
+  // Generic callers reach this through `__TEST`; validate before bigint operators can throw raw
+  // native RangeError/TypeError diagnostics for malformed tower parameters.
+  if (typeof modulus !== 'bigint' || modulus <= _1n)
+    throw new Error('calcFrobeniusCoefficients: expected valid modulus, got ' + modulus);
+  if (degree <= 0)
+    throw new Error('calcFrobeniusCoefficients: expected positive degree, got ' + degree);
   if (num <= 0)
     throw new Error('calcFrobeniusCoefficients: expected positive row count, got ' + num);
-  const _divisor = BigInt(divisor === undefined ? degree : divisor);
-  const towerModulus: any = modulus ** BigInt(degree);
+  if (divisorN <= 0)
+    throw new Error('calcFrobeniusCoefficients: expected positive divisor, got ' + divisorN);
+  const _divisor = BigInt(divisorN);
+  const towerModulus = modulus ** BigInt(degree);
   const res: T[][] = [];
@@ -217,2 +223,21 @@ // Derive tower-basis multipliers for the `p^k` Frobenius action. The
 } {
+  mod.validateField(Fp);
+  mod.validateField(Fp2);
+  validateObject(
+    Fp2 as unknown as Record<string, any>,
+    {
+      Fp: 'object',
+      frobeniusMap: 'function',
+      fromBigTuple: 'function',
+      mulByB: 'function',
+      mulByNonresidue: 'function',
+      reim: 'function',
+      Fp4Square: 'function',
+      NONRESIDUE: 'object',
+    },
+    {}
+  );
+  if (!isObj(base) || Array.isArray(base))
+    throw new TypeError('"base" expected Fp2 element, got type=' + typeof base);
+  if (!Fp2.isValid(base as Fp2)) throw new RangeError('"base" expected valid Fp2 element');
   // GLV endomorphism Ψ(P)
@@ -240,2 +265,7 @@ const PSI_X = Fp2.pow(base, (Fp.ORDER - _1n) / _3n); // u^((p-1)/3)
     (c: WeierstrassPointCons<T>, P: WeierstrassPoint<T>) => {
+      if (typeof (c as unknown) !== 'function')
+        throw new TypeError('"c" expected point constructor, got type=' + typeof c);
+      validatePointCons(c);
+      if (!(P instanceof c))
+        throw new TypeError('"P" expected Point instance, got type=' + typeof P);
       const affine = P.toAffine();
@@ -262,3 +292,4 @@ const p = fn(affine.x, affine.y);
    * Optional custom quadratic square-root helper.
-   * Receives one quadratic-extension element and returns one square root.
+   * @param num - Quadratic-extension element.
+   * @returns One square root.
    */
@@ -294,3 +325,2 @@ Fp2sqrt?: (num: Fp2) => Fp2;
   readonly Fp_div2: bigint;
-  readonly FROBENIUS_COEFFICIENTS: readonly Fp[];
 
@@ -322,6 +352,5 @@ constructor(
     this.NONRESIDUE = this.create({ c0: FP2_NONRESIDUE![0], c1: FP2_NONRESIDUE![1] });
-    // const Fp2Nonresidue = this.create({ c0: FP2_NONRESIDUE![0], c1: FP2_NONRESIDUE![1] });
-    this.FROBENIUS_COEFFICIENTS = Object.freeze(
-      calcFrobeniusCoefficients(Fp, this.Fp_NONRESIDUE, Fp.ORDER, 2)[0]
-    );
+    // NOTE: no Fp2 FROBENIUS_COEFFICIENTS table: for the shipped `u² = -1` tower the coefficients
+    // are always [1, -1] (x²+1 irreducible forces p ≡ 3 mod 4), so frobeniusMap conjugates
+    // directly and the eager table computation was pure import-time waste.
     this.mulByB = (num) => {
@@ -380,3 +409,3 @@ // This config hook is trusted to return a canonical Fp2 value already.
   invertBatch(nums: Fp2[]): Fp2[] {
-    return mod.FpInvertBatch(this, nums);
+    return mod.FpInvertBatch(this, nums, true);
   }
@@ -524,9 +553,18 @@ // Normalized
   mulByNonresidue({ c0, c1 }: Fp2) {
-    return this.mul({ c0, c1 }, this.NONRESIDUE);
+    const { Fp, NONRESIDUE: nr } = this;
+    if (nr.c0 === Fp.ONE && nr.c1 === Fp.ONE) {
+      return Object.freeze({ c0: Fp.sub(c0, c1), c1: Fp.add(c0, c1) });
+    }
+    if (nr.c1 === Fp.ONE) {
+      return Object.freeze({
+        c0: Fp.sub(Fp.mul(c0, nr.c0), c1),
+        c1: Fp.add(c0, Fp.mul(c1, nr.c0)),
+      });
+    }
+    return this.mul({ c0, c1 }, nr);
   }
-  frobeniusMap({ c0, c1 }: Fp2, power: number): Fp2 {
-    return Object.freeze({
-      c0,
-      c1: this.Fp.mul(c1, this.FROBENIUS_COEFFICIENTS[power % 2]),
-    });
+  frobeniusMap(num: Fp2, power: number): Fp2 {
+    const { c0, c1 } = num;
+    const { Fp } = this;
+    return Object.freeze({ c0, c1: power % 2 === 0 ? c1 : Fp.neg(c1) });
   }
@@ -693,3 +731,3 @@ }
   invertBatch(nums: Fp6[]): Fp6[] {
-    return mod.FpInvertBatch(this, nums);
+    return mod.FpInvertBatch(this, nums, true);
   }
@@ -744,3 +782,5 @@
   }
-  frobeniusMap({ c0, c1, c2 }: Fp6, power: number) {
+  frobeniusMap(num: Fp6, power: number) {
+    const { c0, c1, c2 } = num;
+    if (power % 6 === 0) return Object.freeze({ c0, c1, c2 });
     const { Fp2 } = this;
@@ -900,3 +940,3 @@ return Object.freeze({
   invertBatch(nums: Fp12[]): Fp12[] {
-    return mod.FpInvertBatch(this, nums);
+    return mod.FpInvertBatch(this, nums, true);
   }
@@ -999,6 +1039,9 @@
   frobeniusMap(lhs: Fp12, power: number) {
+    const p = power % 12;
+    if (p === 0) return Object.freeze({ c0: lhs.c0, c1: lhs.c1 });
+    if (p === 6) return this.conjugate(lhs);
     const { Fp6 } = this;
     const { Fp2 } = Fp6;
     const { c0, c1, c2 } = Fp6.frobeniusMap(lhs.c1, power);
-    const coeff = this.FROBENIUS_COEFFICIENTS[power % 12];
+    const coeff = this.FROBENIUS_COEFFICIENTS[p];
     return Object.freeze({
@@ -1024,30 +1067,2 @@ c0: Fp6.frobeniusMap(lhs.c0, power),
   }
-  // Sparse multiplication
-  mul014({ c0, c1 }: Fp12, o0: Fp2, o1: Fp2, o4: Fp2) {
-    const { Fp6 } = this;
-    const { Fp2 } = Fp6;
-    let t0 = Fp6.mul01(c0, o0, o1);
-    let t1 = Fp6.mul1(c1, o4);
-    return Object.freeze({
-      c0: Fp6.add(Fp6.mulByNonresidue(t1), t0), // T1 * v + T0
-      // (c1 + c0) * [o0, o1+o4] - T0 - T1
-      c1: Fp6.sub(Fp6.sub(Fp6.mul01(Fp6.add(c1, c0), o0, Fp2.add(o1, o4)), t0), t1),
-    });
-  }
-  mul034({ c0, c1 }: Fp12, o0: Fp2, o3: Fp2, o4: Fp2) {
-    const { Fp6 } = this;
-    const { Fp2 } = Fp6;
-    const a = Object.freeze({
-      c0: Fp2.mul(c0.c0, o0),
-      c1: Fp2.mul(c0.c1, o0),
-      c2: Fp2.mul(c0.c2, o0),
-    });
-    const b = Fp6.mul01(c1, o3, o4);
-    const e = Fp6.mul01(Fp6.add(c0, c1), Fp2.add(o0, o3), o4);
-    return Object.freeze({
-      c0: Fp6.add(Fp6.mulByNonresidue(b), a),
-      c1: Fp6.sub(e, Fp6.add(a, b)),
-    });
-  }
-
   // A cyclotomic group is a subgroup of Fp^n defined by
@@ -1085,4 +1100,5 @@ //   GΦₙ(p) = {α ∈ Fpⁿ : α^Φₙ(p) = 1}
     aInRange('cyclotomic exponent', n, _0n, _1n << BigInt(this.X_LEN));
-    let z = this.ONE;
-    for (let i = this.X_LEN - 1; i >= 0; i--) {
+    if (n === _0n) return this.ONE;
+    let z = num;
+    for (let i = bitLen(n) - 2; i >= 0; i--) {
       z = this._cyclotomicSquare(z);
@@ -1105,2 +1121,3 @@ if (bitGet(n, i)) z = this.mul(z, num);
  * ```ts
+ * import { tower12, type Fp2, type Fp12 } from '@noble/curves/abstract/tower.js';
  * const fields = tower12({
@@ -1110,4 +1127,4 @@ *   ORDER: 17n,
  *   FP2_NONRESIDUE: [1n, 1n],
- *   Fp2mulByB: (num) => num,
- *   Fp12finalExponentiate: (num) => num,
+ *   Fp2mulByB: (num: Fp2) => num,
+ *   Fp12finalExponentiate: (num: Fp12) => num,
  * });
@@ -1114,0 +1131,0 @@ * const fp12 = fields.Fp12.ONE;

src/bls12-381.ts

@@ -86,5 +86,3 @@ /**
   bitLen,
-  bitMask,
   bytesToHex,
-  bytesToNumberBE,
   concatBytes,
@@ -99,7 +97,6 @@ copyBytes,
 // Types
-import { isogenyMap } from './abstract/hash-to-curve.ts';
+import { isogenyMap, mapToCurveSimpleSWU } from './abstract/hash-to-curve.ts';
 import type { BigintTuple, Fp, Fp12, Fp2, Fp6 } from './abstract/tower.ts';
 import { psiFrobenius, tower12 } from './abstract/tower.ts';
 import {
-  mapToCurveSimpleSWU,
   weierstrass,
@@ -164,2 +161,87 @@ type AffinePoint,
 }) as TRet<IField<bigint>>;
+
+type Fp12Compressed = { g2: Fp2; g3: Fp2; g4: Fp2; g5: Fp2 };
+
+// Karabina's G2345 compression for the cyclotomic subgroup. Noble stores Fp12 as
+// (c0 + c1*w), so (g0, g1, g2, g3, g4, g5) map to (c0.c0, c1.c1, c1.c0, c0.c2, c0.c1, c1.c2).
+function bls12FromCompressed(g0: Fp2, g1: Fp2, { g2, g3, g4, g5 }: Fp12Compressed): Fp12 {
+  return { c0: { c0: g0, c1: g4, c2: g3 }, c1: { c0: g2, c1: g1, c2: g5 } };
+}
+
+function bls12Compress({ c0, c1 }: Fp12): Fp12Compressed {
+  return { g2: c1.c0, g3: c0.c2, g4: c0.c1, g5: c1.c2 };
+}
+
+function bls12CyclotomicSquareCompressed({ g2, g3, g4, g5 }: Fp12Compressed): Fp12Compressed {
+  const { first: h23c0, second: h23c1 } = Fp2.Fp4Square(g4, g5);
+  const { first: h45c0, second: h45c1 } = Fp2.Fp4Square(g2, g3);
+  const d2 = Fp2.add(g2, g2);
+  const d3 = Fp2.add(g3, g3);
+  const d4 = Fp2.add(g4, g4);
+  const d5 = Fp2.add(g5, g5);
+  return {
+    g2: Fp2.add(Fp2.mul(Fp2.mulByNonresidue(h23c1), _3n), d2),
+    g3: Fp2.sub(Fp2.mul(h23c0, _3n), d3),
+    g4: Fp2.sub(Fp2.mul(h45c0, _3n), d4),
+    g5: Fp2.add(Fp2.mul(h45c1, _3n), d5),
+  };
+}
+
+function bls12RecoverG1Ratio({ g2, g3, g4, g5 }: Fp12Compressed): { num: Fp2; den: Fp2 } {
+  if (Fp2.is0(g2)) return { num: Fp2.mul(Fp2.mul(g4, g5), _2n), den: g3 };
+  return {
+    num: Fp2.add(
+      Fp2.sub(Fp2.mul(Fp2.sqr(g4), _3n), Fp2.mul(g3, _2n)),
+      Fp2.mulByNonresidue(Fp2.sqr(g5))
+    ),
+    den: Fp2.mul(g2, _4n),
+  };
+}
+
+function bls12RecoverG0(g1: Fp2, { g2, g3, g4, g5 }: Fp12Compressed): Fp2 {
+  const g3g4 = Fp2.mul(g3, g4);
+  const t = Fp2.add(Fp2.sub(Fp2.mul(Fp2.sub(Fp2.sqr(g1), g3g4), _2n), g3g4), Fp2.mul(g2, g5));
+  return Fp2.add(Fp2.mulByNonresidue(t), Fp2.ONE);
+}
+
+function bls12CyclotomicExpCompressed(
+  num: Fp12,
+  squarings: readonly [number, number, number]
+): { result: Fp12; last: Fp12 } {
+  const gs: Fp12Compressed[] = [];
+  let g = bls12Compress(num);
+  for (const count of squarings) {
+    for (let i = 0; i < count; i++) g = bls12CyclotomicSquareCompressed(g);
+    gs.push(g);
+  }
+  // Karabina decompression is undefined at g2 = g3 = 0. Every element decompressed here lies in
+  // the cyclotomic subgroup GΦ₁₂, where the only such element is the identity: unitarity
+  // (z⋅z^(p⁶) = 1) forces g4² = ξ⋅g5², so g4 = g5 = 0 because ξ is a non-square in Fp2, leaving
+  // z ∈ Fp4* ∩ GΦ₁₂ — trivial since gcd(p⁴−p²+1, p⁴−1) = gcd(3, p²−2) = 1 for p ≡ 1 mod 3.
+  // Handle the identity explicitly instead of relying on invertBatch's passZero mapping the zero
+  // denominator to 0 (which happens to reconstruct ONE, but only by coincidence of formulas).
+  const isOne = gs.map(({ g2, g3 }) => Fp2.is0(g2) && Fp2.is0(g3));
+  const ratios = gs.map(bls12RecoverG1Ratio);
+  const invDens = Fp2.invertBatch(ratios.map(({ den }) => den));
+  const elems = gs.map((compressed, i) => {
+    if (isOne[i]) return Fp12.ONE;
+    const g1 = Fp2.mul(ratios[i].num, invDens[i]);
+    return bls12FromCompressed(bls12RecoverG0(g1, compressed), g1, compressed);
+  });
+  return { result: Fp12.mul(Fp12.mul(elems[0], elems[1]), elems[2]), last: elems[2] };
+}
+
+function bls12CyclotomicExpX(num: Fp12): Fp12 {
+  // BLS_X = 2^63 + 2^62 + 2^60 + 2^57 + 2^48 + 2^16.
+  const { result, last } = bls12CyclotomicExpCompressed(num, [16, 32, 9]);
+  let r = result;
+  let s = last;
+  for (let i = 0; i < 3; i++) s = Fp12._cyclotomicSquare(s);
+  r = Fp12.mul(r, s);
+  for (let i = 0; i < 2; i++) s = Fp12._cyclotomicSquare(s);
+  r = Fp12.mul(r, s);
+  s = Fp12._cyclotomicSquare(s);
+  return Fp12.mul(r, s);
+}
+
 const { Fp, Fp2, Fp6, Fp12 } = tower12({
@@ -174,4 +256,4 @@ ORDER: bls12_381_CURVE_G1.p,
   Fp2mulByB: ({ c0, c1 }: Fp2) => {
-    const t0 = Fp.mul(c0, _4n); // 4 * c0
-    const t1 = Fp.mul(c1, _4n); // 4 * c1
+    const t0 = Fp.mul(c0, _4n);
+    const t1 = Fp.mul(c1, _4n);
     // (T0-T1) + (T0+T1)*i
@@ -181,3 +263,3 @@ return { c0: Fp.sub(t0, t1), c1: Fp.add(t0, t1) };
   Fp12finalExponentiate: (num: Fp12) => {
-    const x = BLS_X;
+    const powMinusX = (num: Fp12) => Fp12.conjugate(bls12CyclotomicExpX(num));
     // this^(q⁶) / this
@@ -187,8 +269,8 @@ const t0 = Fp12.div(Fp12.frobeniusMap(num, 6), num);
     const t1 = Fp12.mul(Fp12.frobeniusMap(t0, 2), t0);
-    const t2 = Fp12.conjugate(Fp12._cyclotomicExp(t1, x));
+    const t2 = powMinusX(t1);
     const t3 = Fp12.mul(Fp12.conjugate(Fp12._cyclotomicSquare(t1)), t2);
-    const t4 = Fp12.conjugate(Fp12._cyclotomicExp(t3, x));
-    const t5 = Fp12.conjugate(Fp12._cyclotomicExp(t4, x));
-    const t6 = Fp12.mul(Fp12.conjugate(Fp12._cyclotomicExp(t5, x)), Fp12._cyclotomicSquare(t2));
-    const t7 = Fp12.conjugate(Fp12._cyclotomicExp(t6, x));
+    const t4 = powMinusX(t3);
+    const t5 = powMinusX(t4);
+    const t6 = Fp12.mul(powMinusX(t5), Fp12._cyclotomicSquare(t2));
+    const t7 = powMinusX(t6);
     const t2_t5_pow_q2 = Fp12.frobeniusMap(Fp12.mul(t2, t5), 2);
@@ -288,4 +370,4 @@ const t4_t1_pow_q3 = Fp12.frobeniusMap(Fp12.mul(t4, t1), 3);
     return Fp2.create({
-      c0: Fp.create(bytesToNumberBE(bytes.subarray(L))),
-      c1: Fp.create(bytesToNumberBE(bytes.subarray(0, L))),
+      c0: decodeFp(bytes.subarray(L)),
+      c1: decodeFp(bytes.subarray(0, L)),
     });
@@ -295,2 +377,5 @@ },
 const BaseFp = Fp;
+function decodeFp(bytes: TArg<Uint8Array>): Fp {
+  return Fp.fromBytes(bytes);
+}
 type Mask = { compressed: boolean; infinity: boolean; sort: boolean };
@@ -333,4 +418,4 @@ // Keep BLS12-381 point/signature codecs on one control-flow skeleton: the G1/G2
       if (infinity) {
-        // Infinity canonicality has to be checked on raw bytes before decode()
-        // reduces coordinates modulo p and turns non-empty payloads into zero.
+        // Infinity has a dedicated encoding: after the flag bits are cleared, every
+        // remaining payload byte must be zero.
         for (const b of value) {
@@ -350,4 +435,4 @@ if (b) throw new Error(`invalid ${name} point: non-canonical zero`);
       }
-      // Noble keeps the permissive coordinate reduction path here, but an
-      // omitted infinity flag must not still decode to ZERO afterwards.
+      // The all-zero uncompressed payload must use the infinity flag instead of
+      // decoding as an ordinary affine point.
       if (!compressed && F.is0(x) && F.is0(y))
@@ -373,3 +458,2 @@ throw new Error(`invalid ${name} point: uncompressed`);
   // Copy, so we can remove mask data.
-  // It will be removed also later, when Fp.create will call modulo.
   bytes = copyBytes(bytes);
@@ -402,3 +486,3 @@ const mask = bytes[0] & 0b1110_0000;
   (x: Fp) => numberToBytesBE(x, Fp.BYTES),
-  (bytes: TArg<Uint8Array>) => Fp.create(bytesToNumberBE(bytes) & bitMask(Fp.BITS)),
+  decodeFp,
   (y: Fp) => [y]
@@ -405,0 +489,0 @@ );

src/bn254.ts

@@ -111,2 +111,32 @@ /**
 let Fp12: ReturnType<typeof tower12>['Fp12'];
+const bn254CyclotomicExpX = (num: Fp12): Fp12 => {
+  const cyclSqrN = (n: Fp12, count: number) => {
+    for (let i = 0; i < count; i++) n = Fp12._cyclotomicSquare(n);
+    return n;
+  };
+  // Addition chain for BN_X = 0x44e992b44a6909f1. This keeps the same cyclotomic-square
+  // count as binary exponentiation, but cuts Fp12 multiplications by about a third.
+  const x10 = Fp12._cyclotomicSquare(num);
+  const x100 = Fp12._cyclotomicSquare(x10);
+  const x1000 = Fp12._cyclotomicSquare(x100);
+  const x10000 = Fp12._cyclotomicSquare(x1000);
+  const x10001 = Fp12.mul(x10000, num);
+  const x10011 = Fp12.mul(x10001, x10);
+  const x10100 = Fp12.mul(x10011, num);
+  const x11001 = Fp12.mul(x1000, x10001);
+  const x100010 = Fp12._cyclotomicSquare(x10001);
+  const x100111 = Fp12.mul(x10011, x10100);
+  const x101001 = Fp12.mul(x10, x100111);
+  let r = cyclSqrN(x100010, 6);
+  r = Fp12.mul(Fp12.mul(r, x100), x11001);
+  r = Fp12.mul(cyclSqrN(r, 7), x11001);
+  r = cyclSqrN(r, 8);
+  r = Fp12.mul(Fp12.mul(r, x101001), x10);
+  r = Fp12.mul(cyclSqrN(r, 6), x10001);
+  r = Fp12.mul(cyclSqrN(r, 8), x101001);
+  r = Fp12.mul(cyclSqrN(r, 6), x101001);
+  r = Fp12.mul(cyclSqrN(r, 10), x100111);
+  r = Fp12.mul(Fp12.mul(cyclSqrN(r, 6), x101001), x1000);
+  return r;
+};
 const tower = /* @__PURE__ */ (() => {
@@ -121,3 +151,3 @@ const res = tower12({
     Fp12finalExponentiate: (num: Fp12) => {
-      const powMinusX = (num: Fp12) => Fp12.conjugate(Fp12._cyclotomicExp(num, BN_X));
+      const powMinusX = (num: Fp12) => Fp12.conjugate(bn254CyclotomicExpX(num));
       const r0 = Fp12.mul(Fp12.conjugate(num), Fp12.inv(num));
@@ -124,0 +154,0 @@ const r = Fp12.mul(Fp12.frobeniusMap(r0, 2), r0);

src/ed25519.ts

@@ -127,2 +127,19 @@ /**
 const Fp = /* @__PURE__ */ (() => ed25519_Point.Fp)();
+
+function toMontgomery(point: EdwardsPoint): TRet<Uint8Array> {
+  // Birational map from Ed25519 to Curve25519 / X25519:
+  //   (u, v) = ((1 + y) / (1 - y), sqrt(-486664) * u / x)
+  //   (x, y) = (sqrt(-486664) * u / v, (u - 1) / (u + 1))
+  const { y } = point;
+  return Fp.toBytes(Fp.div(_1n + y, _1n - y)) as TRet<Uint8Array>;
+}
+
+function toMontgomerySecret(secretKey: TArg<Uint8Array>): TRet<Uint8Array> {
+  const size = ed25519_Point.Fp.BYTES;
+  abytes(secretKey, size);
+  return adjustScalarBytes(sha512(secretKey.subarray(0, size))).subarray(
+    0,
+    size
+  ) as TRet<Uint8Array>;
+}
 const Fn = /* @__PURE__ */ (() => ed25519_Point.Fn)();
@@ -151,3 +168,6 @@
     sha512,
-    Object.assign({ adjustScalarBytes, zip215: true }, opts as EdDSAOpts)
+    Object.assign(
+      { adjustScalarBytes, toMontgomery, toMontgomerySecret, zip215: true },
+      opts as EdDSAOpts
+    )
   );
@@ -244,2 +264,3 @@ }
  * const bob = x25519.keygen();
+ * const alicePublic = x25519.getPublicKey(alice.secretKey);
  * const shared = x25519.getSharedSecret(alice.secretKey, bob.publicKey);
@@ -250,11 +271,25 @@ * ```
   const P = ed25519_CURVE_p;
+  const powPminus2 = (x: bigint): bigint => {
+    // x^(p-2) aka x^(2^255-21)
+    const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);
+    return mod(pow2(pow_p_5_8, _3n, P) * b2, P);
+  };
   return montgomery({
     P,
     type: 'x25519',
-    powPminus2: (x: bigint): bigint => {
-      // x^(p-2) aka x^(2^255-21)
-      const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);
-      return mod(pow2(pow_p_5_8, _3n, P) * b2, P);
+    powPminus2,
+    adjustScalarBytes,
+    // ~3x faster fixed-base: [k]B on the birationally-equivalent Edwards curve using cached
+    // base tables, mapped back via u = (1+y)/(1-y) = (Z+Y)/(Z-Y) with one Fermat inversion.
+    // Same construction as libsodium's crypto_scalarmult_curve25519_base.
+    scalarMultBase: (k: bigint): bigint => {
+      // Clamped k (≈2^254) exceeds n, but B has prime order n, so [k]B == [k mod n]B.
+      const kn = mod(k, ed25519_Point.Fn.ORDER);
+      // k ≡ 0 (mod n): [k]B is the point at infinity, whose u is 0 in the x-only ladder;
+      // returning 0 makes montgomery() reject it exactly like the ladder path.
+      if (kn === _0n) return _0n;
+      const p = ed25519_Point.BASE.multiply(kn);
+      // Z-Y == 0 only at the identity, which kn != 0 excludes.
+      return mod((p.Z + p.Y) * powPminus2(mod(p.Z - p.Y, P)), P);
     },
-    adjustScalarBytes,
   });
@@ -270,2 +305,3 @@ })();
 const ELL2_C3 = /* @__PURE__ */ (() => Fp.sqrt(Fp.neg(Fp.ONE)))(); // 3. c3 = sqrt(-1)
+const ELL2_J = /* @__PURE__ */ BigInt(486662);
 
@@ -280,5 +316,4 @@ /**
 } {
-  const ELL2_C4 = (ed25519_CURVE_p - _5n) / _8n; // 4. c4 = (q - 5) / 8       # Integer arithmetic
-  const ELL2_J = BigInt(486662);
-
+  // 4. c4 = (q - 5) / 8: tv2^c4 below reuses the ed25519_pow_2_252_3 addition chain,
+  // whose pow_p_5_8 output is exactly x^((p-5)/8).
   let tv1 = Fp.sqr(u);          //  1.  tv1 = u^2
@@ -300,3 +335,3 @@ tv1 = Fp.mul(tv1, _2n);       //  2.  tv1 = 2 * tv1
   tv2 = Fp.mul(tv2, tv3);       //  15. tv2 = tv2 * tv3       # gx1 * gxd^7
-  let y11 = Fp.pow(tv2, ELL2_C4); //  16. y11 = tv2^c4        # (gx1 * gxd^7)^((p - 5) / 8)
+  let y11 = ed25519_pow_2_252_3(tv2).pow_p_5_8; //  16. y11 = tv2^c4  # (gx1 * gxd^7)^((p - 5) / 8)
   y11 = Fp.mul(y11, tv3);       //  17. y11 = y11 * tv3       # gx1*gxd^3*(gx1*gxd^7)^((p-5)/8)
@@ -417,20 +452,18 @@ let y12 = Fp.mul(y11, ELL2_C3); //  18. y12 = y11 * c3
   const { d } = ed25519_CURVE;
-  const P = ed25519_CURVE_p;
-  const mod = (n: bigint) => Fp.create(n);
-  const r = mod(SQRT_M1 * r0 * r0); // 1
-  const Ns = mod((r + _1n) * ONE_MINUS_D_SQ); // 2
+  const r = Fp.mul(Fp.mulN(SQRT_M1, r0), r0); // 1
+  const Ns = Fp.mul(Fp.addN(r, _1n), ONE_MINUS_D_SQ); // 2
   let c = BigInt(-1); // 3
-  const D = mod((c - d * r) * mod(r + d)); // 4
+  const D = Fp.mul(Fp.subN(c, Fp.mulN(d, r)), Fp.add(r, d)); // 4
   let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D); // 5
-  let s_ = mod(s * r0); // 6
-  if (!isNegativeLE(s_, P)) s_ = mod(-s_);
+  let s_ = Fp.mul(s, r0); // 6
+  if (!Fp.isOdd!(s_)) s_ = Fp.neg(s_);
   if (!Ns_D_is_sq) s = s_; // 7
   if (!Ns_D_is_sq) c = r; // 8
-  const Nt = mod(c * (r - _1n) * D_MINUS_ONE_SQ - D); // 9
-  const s2 = s * s;
-  const W0 = mod((s + s) * D); // 10
-  const W1 = mod(Nt * SQRT_AD_MINUS_ONE); // 11
-  const W2 = mod(_1n - s2); // 12
-  const W3 = mod(_1n + s2); // 13
-  return new ed25519_Point(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));
+  const Nt = Fp.sub(Fp.mulN(Fp.mulN(c, Fp.subN(r, _1n)), D_MINUS_ONE_SQ), D); // 9
+  const s2 = Fp.sqrN(s);
+  const W0 = Fp.mul(Fp.addN(s, s), D); // 10
+  const W1 = Fp.mul(Nt, SQRT_AD_MINUS_ONE); // 11
+  const W2 = Fp.sub(_1n, s2); // 12
+  const W3 = Fp.add(_1n, s2); // 13
+  return new ed25519_Point(Fp.mul(W0, W3), Fp.mul(W2, W1), Fp.mul(W1, W3), Fp.mul(W0, W2));
 }
@@ -488,25 +521,22 @@
     const { a, d } = ed25519_CURVE;
-    const P = ed25519_CURVE_p;
-    const mod = (n: bigint) => Fp.create(n);
     const s = bytes255ToNumberLE(bytes);
     // 1. Check that s_bytes is the canonical encoding of a field element, or else abort.
     // 3. Check that s is non-negative, or else abort
-    if (!equalBytes(Fp.toBytes(s), bytes) || isNegativeLE(s, P))
+    if (!equalBytes(Fp.toBytes(s), bytes) || Fp.isOdd!(s))
       throw new Error('invalid ristretto255 encoding 1');
-    const s2 = mod(s * s);
-    const u1 = mod(_1n + a * s2); // 4 (a is -1)
-    const u2 = mod(_1n - a * s2); // 5
-    const u1_2 = mod(u1 * u1);
-    const u2_2 = mod(u2 * u2);
-    const v = mod(a * d * u1_2 - u2_2); // 6
-    const { isValid, value: I } = invertSqrt(mod(v * u2_2)); // 7
-    const Dx = mod(I * u2); // 8
-    const Dy = mod(I * Dx * v); // 9
-    let x = mod((s + s) * Dx); // 10
-    if (isNegativeLE(x, P)) x = mod(-x); // 10
-    const y = mod(u1 * Dy); // 11
-    const t = mod(x * y); // 12
-    if (!isValid || isNegativeLE(t, P) || y === _0n)
-      throw new Error('invalid ristretto255 encoding 2');
-    return new _RistrettoPoint(new ed25519_Point(x, y, _1n, t));
+    const s2 = Fp.sqr(s);
+    const u1 = Fp.add(_1n, Fp.mulN(a, s2)); // 4 (a is -1)
+    const u2 = Fp.sub(_1n, Fp.mulN(a, s2)); // 5
+    const u1_2 = Fp.sqr(u1);
+    const u2_2 = Fp.sqr(u2);
+    const v = Fp.sub(Fp.mulN(Fp.mulN(a, d), u1_2), u2_2); // 6
+    const { isValid, value: I } = invertSqrt(Fp.mul(v, u2_2)); // 7
+    const Dx = Fp.mul(I, u2); // 8
+    const Dy = Fp.mul(Fp.mulN(I, Dx), v); // 9
+    let x = Fp.mul(Fp.addN(s, s), Dx); // 10
+    if (Fp.isOdd!(x)) x = Fp.neg(x); // 10
+    const y = Fp.mul(u1, Dy); // 11
+    const t = Fp.mul(x, y); // 12
+    if (!isValid || Fp.isOdd!(t) || Fp.is0(y)) throw new Error('invalid ristretto255 encoding 2');
+    return new _RistrettoPoint(new ed25519_Point(x, y, Fp.ONE, t));
   }
@@ -529,25 +559,23 @@
     let { X, Y, Z, T } = this.ep;
-    const P = ed25519_CURVE_p;
-    const mod = (n: bigint) => Fp.create(n);
-    const u1 = mod(mod(Z + Y) * mod(Z - Y)); // 1
-    const u2 = mod(X * Y); // 2
+    const u1 = Fp.mul(Fp.add(Z, Y), Fp.sub(Z, Y)); // 1
+    const u2 = Fp.mul(X, Y); // 2
     // Square root always exists
-    const u2sq = mod(u2 * u2);
-    const { value: invsqrt } = invertSqrt(mod(u1 * u2sq)); // 3
-    const D1 = mod(invsqrt * u1); // 4
-    const D2 = mod(invsqrt * u2); // 5
-    const zInv = mod(D1 * D2 * T); // 6
+    const u2sq = Fp.sqr(u2);
+    const { value: invsqrt } = invertSqrt(Fp.mul(u1, u2sq)); // 3
+    const D1 = Fp.mul(invsqrt, u1); // 4
+    const D2 = Fp.mul(invsqrt, u2); // 5
+    const zInv = Fp.mul(Fp.mulN(D1, D2), T); // 6
     let D: bigint; // 7
-    if (isNegativeLE(T * zInv, P)) {
-      let _x = mod(Y * SQRT_M1);
-      let _y = mod(X * SQRT_M1);
+    if (Fp.isOdd!(Fp.mul(T, zInv))) {
+      let _x = Fp.mul(Y, SQRT_M1);
+      let _y = Fp.mul(X, SQRT_M1);
       X = _x;
       Y = _y;
-      D = mod(D1 * INVSQRT_A_MINUS_D);
+      D = Fp.mul(D1, INVSQRT_A_MINUS_D);
     } else {
       D = D2; // 8
     }
-    if (isNegativeLE(X * zInv, P)) Y = mod(-Y); // 9
-    let s = mod((Z - Y) * D); // 10 (check footer's note, no sqrt(-a))
-    if (isNegativeLE(s, P)) s = mod(-s);
+    if (Fp.isOdd!(Fp.mul(X, zInv))) Y = Fp.neg(Y); // 9
+    let s = Fp.mul(Fp.subN(Z, Y), D); // 10 (check footer's note, no sqrt(-a))
+    if (Fp.isOdd!(s)) s = Fp.neg(s);
     return Fp.toBytes(s) as TRet<Uint8Array>; // 11
@@ -564,6 +592,5 @@ }
     const { X: X2, Y: Y2 } = other.ep;
-    const mod = (n: bigint) => Fp.create(n);
     // (x1 * y2 == y1 * x2) | (y1 * y2 == x1 * x2)
-    const one = mod(X1 * Y2) === mod(Y1 * X2);
-    const two = mod(Y1 * Y2) === mod(X1 * X2);
+    const one = Fp.eql(Fp.mul(X1, Y2), Fp.mul(Y1, X2));
+    const two = Fp.eql(Fp.mul(Y1, Y2), Fp.mul(X1, X2));
     return one || two;
@@ -576,6 +603,2 @@ }
 }
-Object.freeze(_RistrettoPoint.BASE);
-Object.freeze(_RistrettoPoint.ZERO);
-Object.freeze(_RistrettoPoint.prototype);
-Object.freeze(_RistrettoPoint);
 
@@ -585,3 +608,9 @@ /** Prime-order Ristretto255 group bundle. */
   Point: typeof _RistrettoPoint;
-} = /* @__PURE__ */ Object.freeze({ Point: _RistrettoPoint });
+} = /* @__PURE__ */ (() => {
+  Object.freeze(_RistrettoPoint.BASE);
+  Object.freeze(_RistrettoPoint.ZERO);
+  Object.freeze(_RistrettoPoint.prototype);
+  Object.freeze(_RistrettoPoint);
+  return Object.freeze({ Point: _RistrettoPoint });
+})();
 
@@ -600,5 +629,6 @@ /**
  */
-export const ristretto255_hasher: H2CHasherBase<typeof _RistrettoPoint> = Object.freeze({
-  Point: _RistrettoPoint,
-  /**
+export const ristretto255_hasher: H2CHasherBase<typeof _RistrettoPoint> =
+  /* @__PURE__ */ Object.freeze({
+    Point: _RistrettoPoint,
+    /**
   * Spec: https://www.rfc-editor.org/rfc/rfc9380.html#name-hashing-to-ristretto255. Caveats:
@@ -617,36 +647,37 @@ * * There are no test vectors
   */
-  hashToCurve(msg: TArg<Uint8Array>, options?: TArg<H2CDSTOpts>): _RistrettoPoint {
-    // == 'hash_to_ristretto255'
-    // Preserve explicit empty/invalid DST overrides so expand_message_xmd() can reject them.
-    const DST = options?.DST === undefined ? 'ristretto255_XMD:SHA-512_R255MAP_RO_' : options.DST;
-    const xmd = expand_message_xmd(msg, DST, 64, sha512);
-    // NOTE: RFC 9380 incorrectly calls this function `ristretto255_map`.
-    // In RFC 9496, `map` was the per-point function inside the construction.
-    // That also led to confusion that `ristretto255_map` is `mapToCurve`.
-    // It is not: it is the older hash-to-curve construction.
-    return ristretto255_hasher.deriveToCurve!(xmd);
-  },
-  hashToScalar(msg: TArg<Uint8Array>, options: TArg<H2CDSTOpts> = { DST: _DST_scalar }) {
-    const xmd = expand_message_xmd(msg, options.DST, 64, sha512);
-    return Fn.create(bytesToNumberLE(xmd));
-  },
-  /**
-   * HashToCurve-like construction based on RFC 9496 (Element Derivation).
-   * Converts 64 uniform random bytes into a curve point.
-   *
-   * WARNING: This represents an older hash-to-curve construction from before
-   * RFC 9380 was finalized.
-   * It was later reused as a component in the newer
-   * `hash_to_ristretto255` function defined in RFC 9380.
-   */
-  deriveToCurve(bytes: TArg<Uint8Array>): _RistrettoPoint {
-    // https://www.rfc-editor.org/rfc/rfc9496.html#name-element-derivation
-    abytes(bytes, 64);
-    const r1 = bytes255ToNumberLE(bytes.subarray(0, 32));
-    const R1 = calcElligatorRistrettoMap(r1);
-    const r2 = bytes255ToNumberLE(bytes.subarray(32, 64));
-    const R2 = calcElligatorRistrettoMap(r2);
-    return new _RistrettoPoint(R1.add(R2));
-  },
-});
+    hashToCurve(msg: TArg<Uint8Array>, options?: TArg<H2CDSTOpts>): _RistrettoPoint {
+      // == 'hash_to_ristretto255'
+      // Preserve explicit empty/invalid DST overrides so expand_message_xmd() can reject them.
+      const DST = options?.DST === undefined ? 'ristretto255_XMD:SHA-512_R255MAP_RO_' : options.DST;
+      const xmd = expand_message_xmd(msg, DST, 64, sha512);
+      // NOTE: RFC 9380 incorrectly calls this function `ristretto255_map`.
+      // In RFC 9496, `map` was the per-point function inside the construction.
+      // That also led to confusion that `ristretto255_map` is `mapToCurve`.
+      // It is not: it is the older hash-to-curve construction.
+      return ristretto255_hasher.deriveToCurve!(xmd);
+    },
+    hashToScalar(msg: TArg<Uint8Array>, options?: TArg<H2CDSTOpts>) {
+      const DST = options?.DST === undefined ? _DST_scalar : options.DST;
+      const xmd = expand_message_xmd(msg, DST, 64, sha512);
+      return Fn.create(bytesToNumberLE(xmd));
+    },
+    /**
+     * HashToCurve-like construction based on RFC 9496 (Element Derivation).
+     * Converts 64 uniform random bytes into a curve point.
+     *
+     * WARNING: This represents an older hash-to-curve construction from before
+     * RFC 9380 was finalized.
+     * It was later reused as a component in the newer
+     * `hash_to_ristretto255` function defined in RFC 9380.
+     */
+    deriveToCurve(bytes: TArg<Uint8Array>): _RistrettoPoint {
+      // https://www.rfc-editor.org/rfc/rfc9496.html#name-element-derivation
+      abytes(bytes, 64);
+      const r1 = bytes255ToNumberLE(bytes.subarray(0, 32));
+      const R1 = calcElligatorRistrettoMap(r1);
+      const r2 = bytes255ToNumberLE(bytes.subarray(32, 64));
+      const R2 = calcElligatorRistrettoMap(r2);
+      return new _RistrettoPoint(R1.add(R2));
+    },
+  });
 
@@ -653,0 +684,0 @@ /**

src/ed448.ts

@@ -32,3 +32,3 @@ /**
 } from './abstract/hash-to-curve.ts';
-import { Field, FpInvertBatch, isNegativeLE, mod, pow2, type IField } from './abstract/modular.ts';
+import { Field, FpInvertBatch, mod, pow2, type IField } from './abstract/modular.ts';
 import { montgomery, type MontgomeryECDH } from './abstract/montgomery.ts';
@@ -97,3 +97,3 @@ import { createOPRF, type OPRF } from './abstract/oprf.ts';
 // prettier-ignore
-const _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4), _11n = /* @__PURE__ */ BigInt(11);
+const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4), _11n = /* @__PURE__ */ BigInt(11);
 // prettier-ignore
@@ -173,2 +173,21 @@ const _22n = /* @__PURE__ */ BigInt(22), _44n = /* @__PURE__ */ BigInt(44), _88n = /* @__PURE__ */ BigInt(88), _223n = /* @__PURE__ */ BigInt(223);
 
+function toMontgomery(point: EdwardsPoint): TRet<Uint8Array> {
+  // RFC 7748 section 4.2 maps Ed448-Goldilocks to Curve448 via a 4-isogeny.
+  // The u-coordinate map is:
+  //   u = y^2 / x^2
+  // In projective coordinates this is:
+  //   u = Y^2 / X^2
+  const u = Fp.div(Fp.mul(point.Y, point.Y), Fp.mul(point.X, point.X));
+  return Fp448.toBytes(u) as TRet<Uint8Array>;
+}
+
+function toMontgomerySecret(secretKey: TArg<Uint8Array>): TRet<Uint8Array> {
+  const size = ed448_Point.Fp.BYTES;
+  abytes(secretKey, size);
+  return adjustScalarBytes(shake256_114(secretKey.subarray(0, size))).subarray(
+    0,
+    56
+  ) as TRet<Uint8Array>;
+}
+
 // SHAKE256(dom4(phflag,context)||x, 114)
@@ -194,3 +213,6 @@ // RFC 8032 `dom4` prefix. Empty contexts are valid; the accepted length range
     shake256_114,
-    Object.assign({ adjustScalarBytes, domain: dom4 }, opts as EdDSAOpts)
+    Object.assign(
+      { adjustScalarBytes, domain: dom4, toMontgomery, toMontgomerySecret },
+      opts as EdDSAOpts
+    )
   );
@@ -241,9 +263,11 @@ }
  * @example
- * Multiply the E448 base point.
+ * Reconstruct and validate the E448 base point from its projective coordinates.
  *
  * ```ts
- * const point = E448.BASE.multiply(2n);
+ * import { E448 } from '@noble/curves/ed448.js';
+ * const point = new E448(E448.BASE.X, E448.BASE.Y, E448.BASE.Z, E448.BASE.T);
+ * point.assertValidity();
  * ```
  */
-export const E448: EdwardsPointCons = /* @__PURE__ */ edwards(E448_CURVE);
+export const E448: EdwardsPointCons = /* @__PURE__ */ edwards(E448_CURVE, { Fp, Fn });
 
@@ -267,11 +291,26 @@ /**
   const P = ed448_CURVE_p;
+  const powPminus2 = (x: bigint): bigint => {
+    const Pminus3div4 = ed448_pow_Pminus3div4(x);
+    const Pminus3 = pow2(Pminus3div4, _2n, P);
+    return mod(Pminus3 * x, P); // Pminus3 * x = Pminus2
+  };
   return montgomery({
     P,
     type: 'x448',
-    powPminus2: (x: bigint): bigint => {
-      const Pminus3div4 = ed448_pow_Pminus3div4(x);
-      const Pminus3 = pow2(Pminus3div4, _2n, P);
-      return mod(Pminus3 * x, P); // Pminus3 * x = Pminus2
+    powPminus2,
+    adjustScalarBytes,
+    // ~3x faster fixed-base: [k]B on Ed448-Goldilocks using cached base tables, mapped back
+    // through the 4-isogeny to curve448: u = y²/x² = Y²/X² (the isogeny is a homomorphism and
+    // sends the Ed448 base point to u=5, so no scalar correction factor is needed).
+    scalarMultBase: (k: bigint): bigint => {
+      // Clamped k (≈2^447) exceeds n, but B has prime order n, so [k]B == [k mod n]B.
+      const kn = mod(k, ed448_Point.Fn.ORDER);
+      // k ≡ 0 (mod n): [k]B is the point at infinity, whose u is 0 in the x-only ladder;
+      // returning 0 makes montgomery() reject it exactly like the ladder path.
+      if (kn === _0n) return _0n;
+      const p = ed448_Point.BASE.multiply(kn);
+      // X == 0 only at the identity and the order-2 point, both excluded from the prime-order
+      // subgroup hit by kn in 1..n-1.
+      return mod(p.Y * p.Y * powPminus2(mod(p.X * p.X, P)), P);
     },
-    adjustScalarBytes,
   });
@@ -281,4 +320,4 @@ })();
 // Hash To Curve Elligator2 Map
-// 1. c1 = (q - 3) / 4 # Integer arithmetic
-const ELL2_C1 = /* @__PURE__ */ (() => (ed448_CURVE_p - BigInt(3)) / BigInt(4))();
+// 1. c1 = (q - 3) / 4 # Integer arithmetic — tv3^c1 below reuses the
+// ed448_pow_Pminus3div4 addition chain, which computes exactly x^((p-3)/4).
 const ELL2_J = /* @__PURE__ */ BigInt(156326);
@@ -303,3 +342,3 @@
   tv3 = Fp.mul(tv3, tv2); // 14. tv3 = tv3 * tv2         # gx1 * gxd^3
-  let y1 = Fp.pow(tv3, ELL2_C1); // 15.  y1 = tv3^c1            # (gx1 * gxd^3)^((p - 3) / 4)
+  let y1 = ed448_pow_Pminus3div4(tv3); // 15.  y1 = tv3^c1      # (gx1 * gxd^3)^((p - 3) / 4)
   y1 = Fp.mul(y1, tv2); // 16.  y1 = y1 * tv2          # gx1 * gxd * (gx1 * gxd^3)^((p - 3) / 4)
@@ -431,5 +470,4 @@ // 17. x2n = -tv1 * x1n # x2 = x2n / xd = -1 * u^2 * x1n / xd
 const sqrtRatioM1 = (u: bigint, v: bigint) => {
-  const P = ed448_CURVE_p;
   const { isValid, value } = uvRatio(u, v);
-  return { isValid, value: isNegativeLE(value, P) ? Fp448.create(-value) : value };
+  return { isValid, value: Fp448.isOdd!(value) ? Fp448.neg(value) : value };
 };
@@ -445,27 +483,37 @@ const invertSqrt = (number: bigint) => sqrtRatioM1(_1n, number);
 function calcElligatorDecafMap(r0: bigint): EdwardsPoint {
-  const { d, p: P } = ed448_CURVE;
-  const mod = (n: bigint) => Fp448.create(n);
+  const { d } = ed448_CURVE;
 
-  const r = mod(-(r0 * r0)); // 1
-  const u0 = mod(d * (r - _1n)); // 2
-  const u1 = mod((u0 + _1n) * (u0 - r)); // 3
+  const r = Fp448.create(-Fp448.sqrN(r0)); // 1
+  const u0 = Fp448.mul(d, Fp448.subN(r, _1n)); // 2
+  const u1 = Fp448.mul(Fp448.addN(u0, _1n), Fp448.subN(u0, r)); // 3
 
-  const { isValid: was_square, value: v } = sqrtRatioM1(ONE_MINUS_TWO_D, mod((r + _1n) * u1)); // 4
+  const { isValid: was_square, value: v } = sqrtRatioM1(
+    ONE_MINUS_TWO_D,
+    Fp448.mul(Fp448.addN(r, _1n), u1)
+  ); // 4
 
   let v_prime = v; // 5
-  if (!was_square) v_prime = mod(r0 * v);
+  if (!was_square) v_prime = Fp448.mul(r0, v);
 
   let sgn = _1n; // 6
-  if (!was_square) sgn = mod(-_1n);
+  if (!was_square) sgn = Fp448.neg(Fp448.ONE);
 
-  const s = mod(v_prime * (r + _1n)); // 7
+  const s = Fp448.mul(v_prime, Fp448.addN(r, _1n)); // 7
   let s_abs = s;
-  if (isNegativeLE(s, P)) s_abs = mod(-s);
+  if (Fp448.isOdd!(s)) s_abs = Fp448.neg(s);
 
-  const s2 = s * s;
-  const W0 = mod(s_abs * _2n); // 8
-  const W1 = mod(s2 + _1n); // 9
-  const W2 = mod(s2 - _1n); // 10
-  const W3 = mod(v_prime * s * (r - _1n) * ONE_MINUS_TWO_D + sgn); // 11
-  return new ed448_Point(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));
+  const s2 = Fp448.sqrN(s);
+  const W0 = Fp448.mul(s_abs, _2n); // 8
+  const W1 = Fp448.add(s2, _1n); // 9
+  const W2 = Fp448.sub(s2, _1n); // 10
+  const W3 = Fp448.add(
+    Fp448.mulN(Fp448.mulN(Fp448.mulN(v_prime, s), Fp448.subN(r, _1n)), ONE_MINUS_TWO_D),
+    sgn
+  ); // 11
+  return new ed448_Point(
+    Fp448.mul(W0, W3),
+    Fp448.mul(W2, W1),
+    Fp448.mul(W1, W3),
+    Fp448.mul(W0, W2)
+  );
 }
@@ -532,4 +580,3 @@
     abytes(bytes, 56);
-    const { d, p: P } = ed448_CURVE;
-    const mod = (n: bigint) => Fp448.create(n);
+    const { d } = ed448_CURVE;
     const s = Fp448.fromBytes(bytes);
@@ -539,21 +586,21 @@
     // 2. Check that s is non-negative, or else abort
-    if (!equalBytes(Fn448.toBytes(s), bytes) || isNegativeLE(s, P))
+    if (!equalBytes(Fp448.toBytes(s), bytes) || Fp448.isOdd!(s))
       throw new Error('invalid decaf448 encoding 1');
 
-    const s2 = mod(s * s); // 1
-    const u1 = mod(_1n + s2); // 2
-    const u1sq = mod(u1 * u1);
-    const u2 = mod(u1sq - _4n * d * s2); // 3
+    const s2 = Fp448.sqr(s); // 1
+    const u1 = Fp448.add(Fp448.ONE, s2); // 2
+    const u1sq = Fp448.sqr(u1);
+    const u2 = Fp448.sub(u1sq, Fp448.mulN(Fp448.mulN(_4n, d), s2)); // 3
 
-    const { isValid, value: invsqrt } = invertSqrt(mod(u2 * u1sq)); // 4
+    const { isValid, value: invsqrt } = invertSqrt(Fp448.mul(u2, u1sq)); // 4
 
-    let u3 = mod((s + s) * invsqrt * u1 * SQRT_MINUS_D); // 5
-    if (isNegativeLE(u3, P)) u3 = mod(-u3);
+    let u3 = Fp448.mul(Fp448.mulN(Fp448.mulN(Fp448.addN(s, s), invsqrt), u1), SQRT_MINUS_D); // 5
+    if (Fp448.isOdd!(u3)) u3 = Fp448.neg(u3);
 
-    const x = mod(u3 * invsqrt * u2 * INVSQRT_MINUS_D); // 6
-    const y = mod((_1n - s2) * invsqrt * u1); // 7
-    const t = mod(x * y); // 8
+    const x = Fp448.mul(Fp448.mulN(Fp448.mulN(u3, invsqrt), u2), INVSQRT_MINUS_D); // 6
+    const y = Fp448.mul(Fp448.mulN(Fp448.subN(_1n, s2), invsqrt), u1); // 7
+    const t = Fp448.mul(x, y); // 8
 
     if (!isValid) throw new Error('invalid decaf448 encoding 2');
-    return new _DecafPoint(new ed448_Point(x, y, _1n, t));
+    return new _DecafPoint(new ed448_Point(x, y, Fp448.ONE, t));
   }
@@ -576,13 +623,11 @@
     const { X, Z, T } = this.ep;
-    const P = ed448_CURVE.p;
-    const mod = (n: bigint) => Fp448.create(n);
-    const u1 = mod(mod(X + T) * mod(X - T)); // 1
-    const x2 = mod(X * X);
-    const { value: invsqrt } = invertSqrt(mod(u1 * ONE_MINUS_D * x2)); // 2
-    let ratio = mod(invsqrt * u1 * SQRT_MINUS_D); // 3
-    if (isNegativeLE(ratio, P)) ratio = mod(-ratio);
-    const u2 = mod(INVSQRT_MINUS_D * ratio * Z - T); // 4
-    let s = mod(ONE_MINUS_D * invsqrt * X * u2); // 5
-    if (isNegativeLE(s, P)) s = mod(-s);
-    return Fn448.toBytes(s) as TRet<Uint8Array>;
+    const u1 = Fp448.mul(Fp448.add(X, T), Fp448.sub(X, T)); // 1
+    const x2 = Fp448.sqr(X);
+    const { value: invsqrt } = invertSqrt(Fp448.mul(Fp448.mulN(u1, ONE_MINUS_D), x2)); // 2
+    let ratio = Fp448.mul(Fp448.mulN(invsqrt, u1), SQRT_MINUS_D); // 3
+    if (Fp448.isOdd!(ratio)) ratio = Fp448.neg(ratio);
+    const u2 = Fp448.sub(Fp448.mulN(Fp448.mulN(INVSQRT_MINUS_D, ratio), Z), T); // 4
+    let s = Fp448.mul(Fp448.mulN(Fp448.mulN(ONE_MINUS_D, invsqrt), X), u2); // 5
+    if (Fp448.isOdd!(s)) s = Fp448.neg(s);
+    return Fp448.toBytes(s) as TRet<Uint8Array>;
   }
@@ -599,3 +644,3 @@
     // (x1 * y2 == y1 * x2)
-    return Fp448.create(X1 * Y2) === Fp448.create(Y1 * X2);
+    return Fp448.eql(Fp448.mul(X1, Y2), Fp448.mul(Y1, X2));
   }
@@ -607,11 +652,12 @@
 }
-Object.freeze(_DecafPoint.BASE);
-Object.freeze(_DecafPoint.ZERO);
-Object.freeze(_DecafPoint.prototype);
-Object.freeze(_DecafPoint);
-
 /** Prime-order Decaf448 group bundle. */
 export const decaf448: {
   Point: typeof _DecafPoint;
-} = /* @__PURE__ */ Object.freeze({ Point: _DecafPoint });
+} = /* @__PURE__ */ (() => {
+  Object.freeze(_DecafPoint.BASE);
+  Object.freeze(_DecafPoint.ZERO);
+  Object.freeze(_DecafPoint.prototype);
+  Object.freeze(_DecafPoint);
+  return Object.freeze({ Point: _DecafPoint });
+})();
 
@@ -630,3 +676,3 @@ /**
  */
-export const decaf448_hasher: H2CHasherBase<typeof _DecafPoint> = Object.freeze({
+export const decaf448_hasher: H2CHasherBase<typeof _DecafPoint> = /* @__PURE__ */ Object.freeze({
   Point: _DecafPoint,
@@ -643,5 +689,6 @@ hashToCurve(msg: TArg<Uint8Array>, options?: TArg<H2CDSTOpts>): _DecafPoint {
    */
-  hashToScalar(msg: TArg<Uint8Array>, options: TArg<H2CDSTOpts> = { DST: _DST_scalar }): bigint {
+  hashToScalar(msg: TArg<Uint8Array>, options?: TArg<H2CDSTOpts>): bigint {
+    const DST = options?.DST === undefined ? _DST_scalar : options.DST;
     // Can't use `Fn448.fromBytes()`. 64-byte input => 56-byte field element
-    const xof = expand_message_xof(msg, options.DST, 64, 256, shake256);
+    const xof = expand_message_xof(msg, DST, 64, 256, shake256);
     return Fn448.create(bytesToNumberLE(xof));
@@ -698,3 +745,3 @@ },
  * Instead, the torsion subgroup here is cyclic of order 4, generated by
- * `(1, 0)`, and the array below lists that subgroup set (Klein four-group).
+ * `(1, 0)`, and the array below lists that subgroup set.
  * @example
@@ -701,0 +748,0 @@ * Decode one known torsion point for debugging.

src/misc.ts

@@ -121,4 +121,5 @@ /**
   let p = jubjub.Point.fromBytes(h.digest());
-  // NOTE: cannot replace with isSmallOrder, returns Point*8
-  p = p.multiply(jubjub_CURVE.h);
+  // NOTE: cannot replace with isSmallOrder, we need the Point*8 result itself.
+  // clearCofactor (three doublings for h=8) is fine here: inputs are public.
+  p = p.clearCofactor();
   if (p.equals(jubjub.Point.ZERO)) throw new Error('Point has small order');
@@ -155,11 +156,11 @@ return p;
   const tag = concatBytes(m, Uint8Array.of(0));
-  const hashes = [];
+  // Return the first tag byte whose hash decodes to a non-small-order point; later candidates
+  // were never used, so there is no reason to compute them.
   for (let i = 0; i < 256; i++) {
     tag[tag.length - 1] = i;
     try {
-      hashes.push(jubjub_groupHash(tag, personalization));
+      return jubjub_groupHash(tag, personalization);
     } catch (e) {}
   }
-  if (!hashes.length) throw new Error('findGroupHash tag overflow');
-  return hashes[0];
+  throw new Error('findGroupHash tag overflow');
 }
@@ -166,0 +167,0 @@

src/nist.ts

 /**
- * Internal module for NIST P256, P384, P521 curves.
- * Do not use for now.
+ * NIST P256, P384, P521 curves.
+ * https://www.secg.org/sec2-v2.pdf, https://neuromancer.sk/std/nist/P-256
  * @module
@@ -9,7 +9,6 @@ */
 import { createFROST, type FROST } from './abstract/frost.ts';
-import { createHasher, type H2CHasher } from './abstract/hash-to-curve.ts';
+import { createHasher, mapToCurveSimpleSWU, type H2CHasher } from './abstract/hash-to-curve.ts';
 import { createOPRF, type OPRF } from './abstract/oprf.ts';
 import {
   ecdsa,
-  mapToCurveSimpleSWU,
   weierstrass,
@@ -106,5 +105,7 @@ type ECDSA,
  * const { secretKey, publicKey } = p256.keygen();
- * // const publicKey = p256.getPublicKey(secretKey);
+ * const recovered = p256.getPublicKey(secretKey);
+ * const peer = p256.keygen();
+ * const shared = p256.getSharedSecret(secretKey, peer.publicKey);
  * const msg = new TextEncoder().encode('hello noble');
- * const sig = p256.sign(msg, secretKey);
+ * const sig = p256.sign(msg, secretKey, { lowS: true, prehash: true });
  * const isValid = p256.verify(sig, msg, publicKey);
@@ -130,3 +131,3 @@ * // const sigKeccak = p256.sign(keccak256(msg), secretKey, { prehash: false });
       B: p256_CURVE.b,
-      Z: p256_Point.Fp.create(BigInt('-10')),
+      Z: p256_Point.Fp.neg(BigInt(10)),
     }),
@@ -185,3 +186,2 @@ {
 
-// NIST P384
 const p384_Point = /* @__PURE__ */ weierstrass(p384_CURVE);
@@ -216,3 +216,3 @@ /**
       B: p384_CURVE.b,
-      Z: p384_Point.Fp.create(BigInt('-12')),
+      Z: p384_Point.Fp.neg(BigInt(12)),
     }),
@@ -268,2 +268,4 @@ {
 // default exact-66-byte scalar field path.
+// A dedicated MersenneField primitive would allow speed-ups here: +40% getPublicKey, +23% sign,
+// +53% verify, +53% getSharedSecret.
 const p521_Point = /* @__PURE__ */ weierstrass(p521_CURVE);
@@ -300,3 +302,3 @@ /**
       B: p521_CURVE.b,
-      Z: p521_Point.Fp.create(BigInt('-4')),
+      Z: p521_Point.Fp.neg(BigInt(4)),
     }),
@@ -303,0 +305,0 @@ {

src/secp256k1.ts

@@ -19,3 +19,8 @@ /**
 } from './abstract/frost.ts';
-import { createHasher, type H2CHasher, isogenyMap } from './abstract/hash-to-curve.ts';
+import {
+  createHasher,
+  type H2CHasher,
+  isogenyMap,
+  mapToCurveSimpleSWU,
+} from './abstract/hash-to-curve.ts';
 import { Field, mapHashToField, pow2 } from './abstract/modular.ts';
@@ -26,3 +31,2 @@ import {
   type EndomorphismOpts,
-  mapToCurveSimpleSWU,
   type WeierstrassPoint as PointType,
@@ -94,3 +98,3 @@ weierstrass,
 
-const Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
+const Fpk1 = /* @__PURE__ */ Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
 const Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
@@ -125,3 +129,3 @@ Fp: Fpk1,
 /** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */
-const TAGGED_HASH_PREFIXES: { [tag: string]: Uint8Array } = {};
+const TAGGED_HASH_PREFIXES: { [tag: string]: Uint8Array } = Object.create(null);
 // BIP-340 phrases tags as UTF-8, but all current standardized names here are 7-bit ASCII.
@@ -141,3 +145,5 @@ function taggedHash(tag: string, ...messages: TArg<Uint8Array[]>): TRet<Uint8Array> {
   point.toBytes(true).slice(1) as TRet<Uint8Array>;
-const hasEven = (y: bigint) => y % _2n === _0n;
+const affineXToBytes = ({ x }: { x: bigint }): TRet<Uint8Array> =>
+  Fpk1.toBytes(x) as TRet<Uint8Array>;
+const hasEven = (y: bigint) => !Fpk1.isOdd(y);
 
@@ -147,6 +153,7 @@ // Calculate point, scalar and bytes
   const { Fn, BASE } = Pointk1;
-  const d_ = Fn.fromBytes(priv);
+  const d_ = Fn.fromBytes(abytes(priv, 32, 'secretKey'));
   const p = BASE.multiply(d_); // P = d'⋅G; 0 < d' < n check is done inside
-  const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);
-  return { scalar, bytes: pointToBytes(p) };
+  const affine = p.toAffine();
+  const scalar = hasEven(affine.y) ? d_ : Fn.neg(d_);
+  return { scalar, bytes: affineXToBytes(affine) };
 }
@@ -160,4 +167,4 @@ /**
   if (!Fp.isValidNot0(x)) throw new Error('invalid x: Fail if x ≥ p');
-  const xx = Fp.create(x * x);
-  const c = Fp.create(xx * x + BigInt(7)); // Let c = x³ + 7 mod p.
+  const xx = Fp.sqr(x);
+  const c = Fp.add(Fp.mulN(xx, x), BigInt(7)); // Let c = x³ + 7 mod p.
   let y = Fp.sqrt(c); // Let y = c^(p+1)/4 mod p. Same as sqrt().
@@ -207,6 +214,7 @@ // Return the unique point P such that x(P) = x and
   // BIP-340: "Let k' = int(rand) mod n. Fail if k' = 0. Let R = k'⋅G."
-  if (k_ === 0n) throw new Error('sign failed: k is zero');
+  if (k_ === _0n) throw new Error('sign failed: k is zero');
   const p = BASE.multiply(k_); // Rejects zero; only the raw nonce hash needs reduction.
-  const k = hasEven(p.y) ? k_ : Fn.neg(k_);
-  const rx = pointToBytes(p);
+  const affine = p.toAffine();
+  const k = hasEven(affine.y) ? k_ : Fn.neg(k_);
+  const rx = affineXToBytes(affine);
   const e = challenge(rx, px, m); // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.
@@ -236,3 +244,4 @@ const sig = new Uint8Array(64); // Let sig = bytes(R) || bytes((k + ed) mod n).
     const P = lift_x(num(pub)); // P = lift_x(int(pk)); fail if that fails
-    const r = num(sig.subarray(0, 32)); // Let r = int(sig[0:32]); fail if r ≥ p.
+    const rBytes = sig.subarray(0, 32);
+    const r = num(rBytes); // Let r = int(sig[0:32]); fail if r ≥ p.
     if (!Fp.isValidNot0(r)) return false;
@@ -246,8 +255,8 @@ const s = num(sig.subarray(32, 64)); // Let s = int(sig[32:64]); fail if s ≥ n.
     // int(challenge(bytes(r) || bytes(P) || m)) % n
-    const e = challenge(Fn.toBytes(r), pointToBytes(P), m);
+    const e = challenge(rBytes, pointToBytes(P), m);
     // R = s⋅G - e⋅P, where -eP == (n-e)P
-    const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));
+    const R = BASE.mulAddUnsafe(s, P, Fn.neg(e)); // s⋅G + (-e)⋅P, joint Strauss–Shamir
     const { x, y } = R.toAffine();
     // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.
-    if (R.is0() || !hasEven(y) || x !== r) return false;
+    if (R.is0() || !hasEven(y) || !Fp.eql(x, r)) return false;
     return true;
@@ -259,3 +268,7 @@ } catch (error) {
 
-export const __TEST: { lift_x: typeof lift_x } = /* @__PURE__ */ Object.freeze({ lift_x });
+export const __TEST: {
+  lift_x: typeof lift_x;
+  frostTweakPublic: typeof frostTweakPublic;
+  frostTweakSecret: typeof frostTweakSecret;
+} = /* @__PURE__ */ Object.freeze({ lift_x, frostTweakPublic, frostTweakSecret });
 
@@ -328,3 +341,3 @@ /** Schnorr-specific secp256k1 API from BIP340. */
     seed = seed === undefined ? randomBytes(seedLength) : seed;
-    return mapHashToField(seed, secp256k1_CURVE.n);
+    return mapHashToField(abytes(seed, seedLength, 'seed'), secp256k1_CURVE.n);
   };
@@ -483,4 +496,7 @@ return Object.freeze({
 }
-function frostNoncesToEvenY(PK: PointType<bigint>, nonces: TArg<Nonces>): TRet<Nonces> {
-  if (hasEven(PK.y)) return nonces as TRet<Nonces>;
+function frostNoncesToEvenY(
+  groupCommitment: PointType<bigint>,
+  nonces: TArg<Nonces>
+): TRet<Nonces> {
+  if (hasEven(groupCommitment.y)) return nonces as TRet<Nonces>;
   const Fn = Pointk1.Fn;
@@ -515,2 +531,5 @@ return {
   const t = tweak(Pointk1.fromBytes(PKPackage.commitments[0]), merkleRoot);
+  // Disabled TapTweak (t=0): return the even-Y-normalized package as-is. multiply() rejects
+  // zero scalars, and adding [0]G would be a no-op anyway.
+  if (t === _0n) return PKPackage;
   const tp = Pointk1.BASE.multiply(t);
@@ -517,0 +536,0 @@ const commitments = PKPackage.commitments.map((c, i) =>

src/utils.ts

@@ -120,3 +120,28 @@ /**
   : never;
+
 /**
+ * Validates that a value is an array, optionally validating each element.
+ * @param item - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @param inner - Optional per-element validator, called with the element and its label.
+ * @returns The validated array.
+ * @example
+ * Validate an array of points before batch processing.
+ *
+ * ```ts
+ * aarray([1n, 2n], 'scalars');
+ * ```
+ */
+export function aarray<T>(
+  item: unknown,
+  title: string,
+  inner: (elm: T, title: string) => void = () => {}
+): T[] {
+  if (!Array.isArray(item))
+    throw new TypeError(`"${title}" expected array, got type=${typeof item}`);
+  for (let i = 0; i < item.length; i++) inner(item[i], `${title}[${i}]`);
+  return item;
+}
+
+/**
  * Validates that a value is a byte array.
@@ -140,2 +165,3 @@ * @param value - Value to validate.
  * @param title - Optional field name.
+ * @returns The validated number.
  * @example
@@ -150,2 +176,62 @@ * Validate a numeric length before allocating buffers.
 /**
+ * Asserts something is a string.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated string.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate a label string.
+ *
+ * ```ts
+ * astring('example', 'label');
+ * ```
+ */
+export function astring(value: unknown, title: string = ''): string {
+  if (typeof value !== 'string') {
+    const prefix = title && `"${title}" `;
+    throw new TypeError(prefix + 'expected string, got type=' + typeof value);
+  }
+  return value;
+}
+/**
+ * Asserts something is a plain object-ish value, not null or array.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated object.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate an options object before checking fields.
+ *
+ * ```ts
+ * aobject({ flag: true });
+ * ```
+ */
+export function aobject<T extends Record<string, any>>(value: T, title: string = 'object'): T {
+  if (value === null || typeof value !== 'object' || Array.isArray(value))
+    throw new TypeError(
+      title === 'object'
+        ? 'expected valid options object'
+        : `"${title}" expected object, got type=${typeof value}`
+    );
+  return value;
+}
+/**
+ * Asserts something is a function.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated function.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate a required method before calling it.
+ *
+ * ```ts
+ * afunction(() => true, 'predicate');
+ * ```
+ */
+export function afunction<T extends (...args: any[]) => any>(value: T, title: string): T {
+  if (typeof value !== 'function')
+    throw new TypeError(`"${title}" is invalid: expected function, got ${typeof value}`);
+  return value;
+}
+/**
  * Encodes bytes as lowercase hex.
@@ -241,2 +327,6 @@ * @param bytes - Bytes to encode.
 export type HmacFn = (key: TArg<Uint8Array>, message: TArg<Uint8Array>) => TRet<Uint8Array>;
+// Shared error-message prefix builder. Only called on throw paths, so assert
+// success paths never pay for the string concatenation.
+const atitle = (title: string): string => (title ? `"${title}" ` : '');
+
 /**
@@ -256,6 +346,4 @@ * Validates that a flag is boolean.
 export function abool(value: boolean, title: string = ''): boolean {
-  if (typeof value !== 'boolean') {
-    const prefix = title && `"${title}" `;
-    throw new TypeError(prefix + 'expected boolean, got type=' + typeof value);
-  }
+  if (typeof value !== 'boolean')
+    throw new TypeError(atitle(title) + 'expected boolean, got type=' + typeof value);
   return value;
@@ -383,2 +471,3 @@ }
  * @throws On wrong argument ranges or values. {@link RangeError}
+ * @throws If a documented runtime validation or state check fails. {@link Error}
  * @example
@@ -393,8 +482,9 @@ * Serialize a scalar into a 32-byte field element.
   anumber_(len);
-  if (len === 0) throw new RangeError('zero length');
+  if (len === 0) throw new Error('zero output length is invalid');
   n = abignumber(n);
+  const expectedLen = len * 2;
   const hex = n.toString(16);
   // Detect overflow before hex parsing so oversized values don't leak the shared odd-hex error.
-  if (hex.length > len * 2) throw new RangeError('number too large');
-  return hexToBytes_(hex.padStart(len * 2, '0')) as TRet<Uint8Array>;
+  if (hex.length > expectedLen) throw new RangeError('number is too large');
+  return hexToBytes_(hex.padStart(expectedLen, '0')) as TRet<Uint8Array>;
 }
@@ -407,2 +497,3 @@ /**
  * @throws On wrong argument ranges or values. {@link RangeError}
+ * @throws If a documented runtime validation or state check fails. {@link Error}
  * @example
@@ -502,4 +593,16 @@ * Serialize a scalar for little-endian protocols.
 
-// Historical name: this accepts non-negative bigints, including zero.
-const isPosBig = (n: bigint) => typeof n === 'bigint' && _0n <= n;
+/**
+ * Checks whether n is non-negative bigint. Historical name.
+ * @param n - candidate value
+ * @returns `true` when the value is bigint and 0 or larger
+ * @example
+ * Check a candidate scalar before range validation.
+ *
+ * ```ts
+ * isPosBig(2n);
+ * ```
+ */
+export function isPosBig(n: bigint): boolean {
+  return typeof n === 'bigint' && _0n <= n;
+}
 
@@ -569,5 +672,4 @@ /**
   if (n < _0n) throw new Error('expected non-negative bigint, got ' + n);
-  let len;
-  for (len = 0; n > _0n; n >>= _1n, len += 1);
-  return len;
+  // Native radix conversion beats a shift loop at every size, and the loop is quadratic in bits.
+  return n === _0n ? 0 : n.toString(2).length;
 }
@@ -592,2 +694,4 @@
 export function bitGet(n: bigint, pos: number): bigint {
+  if (typeof n !== 'bigint') throw new TypeError('"n" expected bigint, got type=' + typeof n);
+  asafenumber(pos, 'pos');
   return (n >> BigInt(pos)) & _1n;
@@ -611,2 +715,5 @@ }
 export function bitSet(n: bigint, pos: number, value: boolean): bigint {
+  if (typeof n !== 'bigint') throw new TypeError('"n" expected bigint, got type=' + typeof n);
+  asafenumber(pos, 'pos');
+  abool(value, 'value');
   const mask = _1n << BigInt(pos);
@@ -630,3 +737,6 @@ // Clearing needs AND-not here; OR with zero leaves an already-set bit untouched.
  */
-export const bitMask = (n: number): bigint => (_1n << BigInt(n)) - _1n;
+export const bitMask = (n: number): bigint => {
+  asafenumber(n, 'n');
+  return (_1n << BigInt(n)) - _1n;
+};
 
@@ -652,3 +762,4 @@ // DRBG
  * import { sha256 } from '@noble/hashes/sha2.js';
- * const drbg = createHmacDrbg(32, 32, (key, msg) => hmac(sha256, key, msg));
+ * const hmacFn = (key: Uint8Array, msg: Uint8Array) => hmac(sha256, key, msg);
+ * const drbg = createHmacDrbg(32, 32, hmacFn);
  * const seed = new Uint8Array(32);
@@ -723,5 +834,8 @@ * drbg(seed, (bytes) => bytes);
  * richer option bags or runtime objects.
+ * This walks field schemas and formats detailed errors, so avoid it on hot paths; use direct
+ * one-line guards such as `aobject()`, `afunction()`, `abool()`, or `asafenumber()` instead.
  * @param object - Object to validate.
  * @param fields - Required field types.
  * @param optFields - Optional field types.
+ * @param title - Object label included in thrown errors.
  * @throws On wrong argument types. {@link TypeError}
@@ -738,19 +852,27 @@ * @example
   fields: Record<string, string> = {},
-  optFields: Record<string, string> = {}
+  optFields: Record<string, string> = {},
+  title = 'object'
 ): void {
-  if (Object.prototype.toString.call(object) !== '[object Object]')
-    throw new TypeError('expected valid options object');
+  aobject(object, title);
+  aobject(fields, 'fields');
+  aobject(optFields, 'optFields');
   type Item = keyof typeof object;
   function checkField(fieldName: Item, expectedType: string, isOpt: boolean) {
-    // Config/data fields must be explicit own properties, but runtime objects such as Field
-    // instances intentionally satisfy required method slots via their shared prototype.
-    if (!isOpt && expectedType !== 'function' && !Object.hasOwn(object, fieldName))
-      throw new TypeError(`param "${fieldName}" is invalid: expected own property`);
+    const label =
+      title === 'object' ? `param "${String(fieldName)}"` : `"${title}.${String(fieldName)}"`;
+    // Config fields must be explicit own properties. Optional inherited values are rejected too
+    // because callers keep reading the same options object after validation.
     const val = object[fieldName];
+    // Runtime objects such as Field instances intentionally satisfy required method slots
+    // via their shared prototype.
+    if (
+      !Object.hasOwn(object, fieldName) &&
+      (isOpt ? val !== undefined : expectedType !== 'function')
+    ) {
+      throw new TypeError(`${label} is invalid: expected own property`);
+    }
     if (isOpt && val === undefined) return;
     const current = typeof val;
     if (current !== expectedType || val === null)
-      throw new TypeError(
-        `param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`
-      );
+      throw new TypeError(`${label} is invalid: expected ${expectedType}, got ${current}`);
   }
@@ -757,0 +879,0 @@ const iter = (f: typeof fields, isOpt: boolean) =>

src/webcrypto.ts

@@ -44,3 +44,3 @@ /**
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import type { TArg, TRet } from './utils.ts';
+import { abytes, validateObject, type TArg, type TRet } from './utils.ts';
 
@@ -166,3 +166,3 @@ /** Raw type */
         // This is the best one can do. JWK can't be used: it contains public key component inside.
-        const k = key as Uint8Array;
+        const k = abytes(key as Uint8Array, keyLen, 'secretKey');
         const head = hexToBytesLocal(pkcs8header);
@@ -217,2 +217,3 @@ const all = new Uint8Array(head.length + k.length);
   ): Promise<TRet<Key>> {
+    validateObject(opts, {}, { formatSec: 'string', formatPub: 'string' }, 'opts');
     const fsec = opts.formatSec ?? dfsec;
@@ -286,2 +287,3 @@ const fpub = opts.formatPub ?? dfpub;
     ): Promise<TRet<Uint8Array>> {
+      validateObject(opts, {}, { formatSec: 'string', formatPub: 'string' }, 'opts');
       const key = await keys.priv.import(secretKey, opts.formatSec ?? dfsec);
@@ -297,2 +299,3 @@ const sig = await getSubtle().sign(algo, key, msgHash);
     ): Promise<boolean> {
+      validateObject(opts, {}, { formatSec: 'string', formatPub: 'string' }, 'opts');
       const key = await keys.pub.import(publicKey, opts.formatPub ?? dfpub);
@@ -317,2 +320,3 @@ return await getSubtle().verify(algo, key, signature, msgHash);
     ): Promise<TRet<Uint8Array>> {
+      validateObject(opts, {}, { formatSec: 'string', formatPub: 'string' }, 'opts');
       // if (_isCompressed !== true) throw new Error('WebCrypto only supports compressed keys');
@@ -319,0 +323,0 @@ const secKey = await keys.priv.import(

utils.d.ts

@@ -48,2 +48,16 @@ /**
 /**
+ * Validates that a value is an array, optionally validating each element.
+ * @param item - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @param inner - Optional per-element validator, called with the element and its label.
+ * @returns The validated array.
+ * @example
+ * Validate an array of points before batch processing.
+ *
+ * ```ts
+ * aarray([1n, 2n], 'scalars');
+ * ```
+ */
+export declare function aarray<T>(item: unknown, title: string, inner?: (elm: T, title: string) => void): T[];
+/**
  * Validates that a value is a byte array.
@@ -66,2 +80,3 @@ * @param value - Value to validate.
  * @param title - Optional field name.
+ * @returns The validated number.
  * @example
@@ -76,2 +91,44 @@ * Validate a numeric length before allocating buffers.
 /**
+ * Asserts something is a string.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated string.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate a label string.
+ *
+ * ```ts
+ * astring('example', 'label');
+ * ```
+ */
+export declare function astring(value: unknown, title?: string): string;
+/**
+ * Asserts something is a plain object-ish value, not null or array.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated object.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate an options object before checking fields.
+ *
+ * ```ts
+ * aobject({ flag: true });
+ * ```
+ */
+export declare function aobject<T extends Record<string, any>>(value: T, title?: string): T;
+/**
+ * Asserts something is a function.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated function.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate a required method before calling it.
+ *
+ * ```ts
+ * afunction(() => true, 'predicate');
+ * ```
+ */
+export declare function afunction<T extends (...args: any[]) => any>(value: T, title: string): T;
+/**
  * Encodes bytes as lowercase hex.
@@ -267,2 +324,3 @@ * @param bytes - Bytes to encode.
  * @throws On wrong argument ranges or values. {@link RangeError}
+ * @throws If a documented runtime validation or state check fails. {@link Error}
  * @example
@@ -282,2 +340,3 @@ * Serialize a scalar into a 32-byte field element.
  * @throws On wrong argument ranges or values. {@link RangeError}
+ * @throws If a documented runtime validation or state check fails. {@link Error}
  * @example
@@ -346,2 +405,14 @@ * Serialize a scalar for little-endian protocols.
 /**
+ * Checks whether n is non-negative bigint. Historical name.
+ * @param n - candidate value
+ * @returns `true` when the value is bigint and 0 or larger
+ * @example
+ * Check a candidate scalar before range validation.
+ *
+ * ```ts
+ * isPosBig(2n);
+ * ```
+ */
+export declare function isPosBig(n: bigint): boolean;
+/**
  * Checks whether a bigint lies inside a half-open range.
@@ -455,3 +526,4 @@ * @param n - Candidate value.
  * import { sha256 } from '@noble/hashes/sha2.js';
- * const drbg = createHmacDrbg(32, 32, (key, msg) => hmac(sha256, key, msg));
+ * const hmacFn = (key: Uint8Array, msg: Uint8Array) => hmac(sha256, key, msg);
+ * const drbg = createHmacDrbg(32, 32, hmacFn);
  * const seed = new Uint8Array(32);
@@ -466,5 +538,8 @@ * drbg(seed, (bytes) => bytes);
  * richer option bags or runtime objects.
+ * This walks field schemas and formats detailed errors, so avoid it on hot paths; use direct
+ * one-line guards such as `aobject()`, `afunction()`, `abool()`, or `asafenumber()` instead.
  * @param object - Object to validate.
  * @param fields - Required field types.
  * @param optFields - Optional field types.
+ * @param title - Object label included in thrown errors.
  * @throws On wrong argument types. {@link TypeError}
@@ -478,3 +553,3 @@ * @example
  */
-export declare function validateObject(object: Record<string, any>, fields?: Record<string, string>, optFields?: Record<string, string>): void;
+export declare function validateObject(object: Record<string, any>, fields?: Record<string, string>, optFields?: Record<string, string>, title?: string): void;
 /**
@@ -545,2 +620,1 @@ * Throws not implemented error.
 export {};
-//# sourceMappingURL=utils.d.ts.map

utils.js

@@ -8,2 +8,22 @@ /**
 /**
+ * Validates that a value is an array, optionally validating each element.
+ * @param item - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @param inner - Optional per-element validator, called with the element and its label.
+ * @returns The validated array.
+ * @example
+ * Validate an array of points before batch processing.
+ *
+ * ```ts
+ * aarray([1n, 2n], 'scalars');
+ * ```
+ */
+export function aarray(item, title, inner = () => { }) {
+    if (!Array.isArray(item))
+        throw new TypeError(`"${title}" expected array, got type=${typeof item}`);
+    for (let i = 0; i < item.length; i++)
+        inner(item[i], `${title}[${i}]`);
+    return item;
+}
+/**
  * Validates that a value is a byte array.
@@ -26,2 +46,3 @@ * @param value - Value to validate.
  * @param title - Optional field name.
+ * @returns The validated number.
  * @example
@@ -36,2 +57,60 @@ * Validate a numeric length before allocating buffers.
 /**
+ * Asserts something is a string.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated string.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate a label string.
+ *
+ * ```ts
+ * astring('example', 'label');
+ * ```
+ */
+export function astring(value, title = '') {
+    if (typeof value !== 'string') {
+        const prefix = title && `"${title}" `;
+        throw new TypeError(prefix + 'expected string, got type=' + typeof value);
+    }
+    return value;
+}
+/**
+ * Asserts something is a plain object-ish value, not null or array.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated object.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate an options object before checking fields.
+ *
+ * ```ts
+ * aobject({ flag: true });
+ * ```
+ */
+export function aobject(value, title = 'object') {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new TypeError(title === 'object'
+            ? 'expected valid options object'
+            : `"${title}" expected object, got type=${typeof value}`);
+    return value;
+}
+/**
+ * Asserts something is a function.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated function.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate a required method before calling it.
+ *
+ * ```ts
+ * afunction(() => true, 'predicate');
+ * ```
+ */
+export function afunction(value, title) {
+    if (typeof value !== 'function')
+        throw new TypeError(`"${title}" is invalid: expected function, got ${typeof value}`);
+    return value;
+}
+/**
  * Encodes bytes as lowercase hex.
@@ -98,2 +177,5 @@ * @param bytes - Bytes to encode.
 const _1n = /* @__PURE__ */ BigInt(1);
+// Shared error-message prefix builder. Only called on throw paths, so assert
+// success paths never pay for the string concatenation.
+const atitle = (title) => (title ? `"${title}" ` : '');
 /**
@@ -113,6 +195,4 @@ * Validates that a flag is boolean.
 export function abool(value, title = '') {
-    if (typeof value !== 'boolean') {
-        const prefix = title && `"${title}" `;
-        throw new TypeError(prefix + 'expected boolean, got type=' + typeof value);
-    }
+    if (typeof value !== 'boolean')
+        throw new TypeError(atitle(title) + 'expected boolean, got type=' + typeof value);
     return value;
@@ -238,2 +318,3 @@ }
  * @throws On wrong argument ranges or values. {@link RangeError}
+ * @throws If a documented runtime validation or state check fails. {@link Error}
  * @example
@@ -249,9 +330,10 @@ * Serialize a scalar into a 32-byte field element.
     if (len === 0)
-        throw new RangeError('zero length');
+        throw new Error('zero output length is invalid');
     n = abignumber(n);
+    const expectedLen = len * 2;
     const hex = n.toString(16);
     // Detect overflow before hex parsing so oversized values don't leak the shared odd-hex error.
-    if (hex.length > len * 2)
-        throw new RangeError('number too large');
-    return hexToBytes_(hex.padStart(len * 2, '0'));
+    if (hex.length > expectedLen)
+        throw new RangeError('number is too large');
+    return hexToBytes_(hex.padStart(expectedLen, '0'));
 }
@@ -264,2 +346,3 @@ /**
  * @throws On wrong argument ranges or values. {@link RangeError}
+ * @throws If a documented runtime validation or state check fails. {@link Error}
  * @example
@@ -356,5 +439,17 @@ * Serialize a scalar for little-endian protocols.
 }
-// Historical name: this accepts non-negative bigints, including zero.
-const isPosBig = (n) => typeof n === 'bigint' && _0n <= n;
 /**
+ * Checks whether n is non-negative bigint. Historical name.
+ * @param n - candidate value
+ * @returns `true` when the value is bigint and 0 or larger
+ * @example
+ * Check a candidate scalar before range validation.
+ *
+ * ```ts
+ * isPosBig(2n);
+ * ```
+ */
+export function isPosBig(n) {
+    return typeof n === 'bigint' && _0n <= n;
+}
+/**
  * Checks whether a bigint lies inside a half-open range.
@@ -420,6 +515,4 @@ * @param n - Candidate value.
         throw new Error('expected non-negative bigint, got ' + n);
-    let len;
-    for (len = 0; n > _0n; n >>= _1n, len += 1)
-        ;
-    return len;
+    // Native radix conversion beats a shift loop at every size, and the loop is quadratic in bits.
+    return n === _0n ? 0 : n.toString(2).length;
 }
@@ -443,2 +536,5 @@ /**
 export function bitGet(n, pos) {
+    if (typeof n !== 'bigint')
+        throw new TypeError('"n" expected bigint, got type=' + typeof n);
+    asafenumber(pos, 'pos');
     return (n >> BigInt(pos)) & _1n;
@@ -461,2 +557,6 @@ }
 export function bitSet(n, pos, value) {
+    if (typeof n !== 'bigint')
+        throw new TypeError('"n" expected bigint, got type=' + typeof n);
+    asafenumber(pos, 'pos');
+    abool(value, 'value');
     const mask = _1n << BigInt(pos);
@@ -479,3 +579,6 @@ // Clearing needs AND-not here; OR with zero leaves an already-set bit untouched.
  */
-export const bitMask = (n) => (_1n << BigInt(n)) - _1n;
+export const bitMask = (n) => {
+    asafenumber(n, 'n');
+    return (_1n << BigInt(n)) - _1n;
+};
 /**
@@ -497,3 +600,4 @@ * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
  * import { sha256 } from '@noble/hashes/sha2.js';
- * const drbg = createHmacDrbg(32, 32, (key, msg) => hmac(sha256, key, msg));
+ * const hmacFn = (key: Uint8Array, msg: Uint8Array) => hmac(sha256, key, msg);
+ * const drbg = createHmacDrbg(32, 32, hmacFn);
  * const seed = new Uint8Array(32);
@@ -566,5 +670,8 @@ * drbg(seed, (bytes) => bytes);
  * richer option bags or runtime objects.
+ * This walks field schemas and formats detailed errors, so avoid it on hot paths; use direct
+ * one-line guards such as `aobject()`, `afunction()`, `abool()`, or `asafenumber()` instead.
  * @param object - Object to validate.
  * @param fields - Required field types.
  * @param optFields - Optional field types.
+ * @param title - Object label included in thrown errors.
  * @throws On wrong argument types. {@link TypeError}
@@ -578,11 +685,17 @@ * @example
  */
-export function validateObject(object, fields = {}, optFields = {}) {
-    if (Object.prototype.toString.call(object) !== '[object Object]')
-        throw new TypeError('expected valid options object');
+export function validateObject(object, fields = {}, optFields = {}, title = 'object') {
+    aobject(object, title);
+    aobject(fields, 'fields');
+    aobject(optFields, 'optFields');
     function checkField(fieldName, expectedType, isOpt) {
-        // Config/data fields must be explicit own properties, but runtime objects such as Field
-        // instances intentionally satisfy required method slots via their shared prototype.
-        if (!isOpt && expectedType !== 'function' && !Object.hasOwn(object, fieldName))
-            throw new TypeError(`param "${fieldName}" is invalid: expected own property`);
+        const label = title === 'object' ? `param "${String(fieldName)}"` : `"${title}.${String(fieldName)}"`;
+        // Config fields must be explicit own properties. Optional inherited values are rejected too
+        // because callers keep reading the same options object after validation.
         const val = object[fieldName];
+        // Runtime objects such as Field instances intentionally satisfy required method slots
+        // via their shared prototype.
+        if (!Object.hasOwn(object, fieldName) &&
+            (isOpt ? val !== undefined : expectedType !== 'function')) {
+            throw new TypeError(`${label} is invalid: expected own property`);
+        }
         if (isOpt && val === undefined)
@@ -592,3 +705,3 @@ return;
         if (current !== expectedType || val === null)
-            throw new TypeError(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+            throw new TypeError(`${label} is invalid: expected ${expectedType}, got ${current}`);
     }
@@ -615,2 +728,1 @@ const iter = (f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));
 };
-//# sourceMappingURL=utils.js.map

webcrypto.d.ts

@@ -44,3 +44,3 @@ /**
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import type { TArg, TRet } from './utils.ts';
+import { type TArg, type TRet } from './utils.ts';
 /** Raw type */
@@ -242,2 +242,1 @@ declare const TYPE_RAW = "raw";
 export {};
-//# sourceMappingURL=webcrypto.d.ts.map

webcrypto.js

@@ -0,1 +1,45 @@
+/**
+ * Friendly wrapper over elliptic curves from built-in WebCrypto. Experimental: API may change.
+
+# WebCrypto issues
+
+## No way to get public keys
+
+- Export of raw secret key is prohibited by spec:
+  - https://w3c.github.io/webcrypto/#ecdsa-operations-export-key
+    -> "If format is "raw":" -> "If the [[type]] internal slot of key is not "public",
+       then throw an InvalidAccessError."
+- Import of raw secret keys is prohibited by spec:
+  - https://w3c.github.io/webcrypto/#ecdsa-operations-import-key
+    -> "If format is "raw":" -> "If usages contains a value which is not "verify"
+       then throw a SyntaxError."
+- SPKI (Simple public-key infrastructure) is public-key-only
+- PKCS8 is secret-key-only
+- No way to get public key from secret key, but we convert to JWK and then
+  create it manually, since a JWK secret key includes both private and public
+  parts.
+- Noble supports generating keys for both sign, verify & getSharedSecret,
+  but JWK key includes usage, which forces us to patch it (non-JWK is ok)
+- We have import/export for 'raw', but it doesn't work in Firefox / Safari
+
+## Point encoding
+
+- Raw export of public points returns uncompressed points,
+  but this is implementation specific and not much we can do there.
+- `getSharedSecret` differs for p256, p384, p521:
+  Noble returns 33-byte output (y-parity + x coordinate),
+  while in WebCrypto returns 32-byte output (x coordinate).
+  This is intentional: noble keeps the full encoded shared point, and x-only
+  callers can slice it down themselves.
+- `getSharedSecret` identical for X25519, X448
+
+## Availability
+
+Node.js additionally supports ed448.
+There seems no reasonable way to check for availability, other than actually calling methods.
+
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import { abytes, validateObject } from "./utils.js";
 /** Raw type */
@@ -71,3 +115,3 @@ const TYPE_RAW = 'raw';
                 // This is the best one can do. JWK can't be used: it contains public key component inside.
-                const k = key;
+                const k = abytes(key, keyLen, 'secretKey');
                 const head = hexToBytesLocal(pkcs8header);
@@ -116,2 +160,3 @@ const all = new Uint8Array(head.length + k.length);
     async function getPublicKey(secretKey, opts = {}) {
+        validateObject(opts, {}, { formatSec: 'string', formatPub: 'string' }, 'opts');
         const fsec = opts.formatSec ?? dfsec;
@@ -174,2 +219,3 @@ const fpub = opts.formatPub ?? dfpub;
         async sign(msgHash, secretKey, opts = {}) {
+            validateObject(opts, {}, { formatSec: 'string', formatPub: 'string' }, 'opts');
             const key = await keys.priv.import(secretKey, opts.formatSec ?? dfsec);
@@ -180,2 +226,3 @@ const sig = await getSubtle().sign(algo, key, msgHash);
         async verify(signature, msgHash, publicKey, opts = {}) {
+            validateObject(opts, {}, { formatSec: 'string', formatPub: 'string' }, 'opts');
             const key = await keys.pub.import(publicKey, opts.formatPub ?? dfpub);
@@ -191,2 +238,3 @@ return await getSubtle().verify(algo, key, signature, msgHash);
         async getSharedSecret(secretKeyA, publicKeyB, opts = {}) {
+            validateObject(opts, {}, { formatSec: 'string', formatPub: 'string' }, 'opts');
             // if (_isCompressed !== true) throw new Error('WebCrypto only supports compressed keys');
@@ -368,2 +416,1 @@ const secKey = await keys.priv.import(secretKeyA, opts.formatSec === undefined ? dfsec : opts.formatSec);
 export const x448 = /* @__PURE__ */ wrapMontgomery('X448', 56, '3046020100300506032b656f043a0438');
-//# sourceMappingURL=webcrypto.js.map

abstract/bls.d.ts.map

-{"version":3,"file":"bls.d.ts","sourceRoot":"","sources":["../src/abstract/bls.ts"],"names":[],"mappings":"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"}

abstract/bls.js.map

-{"version":3,"file":"bls.js","sourceRoot":"","sources":["../src/abstract/bls.ts"],"names":[],"mappings":"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"}

abstract/curve.d.ts.map

-{"version":3,"file":"curve.d.ts","sourceRoot":"","sources":["../src/abstract/curve.ts"],"names":[],"mappings":"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"}

abstract/curve.js.map

-{"version":3,"file":"curve.js","sourceRoot":"","sources":["../src/abstract/curve.ts"],"names":[],"mappings":"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"}

abstract/edwards.d.ts.map

-{"version":3,"file":"edwards.d.ts","sourceRoot":"","sources":["../src/abstract/edwards.ts"],"names":[],"mappings":"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"}

abstract/edwards.js.map

-{"version":3,"file":"edwards.js","sourceRoot":"","sources":["../src/abstract/edwards.ts"],"names":[],"mappings":"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"}

abstract/fft.d.ts.map

-{"version":3,"file":"fft.d.ts","sourceRoot":"","sources":["../src/abstract/fft.ts"],"names":[],"mappings":"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"}

abstract/fft.js.map

-{"version":3,"file":"fft.js","sourceRoot":"","sources":["../src/abstract/fft.ts"],"names":[],"mappings":"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"}

abstract/frost.d.ts.map

-{"version":3,"file":"frost.d.ts","sourceRoot":"","sources":["../src/abstract/frost.ts"],"names":[],"mappings":"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"}

abstract/frost.js.map

-{"version":3,"file":"frost.js","sourceRoot":"","sources":["../src/abstract/frost.ts"],"names":[],"mappings":"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"}

abstract/hash-to-curve.d.ts.map

-{"version":3,"file":"hash-to-curve.d.ts","sourceRoot":"","sources":["../src/abstract/hash-to-curve.ts"],"names":[],"mappings":"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"}

abstract/hash-to-curve.js.map

-{"version":3,"file":"hash-to-curve.js","sourceRoot":"","sources":["../src/abstract/hash-to-curve.ts"],"names":[],"mappings":"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"}

abstract/modular.d.ts.map

-{"version":3,"file":"modular.d.ts","sourceRoot":"","sources":["../src/abstract/modular.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,sEAAsE;AACtE,OAAO,EAWL,KAAK,IAAI,EACT,KAAK,IAAI,EACV,MAAM,aAAa,CAAC;AAWrB;;;;;;;;;;;GAWG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIhD;AACD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAQrE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAmB7D;AA2DD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,EAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EAAC,CAiE5E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,EAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EAAC,CASrE;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,KAAG,OACzB,CAAC;AAEnC;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,IAAI,EAAE,OAAO,CAAC;IACd,yBAAyB;IACzB,IAAI,EAAE,CAAC,CAAC;IACR,+BAA+B;IAC/B,GAAG,EAAE,CAAC,CAAC;IAEP;;;;OAIG;IACH,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;IACtB;;;;;OAKG;IACH,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IAC7B;;;;OAIG;IACH,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IACzB;;;;;OAKG;IACH,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IACjC;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACf;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACf;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IAChB;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IAEf;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAC7B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACvB;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACvB;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;IAChC;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAC9B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;IAEhC;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACxB;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACxB;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;IACjC;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IAOhB;;;;OAIG;IACH,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAExB;;;;OAIG;IACH,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;IAC/B;;;;;;OAMG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC;IAC5B;;;;;;OAMG;IACH,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,cAAc,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC;IAE1D;;;;;;OAMG;IACH,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC;CACjC;AAUD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAoBxE;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAatE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,QAAQ,UAAQ,GAAG,CAAC,EAAE,CAkBtF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,CAAC,CAGxE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAWnE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAIhE;AAED,0DAA0D;AAC1D,MAAM,MAAM,OAAO,GAAG;IACpB,6BAA6B;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AACF;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAc/D;AAED,KAAK,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;AACxE,KAAK,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AACpC,KAAK,SAAS,GAAG,OAAO,CAAC;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC,CAAC;AA4JH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,SAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAElF;AAgBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAK3D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAK5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAO9D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAG3D;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,IAAI,CAAC,UAAU,CAAC,EACrB,UAAU,EAAE,MAAM,EAClB,IAAI,UAAQ,GACX,IAAI,CAAC,UAAU,CAAC,CAalB"}

abstract/modular.js.map

-{"version":3,"file":"modular.js","sourceRoot":"","sources":["../src/abstract/modular.ts"],"names":[],"mappings":"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"}

abstract/montgomery.d.ts.map

-{"version":3,"file":"montgomery.d.ts","sourceRoot":"","sources":["../src/abstract/montgomery.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,sEAAsE;AACtE,OAAO,EASL,KAAK,IAAI,EACT,KAAK,IAAI,EACV,MAAM,aAAa,CAAC;AACrB,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAO7D,qEAAqE;AACrE,MAAM,MAAM,cAAc,GAAG;IAC3B,2BAA2B;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,6BAA6B;IAC7B,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACxB;;;;OAIG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC;IACjE;;;;OAIG;IACH,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAClC;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC;CAC1D,CAAC;AAEF,gEAAgE;AAChE,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;OAKG;IACH,UAAU,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC;IAChF;;;;OAIG;IACH,cAAc,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC;IAC/D;;;;;;OAMG;IACH,eAAe,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC;IAClG;;;;OAIG;IACH,YAAY,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC;IAChE,iDAAiD;IACjD,KAAK,EAAE;QACL,4EAA4E;QAC5E,eAAe,EAAE,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC;KACzC,CAAC;IACF,yCAAyC;IACzC,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC1B,yCAAyC;IACzC,OAAO,EAAE,YAAY,CAAC;IACtB;;;;OAIG;IACH,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK;QACnC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAC5B,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;KAC7B,CAAC;CACH,CAAC;AAqBF;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CA0I/E"}

abstract/montgomery.js.map

-{"version":3,"file":"montgomery.js","sourceRoot":"","sources":["../src/abstract/montgomery.ts"],"names":[],"mappings":"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"}

abstract/oprf.d.ts.map

-{"version":3,"file":"oprf.d.ts","sourceRoot":"","sources":["../src/abstract/oprf.ts"],"names":[],"mappings":"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"}

abstract/oprf.js.map

-{"version":3,"file":"oprf.js","sourceRoot":"","sources":["../src/abstract/oprf.ts"],"names":[],"mappings":"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"}

abstract/poseidon.d.ts.map

-{"version":3,"file":"poseidon.d.ts","sourceRoot":"","sources":["../src/abstract/poseidon.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sEAAsE;AACtE,OAAO,EAAuC,KAAK,IAAI,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AACxF,OAAO,EAAwB,KAAK,MAAM,EAAiB,MAAM,cAAc,CAAC;AA2BhF,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IACnB,4CAA4C;IAC5C,CAAC,EAAE,MAAM,CAAC;IACV,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAkEF,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,GAAG;IAClD,mDAAmD;IACnD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,iBAAiB,GAAG;IAAE,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,EAAE,CAAA;CAAE,CAAC;AAIzE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,EAC7B,OAAO,GAAE,MAAU,GAClB,iBAAiB,CA4BnB;AAED,4EAA4E;AAC5E,MAAM,MAAM,YAAY,GAAG,iBAAiB,GAC1C,iBAAiB,GAAG;IAClB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEJ;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,GAAG,IAAI,CAC1D,QAAQ,CAAC;IACP,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B,cAAc,EAAE,MAAM,EAAE,EAAE,CAAC;IAC3B,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC,CACH,CAkEA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAgBlE;AAED;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IAC7B,4DAA4D;IAC5D,cAAc,EAAE,MAAM,EAAE,EAAE,CAAC;CAC5B,CAAC;AACF,kCAAkC;AAClC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,GAAG,UAAU,CAyC7D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,EAAE,CAAiB;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,WAAW,CAAQ;gBAEf,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU;IAgBhF,OAAO,CAAC,OAAO;IAKf,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAgB7B,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAiBhC,KAAK,IAAI,IAAI;IAKb,KAAK,IAAI,cAAc;CAOxB;AAED,8EAA8E;AAC9E,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,CAAC,GAAG;IACzD,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAaF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,MAAM,cAAc,CAAC,CAQzF"}

abstract/poseidon.js.map

-{"version":3,"file":"poseidon.js","sourceRoot":"","sources":["../src/abstract/poseidon.ts"],"names":[],"mappings":"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"}

abstract/tower.d.ts.map

-{"version":3,"file":"tower.d.ts","sourceRoot":"","sources":["../src/abstract/tower.ts"],"names":[],"mappings":"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"}

abstract/tower.js.map

-{"version":3,"file":"tower.js","sourceRoot":"","sources":["../src/abstract/tower.ts"],"names":[],"mappings":"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"}

abstract/weierstrass.d.ts.map

-{"version":3,"file":"weierstrass.d.ts","sourceRoot":"","sources":["../src/abstract/weierstrass.ts"],"names":[],"mappings":"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"}

abstract/weierstrass.js.map

-{"version":3,"file":"weierstrass.js","sourceRoot":"","sources":["../src/abstract/weierstrass.ts"],"names":[],"mappings":"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,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU;YAC/B,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU;YAC/B,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACnB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU;YAC/B,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACnB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU;YAC/B,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,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"}

bls12-381.d.ts.map

-{"version":3,"file":"bls12-381.d.ts","sourceRoot":"","sources":["src/bls12-381.ts"],"names":[],"mappings":"AAgFA,OAAO,EAAO,KAAK,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,EAAS,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAYL,KAAK,IAAI,EACV,MAAM,YAAY,CAAC;AA2DpB;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAEpB,CAAC;AA+Y3B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,EAAE,0BAOvB,CAAC"}

bls12-381.js.map

-{"version":3,"file":"bls12-381.js","sourceRoot":"","sources":["src/bls12-381.ts"],"names":[],"mappings":"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"}

bn254.d.ts.map

-{"version":3,"file":"bn254.d.ts","sourceRoot":"","sources":["src/bn254.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,sEAAsE;AACtE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EAEzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAS,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAI3D,OAAO,EAAU,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AA8B/C,0BAA0B;AAC1B,eAAO,MAAM,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CACU,CAAC;AA+DrD,eAAO,MAAM,eAAe,EAAE,mBAY7B,CAAC;AAyFF;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,KAAK,EAAE,YAKnB,CAAC"}

bn254.js.map

-{"version":3,"file":"bn254.js","sourceRoot":"","sources":["src/bn254.ts"],"names":[],"mappings":"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"}

ed25519.d.ts.map

-{"version":3,"file":"ed25519.d.ts","sourceRoot":"","sources":["src/ed25519.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAGL,iBAAiB,EACjB,KAAK,KAAK,EAGV,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,aAAa,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAML,KAAK,MAAM,EACZ,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EAAc,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAA6C,KAAK,IAAI,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAiH7F;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,OAAO,EAAE,KAA8B,CAAC;AACrD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,EAAE,KAAsD,CAAC;AAChF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,EAAE,KAAuE,CAAC;AAChG;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,EAAE,IAAI,CAAC,KAAK,CAa/B,CAAC;AAER;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,MAAM,EAAE,IAAI,CAAC,cAAc,CAYpC,CAAC;AAUL;;;GAGG;AAEH,wBAAgB,mCAAmC,CAAC,CAAC,EAAE,MAAM,GAAG;IAC9D,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CACnD,CA8CA;AA0BD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,gBAAgB,CAajD,CAAC;AA4DP;;;;;;;;GAQG;AACH,cAAM,eAAgB,SAAQ,iBAAiB,CAAC,eAAe,CAAC;IAI9D,MAAM,CAAC,IAAI,EAAE,eAAe,CACwC;IAEpE,MAAM,CAAC,IAAI,EAAE,eAAe,CACwC;IAEpE,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CACM;IAE/B,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CACM;gBAEnB,EAAE,EAAE,YAAY;IAI5B;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,EAAE,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,eAAe;IAI3D,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAIlD,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,YAAY,GAAG,eAAe;IAIjD,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,eAAe;IA4B1D;;;;OAIG;IACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe;IAI5C;;;OAGG;IACH,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC;IA4B3B;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO;IAWvC,GAAG,IAAI,OAAO;CAGf;AAMD,6CAA6C;AAC7C,eAAO,MAAM,YAAY,EAAE;IACzB,KAAK,EAAE,OAAO,eAAe,CAAC;CAC6B,CAAC;AAE9D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,aAAa,CAAC,OAAO,eAAe,CAiDpE,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,EAAE,IAAI,CAAC,IAAI,CAOlC,CAAC;AACR;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,EAAE,IAAI,CAAC,KAAK,CASpC,CAAC;AAER;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAAS,MAAM,EASpD,CAAC"}

ed25519.js.map

-{"version":3,"file":"ed25519.js","sourceRoot":"","sources":["src/ed25519.ts"],"names":[],"mappings":"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"}

ed448.d.ts.map

-{"version":3,"file":"ed448.d.ts","sourceRoot":"","sources":["src/ed448.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAGL,iBAAiB,EACjB,KAAK,KAAK,EAGV,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,aAAa,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAiD,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACnG,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EAAc,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAKL,KAAK,IAAI,EACT,KAAK,IAAI,EACV,MAAM,YAAY,CAAC;AAyJpB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,EAAE,KAA+B,CAAC;AAGpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,EAAE,KAAqD,CAAC;AAC5E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,EAAE,gBAAsD,CAAC;AAE1E;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,cAAc,CAYlC,CAAC;AAqFL;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,CAAC,gBAAgB,CAS9C,CAAC;AACR;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,EAAE,IAAI,CAAC,KAAK,CAa7B,CAAC;AAwER;;;;;;GAMG;AACH,cAAM,WAAY,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IAGtD,MAAM,CAAC,IAAI,EAAE,WAAW,CACoF;IAE5G,MAAM,CAAC,IAAI,EAAE,WAAW,CACsC;IAE9D,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CACS;IAElC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CACS;gBAEtB,EAAE,EAAE,YAAY;IAI5B;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,EAAE,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,WAAW;IAIvD,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAI9C,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,YAAY,GAAG,WAAW;IAI7C,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,WAAW;IA6BtD;;;;OAIG;IACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW;IAIxC;;;OAGG;IACH,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC;IAe3B;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;IAQnC,GAAG,IAAI,OAAO;CAGf;AAMD,yCAAyC;AACzC,eAAO,MAAM,QAAQ,EAAE;IACrB,KAAK,EAAE,OAAO,WAAW,CAAC;CAC6B,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,OAAO,WAAW,CAsC5D,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,EAAE,IAAI,CAAC,IAAI,CAO9B,CAAC;AAER;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAKlD,CAAC"}

ed448.js.map

-{"version":3,"file":"ed448.js","sourceRoot":"","sources":["src/ed448.ts"],"names":[],"mappings":"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"}

index.d.ts.map

-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":""}

index.js.map

-{"version":3,"file":"index.js","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAC"}

misc.d.ts.map

-{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["src/misc.ts"],"names":[],"mappings":"AAUA,OAAO,EAGL,KAAK,KAAK,EAEV,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAsB,KAAK,KAAK,EAAwB,MAAM,2BAA2B,CAAC;AACjG,OAAO,EAAgB,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAgBrD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,EAAE,KAAsE,CAAC;AAoB5F;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,EAAE,KACsB,CAAC;AAQhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,IAAI,CAAC,UAAU,CAAC,EACrB,eAAe,EAAE,IAAI,CAAC,UAAU,CAAC,GAChC,YAAY,CAUd;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,EACnB,eAAe,EAAE,IAAI,CAAC,UAAU,CAAC,GAChC,YAAY,CAcd;AAWD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,KACwB,CAAC;AAuBvD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,KACwB,CAAC;AAuBvD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,KACwB,CAAC"}

misc.js.map

-{"version":3,"file":"misc.js","sourceRoot":"","sources":["src/misc.ts"],"names":[],"mappings":"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"}

nist.d.ts.map

-{"version":3,"file":"nist.d.ts","sourceRoot":"","sources":["src/nist.ts"],"names":[],"mappings":"AAOA,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAgB,KAAK,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,EAAc,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAIL,KAAK,KAAK,EAEV,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AA4EvC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,EAAE,KAAiD,CAAC;AACrE;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAkB5D,CAAC;AACL;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,EAAE,IAAI,CAAC,IAAI,CAO1B,CAAC;AACR;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,EAAE,IAAI,CAAC,KAAK,CAM5B,CAAC;AAIR;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,EAAE,KAAiD,CAAC;AACrE;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAkB5D,CAAC;AACL;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,EAAE,IAAI,CAAC,IAAI,CAO1B,CAAC;AAmBR;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,IAAI,EAAE,KAAiD,CAAC;AACrE;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAkB5D,CAAC;AACL;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,EAAE,IAAI,CAAC,IAAI,CAO1B,CAAC"}

nist.js.map

-{"version":3,"file":"nist.js","sourceRoot":"","sources":["src/nist.ts"],"names":[],"mappings":"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"}

secp256k1.d.ts.map

-{"version":3,"file":"secp256k1.d.ts","sourceRoot":"","sources":["src/secp256k1.ts"],"names":[],"mappings":"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"}

secp256k1.js.map

-{"version":3,"file":"secp256k1.js","sourceRoot":"","sources":["src/secp256k1.ts"],"names":[],"mappings":"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"}

utils.d.ts.map

-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["src/utils.ts"],"names":[],"mappings":"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"}

utils.js.map

-{"version":3,"file":"utils.js","sourceRoot":"","sources":["src/utils.ts"],"names":[],"mappings":"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"}

webcrypto.d.ts.map

-{"version":3,"file":"webcrypto.d.ts","sourceRoot":"","sources":["src/webcrypto.ts"],"names":[],"mappings":"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"}

webcrypto.js.map

-{"version":3,"file":"webcrypto.js","sourceRoot":"","sources":["src/webcrypto.ts"],"names":[],"mappings":"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"}

New alerts

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Improved metrics

Lines of code

35977

9.86%

Number of lines in readme file

1152

1.95%

Worsened metrics

Total package byte prevSize

1585635

-15.41%

Number of package files

72

-36.28%

Number of low supply chain risk alerts

1

Infinity%

Dependency changes

• + Added

  @noble/hashes@2.3.0
  (transitive)

• - Removed

  @noble/hashes@2.2.0
  (transitive)

• Updated

  @noble/hashes@2.3.0