@babylonlabs-io/ts-sdk 0.72.1 → 0.74.0

package/dist/pegin-registration-client-6vLk2itL.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pegin-registration-client-6vLk2itL.cjs","sources":["../src/tbv/core/deposit-terms/commissionCeiling.ts","../../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/legacy.js","../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/crypto.js","../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js","../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_md.js","../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha2.js","../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/hmac.js","../../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/utils.js","../../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/modular.js","../../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/curve.js","../../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/weierstrass.js","../../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/_shortw_utils.js","../../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/secp256k1.js","../src/tbv/core/clients/eth/payout-script.ts","../src/tbv/core/clients/eth/pegin-transaction.ts","../src/tbv/core/clients/eth/protocol-params-validation.ts","../src/tbv/core/clients/eth/vault-registry-reader.ts","../src/tbv/core/clients/eth/pegin-registration-client.ts"],"sourcesContent":["/**\n * The depositor's commission ceiling (`maxAcceptableCommissionBps`) policy:\n * quoted VP commission + drift headroom, capped below the contract's\n * exclusive bound. Shared by the fresh path (`PeginManager`) and the\n * resume-rebuild path so both compute the same ceiling.\n *\n * @module deposit-terms/commissionCeiling\n */\n\n/*\n * Commission-check map (each guards a DIFFERENT boundary — do not consolidate):\n *  1. assertVpCommissionInProtocolRange (vault app, vaultPayoutSignatureService)\n *     — chain-read trust boundary; mirrors VPKeyRegistryLogic.sol bounds.\n *  2. capMaxAcceptableCommissionBps (here) — depositor quote → ceiling policy;\n *     mirrors PeginLogic.sol's strict > check via the +25bps headroom.\n *  3. buildDepositTerms range check — public-API precondition on the projection\n *     that mints the device-enforced commissionFee.\n *  4. payout.ts commission cap — the VP-built tx's output value vs bps at the\n *     signing site (CLAUDE.md Critical Path #3).\n *  5. envelope.ts dust/cross-field gates (ledger-vault-signer) — firmware-only\n *     constants, pre-device-I/O (Critical Path #7).\n */\n\nimport { MAX_VP_COMMISSION_BPS_EXCLUSIVE } from \"../primitives/psbt/constants\";\n\n/**\n * Headroom (in basis points) added to the current VP commission to compute\n * `maxAcceptableCommissionBps` at submit time. Lets the VP raise its\n * commission by up to this amount between read and submit without forcing\n * a re-quote. Capped by {@link MAX_ACCEPTABLE_COMMISSION_BPS_CAP}.\n *\n * Contract check is strict `>` (PeginLogic.sol `VaultProviderCommissionExceeded`\n * revert), so +25 allows up\n * to +25 bps of drift.\n */\nexport const COMMISSION_BPS_HEADROOM = 25;\n\n/**\n * Hard ceiling for `maxAcceptableCommissionBps`. The contract enforces\n * `commissionBps < 10000`, so any value at/above that is unreachable;\n * `9999` is the maximum useful cap.\n */\nexport const MAX_ACCEPTABLE_COMMISSION_BPS_CAP = 9999;\n\n/**\n * The commission ceiling submitted as registration calldata and mirrored\n * into `DepositTerms.commissionFee`: quoted + drift headroom, capped.\n * Single source for both consumers — feed it the SAME quoted bps at prepare\n * and register time so device-accept stays coextensive with contract-accept.\n */\nexport function capMaxAcceptableCommissionBps(bps: number): number {\n  // Validate the raw quote before headroom shifts its domain — a negative\n  // quote must throw here, not become a small \"legal\" ceiling.\n  // Reject an out-of-range quote outright — clamping it to 9999 would turn a\n  // bad read into a 99.99% ceiling, the exact failure the cap exists to stop.\n  if (\n    !Number.isInteger(bps) ||\n    bps < 0 ||\n    bps >= MAX_VP_COMMISSION_BPS_EXCLUSIVE\n  ) {\n    throw new Error(\n      `Quoted commissionBps must be an integer in ` +\n        `[0, ${MAX_VP_COMMISSION_BPS_EXCLUSIVE}), got ${bps}`,\n    );\n  }\n  return Math.min(\n    bps + COMMISSION_BPS_HEADROOM,\n    MAX_ACCEPTABLE_COMMISSION_BPS_CAP,\n  );\n}\n","/**\n\nSHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.\nDon't use them in a new protocol. What \"weak\" means:\n\n- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.\n- No practical pre-image attacks (only theoretical, 2^123.4)\n- HMAC seems kinda ok: https://www.rfc-editor.org/rfc/rfc6151\n * @module\n */\nimport { Chi, HashMD, Maj } from \"./_md.js\";\nimport { clean, createHasher, rotl } from \"./utils.js\";\n/** Initial SHA1 state */\nconst SHA1_IV = /* @__PURE__ */ Uint32Array.from([\n    0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0,\n]);\n// Reusable temporary buffer\nconst SHA1_W = /* @__PURE__ */ new Uint32Array(80);\n/** Internal SHA1 legacy hash class. */\nexport class _SHA1 extends HashMD {\n    A = SHA1_IV[0] | 0;\n    B = SHA1_IV[1] | 0;\n    C = SHA1_IV[2] | 0;\n    D = SHA1_IV[3] | 0;\n    E = SHA1_IV[4] | 0;\n    constructor() {\n        super(64, 20, 8, false);\n    }\n    get() {\n        const { A, B, C, D, E } = this;\n        return [A, B, C, D, E];\n    }\n    set(A, B, C, D, E) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n    }\n    process(view, offset) {\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA1_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 80; i++)\n            SHA1_W[i] = rotl(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);\n        // Compression function main loop, 80 rounds\n        let { A, B, C, D, E } = this;\n        for (let i = 0; i < 80; i++) {\n            let F, K;\n            if (i < 20) {\n                F = Chi(B, C, D);\n                K = 0x5a827999;\n            }\n            else if (i < 40) {\n                F = B ^ C ^ D;\n                K = 0x6ed9eba1;\n            }\n            else if (i < 60) {\n                F = Maj(B, C, D);\n                K = 0x8f1bbcdc;\n            }\n            else {\n                F = B ^ C ^ D;\n                K = 0xca62c1d6;\n            }\n            const T = (rotl(A, 5) + F + E + K + SHA1_W[i]) | 0;\n            E = D;\n            D = C;\n            C = rotl(B, 30);\n            B = A;\n            A = T;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        this.set(A, B, C, D, E);\n    }\n    roundClean() {\n        clean(SHA1_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\n/** SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */\nexport const sha1 = /* @__PURE__ */ createHasher(() => new _SHA1());\n/** Per-round constants */\nconst p32 = /* @__PURE__ */ Math.pow(2, 32);\nconst K = /* @__PURE__ */ Array.from({ length: 64 }, (_, i) => Math.floor(p32 * Math.abs(Math.sin(i + 1))));\n/** md5 initial state: same as sha1, but 4 u32 instead of 5. */\nconst MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);\n// Reusable temporary buffer\nconst MD5_W = /* @__PURE__ */ new Uint32Array(16);\n/** Internal MD5 legacy hash class. */\nexport class _MD5 extends HashMD {\n    A = MD5_IV[0] | 0;\n    B = MD5_IV[1] | 0;\n    C = MD5_IV[2] | 0;\n    D = MD5_IV[3] | 0;\n    constructor() {\n        super(64, 16, 8, true);\n    }\n    get() {\n        const { A, B, C, D } = this;\n        return [A, B, C, D];\n    }\n    set(A, B, C, D) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n    }\n    process(view, offset) {\n        for (let i = 0; i < 16; i++, offset += 4)\n            MD5_W[i] = view.getUint32(offset, true);\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D } = this;\n        for (let i = 0; i < 64; i++) {\n            let F, g, s;\n            if (i < 16) {\n                F = Chi(B, C, D);\n                g = i;\n                s = [7, 12, 17, 22];\n            }\n            else if (i < 32) {\n                F = Chi(D, B, C);\n                g = (5 * i + 1) % 16;\n                s = [5, 9, 14, 20];\n            }\n            else if (i < 48) {\n                F = B ^ C ^ D;\n                g = (3 * i + 5) % 16;\n                s = [4, 11, 16, 23];\n            }\n            else {\n                F = C ^ (B | ~D);\n                g = (7 * i) % 16;\n                s = [6, 10, 15, 21];\n            }\n            F = F + A + K[i] + MD5_W[g];\n            A = D;\n            D = C;\n            C = B;\n            B = B + rotl(F, s[i % 4]);\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        this.set(A, B, C, D);\n    }\n    roundClean() {\n        clean(MD5_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\n/**\n * MD5 (RFC 1321) legacy hash function. It was cryptographically broken.\n * MD5 architecture is similar to SHA1, with some differences:\n * - Reduced output length: 16 bytes (128 bit) instead of 20\n * - 64 rounds, instead of 80\n * - Little-endian: could be faster, but will require more code\n * - Non-linear index selection: huge speed-up for unroll\n * - Per round constants: more memory accesses, additional speed-up for unroll\n */\nexport const md5 = /* @__PURE__ */ createHasher(() => new _MD5());\n// RIPEMD-160\nconst Rho160 = /* @__PURE__ */ Uint8Array.from([\n    7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n]);\nconst Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();\nconst Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();\nconst idxLR = /* @__PURE__ */ (() => {\n    const L = [Id160];\n    const R = [Pi160];\n    const res = [L, R];\n    for (let i = 0; i < 4; i++)\n        for (let j of res)\n            j.push(j[i].map((k) => Rho160[k]));\n    return res;\n})();\nconst idxL = /* @__PURE__ */ (() => idxLR[0])();\nconst idxR = /* @__PURE__ */ (() => idxLR[1])();\n// const [idxL, idxR] = idxLR;\nconst shifts160 = /* @__PURE__ */ [\n    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],\n    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],\n    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],\n    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],\n    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],\n].map((i) => Uint8Array.from(i));\nconst shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));\nconst shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));\nconst Kl160 = /* @__PURE__ */ Uint32Array.from([\n    0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,\n]);\nconst Kr160 = /* @__PURE__ */ Uint32Array.from([\n    0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,\n]);\n// It's called f() in spec.\nfunction ripemd_f(group, x, y, z) {\n    if (group === 0)\n        return x ^ y ^ z;\n    if (group === 1)\n        return (x & y) | (~x & z);\n    if (group === 2)\n        return (x | ~y) ^ z;\n    if (group === 3)\n        return (x & z) | (y & ~z);\n    return x ^ (y | ~z);\n}\n// Reusable temporary buffer\nconst BUF_160 = /* @__PURE__ */ new Uint32Array(16);\nexport class _RIPEMD160 extends HashMD {\n    h0 = 0x67452301 | 0;\n    h1 = 0xefcdab89 | 0;\n    h2 = 0x98badcfe | 0;\n    h3 = 0x10325476 | 0;\n    h4 = 0xc3d2e1f0 | 0;\n    constructor() {\n        super(64, 20, 8, true);\n    }\n    get() {\n        const { h0, h1, h2, h3, h4 } = this;\n        return [h0, h1, h2, h3, h4];\n    }\n    set(h0, h1, h2, h3, h4) {\n        this.h0 = h0 | 0;\n        this.h1 = h1 | 0;\n        this.h2 = h2 | 0;\n        this.h3 = h3 | 0;\n        this.h4 = h4 | 0;\n    }\n    process(view, offset) {\n        for (let i = 0; i < 16; i++, offset += 4)\n            BUF_160[i] = view.getUint32(offset, true);\n        // prettier-ignore\n        let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;\n        // Instead of iterating 0 to 80, we split it into 5 groups\n        // And use the groups in constants, functions, etc. Much simpler\n        for (let group = 0; group < 5; group++) {\n            const rGroup = 4 - group;\n            const hbl = Kl160[group], hbr = Kr160[group]; // prettier-ignore\n            const rl = idxL[group], rr = idxR[group]; // prettier-ignore\n            const sl = shiftsL160[group], sr = shiftsR160[group]; // prettier-ignore\n            for (let i = 0; i < 16; i++) {\n                const tl = (rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el) | 0;\n                al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore\n            }\n            // 2 loops are 10% faster\n            for (let i = 0; i < 16; i++) {\n                const tr = (rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er) | 0;\n                ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr; // prettier-ignore\n            }\n        }\n        // Add the compressed chunk to the current hash value\n        this.set((this.h1 + cl + dr) | 0, (this.h2 + dl + er) | 0, (this.h3 + el + ar) | 0, (this.h4 + al + br) | 0, (this.h0 + bl + cr) | 0);\n    }\n    roundClean() {\n        clean(BUF_160);\n    }\n    destroy() {\n        this.destroyed = true;\n        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0);\n    }\n}\n/**\n * RIPEMD-160 - a legacy hash function from 1990s.\n * * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html\n * * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf\n */\nexport const ripemd160 = /* @__PURE__ */ createHasher(() => new _RIPEMD160());\n//# sourceMappingURL=legacy.js.map","export const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;\n//# sourceMappingURL=crypto.js.map","/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\n/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is positive integer. */\nexport function anumber(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error('positive integer expected, got ' + n);\n}\n/** Asserts something is Uint8Array. */\nexport function abytes(b, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Uint8Array expected');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\n/** Asserts something is hash */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.createHasher');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n}\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out, instance) {\n    abytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error('digestInto() expects output buffer of length at least ' + min);\n    }\n}\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/** The byte swap operation for uint32 */\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n);\n/** @deprecated */\nexport const byteSwapIfBE = swap8IfBE;\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n    return arr;\n}\nexport const swap32IfBE = isLE\n    ? (u) => u\n    : byteSwap32;\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = /* @__PURE__ */ (() => \n// @ts-ignore\ntypeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return bytes.toHex();\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return Uint8Array.fromHex(hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * Call of async fn will return Promise, which will be fullfiled only on\n * next scheduler queue processing step and this is exactly what we need.\n */\nexport const nextTick = async () => { };\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes) {\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/**\n * Helper for KDFs: consumes uint8array or string.\n * When string is passed, does utf8 decoding, using TextDecoder.\n */\nexport function kdfInputToBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/** Copies several Uint8Arrays into one. */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n        throw new Error('options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/** For runtime check if class implements interface */\nexport class Hash {\n}\n/** Wraps hash function, creating an interface on top of it */\nexport function createHasher(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function createOptHasher(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function createXOFer(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport const wrapConstructor = createHasher;\nexport const wrapConstructorWithOpts = createOptHasher;\nexport const wrapXOFConstructorWithOpts = createXOFer;\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    // Legacy Node.js compatibility\n    if (crypto && typeof crypto.randomBytes === 'function') {\n        return Uint8Array.from(crypto.randomBytes(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { Hash, abytes, aexists, aoutput, clean, createView, toBytes } from \"./utils.js\";\n/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */\nexport function setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\n/** Choice: a ? b : c */\nexport function Chi(a, b, c) {\n    return (a & b) ^ (~a & c);\n}\n/** Majority function, true if any two inputs is true. */\nexport function Maj(a, b, c) {\n    return (a & b) ^ (a & c) ^ (b & c);\n}\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n */\nexport class HashMD extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        data = toBytes(data);\n        abytes(data);\n        const { view, buffer, blockLen } = this;\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path: we have at least one block in input, cast it to view and process\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                continue;\n            }\n            buffer.set(data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            pos += take;\n            if (this.pos === blockLen) {\n                this.process(view, 0);\n                this.pos = 0;\n            }\n        }\n        this.length += data.length;\n        this.roundClean();\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        // Padding\n        // We can avoid allocation of buffer for padding completely if it\n        // was previously not allocated here. But it won't change performance.\n        const { buffer, view, blockLen, isLE } = this;\n        let { pos } = this;\n        // append the bit '1' to the message\n        buffer[pos++] = 0b10000000;\n        clean(this.buffer.subarray(pos));\n        // we have less than padOffset left in buffer, so we cannot put length in\n        // current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to || (to = new this.constructor());\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n}\n/**\n * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.\n * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.\n */\n/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */\nexport const SHA256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */\nexport const SHA224_IV = /* @__PURE__ */ Uint32Array.from([\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */\nexport const SHA384_IV = /* @__PURE__ */ Uint32Array.from([\n    0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,\n]);\n/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */\nexport const SHA512_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,\n]);\n//# sourceMappingURL=_md.js.map","/**\n * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.\n * SHA256 is the fastest hash implementable in JS, even faster than Blake3.\n * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and\n * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\nimport { clean, createHasher, rotr } from \"./utils.js\";\n/**\n * Round constants:\n * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)\n */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ Uint32Array.from([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n/** Reusable temporary buffer. \"W\" comes straight from spec. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nexport class SHA256 extends HashMD {\n    constructor(outputLen = 32) {\n        super(64, outputLen, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = SHA256_IV[0] | 0;\n        this.B = SHA256_IV[1] | 0;\n        this.C = SHA256_IV[2] | 0;\n        this.D = SHA256_IV[3] | 0;\n        this.E = SHA256_IV[4] | 0;\n        this.F = SHA256_IV[5] | 0;\n        this.G = SHA256_IV[6] | 0;\n        this.H = SHA256_IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        clean(SHA256_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\nexport class SHA224 extends SHA256 {\n    constructor() {\n        super(28);\n        this.A = SHA224_IV[0] | 0;\n        this.B = SHA224_IV[1] | 0;\n        this.C = SHA224_IV[2] | 0;\n        this.D = SHA224_IV[3] | 0;\n        this.E = SHA224_IV[4] | 0;\n        this.F = SHA224_IV[5] | 0;\n        this.G = SHA224_IV[6] | 0;\n        this.H = SHA224_IV[7] | 0;\n    }\n}\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n// Round contants\n// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409\n// prettier-ignore\nconst K512 = /* @__PURE__ */ (() => u64.split([\n    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\nconst SHA512_Kh = /* @__PURE__ */ (() => K512[0])();\nconst SHA512_Kl = /* @__PURE__ */ (() => K512[1])();\n// Reusable temporary buffers\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\nexport class SHA512 extends HashMD {\n    constructor(outputLen = 64) {\n        super(128, outputLen, 16, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = SHA512_IV[0] | 0;\n        this.Al = SHA512_IV[1] | 0;\n        this.Bh = SHA512_IV[2] | 0;\n        this.Bl = SHA512_IV[3] | 0;\n        this.Ch = SHA512_IV[4] | 0;\n        this.Cl = SHA512_IV[5] | 0;\n        this.Dh = SHA512_IV[6] | 0;\n        this.Dl = SHA512_IV[7] | 0;\n        this.Eh = SHA512_IV[8] | 0;\n        this.El = SHA512_IV[9] | 0;\n        this.Fh = SHA512_IV[10] | 0;\n        this.Fl = SHA512_IV[11] | 0;\n        this.Gh = SHA512_IV[12] | 0;\n        this.Gl = SHA512_IV[13] | 0;\n        this.Hh = SHA512_IV[14] | 0;\n        this.Hl = SHA512_IV[15] | 0;\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n            const W2h = SHA512_W_H[i - 2] | 0;\n            const W2l = SHA512_W_L[i - 2] | 0;\n            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n            SHA512_W_H[i] = SUMh | 0;\n            SHA512_W_L[i] = SUMl | 0;\n        }\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        // Compression function main loop, 80 rounds\n        for (let i = 0; i < 80; i++) {\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n            const CHIl = (El & Fl) ^ (~El & Gl);\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n            // prettier-ignore\n            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n            const T1l = T1ll | 0;\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n            Hh = Gh | 0;\n            Hl = Gl | 0;\n            Gh = Fh | 0;\n            Gl = Fl | 0;\n            Fh = Eh | 0;\n            Fl = El | 0;\n            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n            Dh = Ch | 0;\n            Dl = Cl | 0;\n            Ch = Bh | 0;\n            Cl = Bl | 0;\n            Bh = Ah | 0;\n            Bl = Al | 0;\n            const All = u64.add3L(T1l, sigma0l, MAJl);\n            Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n            Al = All | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n    }\n    roundClean() {\n        clean(SHA512_W_H, SHA512_W_L);\n    }\n    destroy() {\n        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\nexport class SHA384 extends SHA512 {\n    constructor() {\n        super(48);\n        this.Ah = SHA384_IV[0] | 0;\n        this.Al = SHA384_IV[1] | 0;\n        this.Bh = SHA384_IV[2] | 0;\n        this.Bl = SHA384_IV[3] | 0;\n        this.Ch = SHA384_IV[4] | 0;\n        this.Cl = SHA384_IV[5] | 0;\n        this.Dh = SHA384_IV[6] | 0;\n        this.Dl = SHA384_IV[7] | 0;\n        this.Eh = SHA384_IV[8] | 0;\n        this.El = SHA384_IV[9] | 0;\n        this.Fh = SHA384_IV[10] | 0;\n        this.Fl = SHA384_IV[11] | 0;\n        this.Gh = SHA384_IV[12] | 0;\n        this.Gl = SHA384_IV[13] | 0;\n        this.Hh = SHA384_IV[14] | 0;\n        this.Hl = SHA384_IV[15] | 0;\n    }\n}\n/**\n * Truncated SHA512/256 and SHA512/224.\n * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as \"intermediary\" IV of SHA512/t.\n * Then t hashes string to produce result IV.\n * See `test/misc/sha2-gen-iv.js`.\n */\n/** SHA512/224 IV */\nconst T224_IV = /* @__PURE__ */ Uint32Array.from([\n    0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,\n    0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,\n]);\n/** SHA512/256 IV */\nconst T256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,\n    0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,\n]);\nexport class SHA512_224 extends SHA512 {\n    constructor() {\n        super(28);\n        this.Ah = T224_IV[0] | 0;\n        this.Al = T224_IV[1] | 0;\n        this.Bh = T224_IV[2] | 0;\n        this.Bl = T224_IV[3] | 0;\n        this.Ch = T224_IV[4] | 0;\n        this.Cl = T224_IV[5] | 0;\n        this.Dh = T224_IV[6] | 0;\n        this.Dl = T224_IV[7] | 0;\n        this.Eh = T224_IV[8] | 0;\n        this.El = T224_IV[9] | 0;\n        this.Fh = T224_IV[10] | 0;\n        this.Fl = T224_IV[11] | 0;\n        this.Gh = T224_IV[12] | 0;\n        this.Gl = T224_IV[13] | 0;\n        this.Hh = T224_IV[14] | 0;\n        this.Hl = T224_IV[15] | 0;\n    }\n}\nexport class SHA512_256 extends SHA512 {\n    constructor() {\n        super(32);\n        this.Ah = T256_IV[0] | 0;\n        this.Al = T256_IV[1] | 0;\n        this.Bh = T256_IV[2] | 0;\n        this.Bl = T256_IV[3] | 0;\n        this.Ch = T256_IV[4] | 0;\n        this.Cl = T256_IV[5] | 0;\n        this.Dh = T256_IV[6] | 0;\n        this.Dl = T256_IV[7] | 0;\n        this.Eh = T256_IV[8] | 0;\n        this.El = T256_IV[9] | 0;\n        this.Fh = T256_IV[10] | 0;\n        this.Fl = T256_IV[11] | 0;\n        this.Gh = T256_IV[12] | 0;\n        this.Gl = T256_IV[13] | 0;\n        this.Hh = T256_IV[14] | 0;\n        this.Hl = T256_IV[15] | 0;\n    }\n}\n/**\n * SHA2-256 hash function from RFC 4634.\n *\n * It is the fastest JS hash, even faster than Blake3.\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new SHA224());\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new SHA512());\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new SHA384());\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_256 = /* @__PURE__ */ createHasher(() => new SHA512_256());\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_224 = /* @__PURE__ */ createHasher(() => new SHA512_224());\n//# sourceMappingURL=sha2.js.map","/**\n * HMAC: RFC2104 message authentication code.\n * @module\n */\nimport { abytes, aexists, ahash, clean, Hash, toBytes } from \"./utils.js\";\nexport class HMAC extends Hash {\n    constructor(hash, _key) {\n        super();\n        this.finished = false;\n        this.destroyed = false;\n        ahash(hash);\n        const key = toBytes(_key);\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new Error('Expected instance of class which extends utils.Hash');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        clean(pad);\n    }\n    update(buf) {\n        aexists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        abytes(out, this.outputLen);\n        this.finished = true;\n        this.iHash.digestInto(out);\n        this.oHash.update(out);\n        this.oHash.digestInto(out);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since key already in state and we don't know it.\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n * @example\n * import { hmac } from '@noble/hashes/hmac';\n * import { sha256 } from '@noble/hashes/sha2';\n * const mac1 = hmac(sha256, 'key', 'message');\n */\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n//# sourceMappingURL=hmac.js.map","/**\n * Hex, bytes and number utilities.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { abytes as abytes_, bytesToHex as bytesToHex_, concatBytes as concatBytes_, hexToBytes as hexToBytes_, isBytes as isBytes_, } from '@noble/hashes/utils.js';\nexport { abytes, anumber, bytesToHex, bytesToUtf8, concatBytes, hexToBytes, isBytes, randomBytes, utf8ToBytes, } from '@noble/hashes/utils.js';\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function abool(title, value) {\n    if (typeof value !== 'boolean')\n        throw new Error(title + ' boolean expected, got ' + value);\n}\n// tmp name until v2\nexport function _abool2(value, title = '') {\n    if (typeof value !== 'boolean') {\n        const prefix = title && `\"${title}\"`;\n        throw new Error(prefix + 'expected boolean, got type=' + typeof value);\n    }\n    return value;\n}\n// tmp name until v2\n/** Asserts something is Uint8Array. */\nexport function _abytes2(value, length, title = '') {\n    const bytes = isBytes_(value);\n    const len = value?.length;\n    const needsLen = length !== undefined;\n    if (!bytes || (needsLen && len !== length)) {\n        const prefix = title && `\"${title}\" `;\n        const ofLen = needsLen ? ` of length ${length}` : '';\n        const got = bytes ? `length=${len}` : `type=${typeof value}`;\n        throw new Error(prefix + 'expected Uint8Array' + ofLen + ', got ' + got);\n    }\n    return value;\n}\n// Used in weierstrass, der\nexport function numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? '0' + hex : hex;\n}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex_(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    abytes_(bytes);\n    return hexToNumber(bytesToHex_(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes_(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n, len) {\n    return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n    return hexToBytes_(numberToHexUnpadded(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'secret key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes_(hex);\n        }\n        catch (e) {\n            throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);\n        }\n    }\n    else if (isBytes_(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(title + ' must be hex string or Uint8Array');\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);\n    return res;\n}\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a, b) {\n    if (a.length !== b.length)\n        return false;\n    let diff = 0;\n    for (let i = 0; i < a.length; i++)\n        diff |= a[i] ^ b[i];\n    return diff === 0;\n}\n/**\n * Copies Uint8Array. We can't use u8a.slice(), because u8a can be Buffer,\n * and Buffer#slice creates mutable copy. Never use Buffers!\n */\nexport function copyBytes(bytes) {\n    return Uint8Array.from(bytes);\n}\n/**\n * Decodes 7-bit ASCII string to Uint8Array, throws on non-ascii symbols\n * Should be safe to use for things expected to be ASCII.\n * Returns exact same result as utf8ToBytes for ASCII or throws.\n */\nexport function asciiToBytes(ascii) {\n    return Uint8Array.from(ascii, (c, i) => {\n        const charCode = c.charCodeAt(0);\n        if (c.length !== 1 || charCode > 127) {\n            throw new Error(`string contains non-ASCII character \"${ascii[i]}\" with code ${charCode} at position ${i}`);\n        }\n        return charCode;\n    });\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\n// export const utf8ToBytes: typeof utf8ToBytes_ = utf8ToBytes_;\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'\n */\n// export const bytesToUtf8: typeof bytesToUtf8_ = bytesToUtf8_;\n// Is positive bigint\nconst isPosBig = (n) => typeof n === 'bigint' && _0n <= n;\nexport function inRange(n, min, max) {\n    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;\n}\n/**\n * Asserts min <= n < max. NOTE: It's < max and not <= max.\n * @example\n * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)\n */\nexport function aInRange(title, n, min, max) {\n    // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?\n    // consider P=256n, min=0n, max=P\n    // - a for min=0 would require -1:          `inRange('x', x, -1n, P)`\n    // - b would commonly require subtraction:  `inRange('x', x, 0n, P - 1n)`\n    // - our way is the cleanest:               `inRange('x', x, 0n, P)\n    if (!inRange(n, min, max))\n        throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n * TODO: merge with nLength in modular\n */\nexport function bitLen(n) {\n    let len;\n    for (len = 0; n > _0n; n >>= _1n, len += 1)\n        ;\n    return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n    return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport function bitSet(n, pos, value) {\n    return n | ((value ? _1n : _0n) << BigInt(pos));\n}\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_1n << BigInt(n)) - _1n;\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    const u8n = (len) => new Uint8Array(len); // creates Uint8Array\n    const u8of = (byte) => Uint8Array.of(byte); // another shortcut\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n(0)) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8of(0x00), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8of(0x01), seed); // k = hmac(k || v || 0x01 || seed)\n        v = h(); // v = hmac(k || v)\n    };\n    const gen = () => {\n        // HMAC-DRBG generate() function\n        if (i++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\n        let len = 0;\n        const out = [];\n        while (len < qByteLen) {\n            v = h();\n            const sl = v.slice();\n            out.push(sl);\n            len += v.length;\n        }\n        return concatBytes_(...out);\n    };\n    const genUntil = (seed, pred) => {\n        reset();\n        reseed(seed); // Steps D-G\n        let res = undefined; // Step H: grind until k is in [1..n-1]\n        while (!(res = pred(gen())))\n            reseed();\n        reset();\n        return res;\n    };\n    return genUntil;\n}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || isBytes_(val),\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error('invalid validator function');\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error('param ' + String(fieldName) + ' is invalid. Expected ' + type + ', got ' + val);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\nexport function isHash(val) {\n    return typeof val === 'function' && Number.isSafeInteger(val.outputLen);\n}\nexport function _validateObject(object, fields, optFields = {}) {\n    if (!object || typeof object !== 'object')\n        throw new Error('expected valid options object');\n    function checkField(fieldName, expectedType, isOpt) {\n        const val = object[fieldName];\n        if (isOpt && val === undefined)\n            return;\n        const current = typeof val;\n        if (current !== expectedType || val === null)\n            throw new Error(`param \"${fieldName}\" is invalid: expected ${expectedType}, got ${current}`);\n    }\n    Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));\n    Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));\n}\n/**\n * throws not implemented error\n */\nexport const notImplemented = () => {\n    throw new Error('not implemented');\n};\n/**\n * Memoizes (caches) computation result.\n * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.\n */\nexport function memoized(fn) {\n    const map = new WeakMap();\n    return (arg, ...args) => {\n        const val = map.get(arg);\n        if (val !== undefined)\n            return val;\n        const computed = fn(arg, ...args);\n        map.set(arg, computed);\n        return computed;\n    };\n}\n//# sourceMappingURL=utils.js.map","/**\n * Utils for modular division and fields.\n * Field over 11 is a finite (Galois) field is integer number operations `mod 11`.\n * There is no division: it is replaced by modular multiplicative inverse.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { _validateObject, anumber, bitMask, bytesToNumberBE, bytesToNumberLE, ensureBytes, numberToBytesBE, numberToBytesLE, } from \"../utils.js\";\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3);\n// prettier-ignore\nconst _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5), _7n = /* @__PURE__ */ BigInt(7);\n// prettier-ignore\nconst _8n = /* @__PURE__ */ BigInt(8), _9n = /* @__PURE__ */ BigInt(9), _16n = /* @__PURE__ */ BigInt(16);\n// Calculates a modulo b\nexport function mod(a, b) {\n    const result = a % b;\n    return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\nexport function pow(num, power, modulo) {\n    return FpPow(Field(modulo), num, power);\n}\n/** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */\nexport function pow2(x, power, modulo) {\n    let res = x;\n    while (power-- > _0n) {\n        res *= res;\n        res %= modulo;\n    }\n    return res;\n}\n/**\n * Inverses number over modulo.\n * Implemented using [Euclidean GCD](https://brilliant.org/wiki/extended-euclidean-algorithm/).\n */\nexport function invert(number, modulo) {\n    if (number === _0n)\n        throw new Error('invert: expected non-zero number');\n    if (modulo <= _0n)\n        throw new Error('invert: expected positive modulus, got ' + modulo);\n    // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n    let a = mod(number, modulo);\n    let b = modulo;\n    // prettier-ignore\n    let x = _0n, y = _1n, u = _1n, v = _0n;\n    while (a !== _0n) {\n        // JIT applies optimization if those two lines follow each other\n        const q = b / a;\n        const r = b % a;\n        const m = x - u * q;\n        const n = y - v * q;\n        // prettier-ignore\n        b = a, a = r, x = u, y = v, u = m, v = n;\n    }\n    const gcd = b;\n    if (gcd !== _1n)\n        throw new Error('invert: does not exist');\n    return mod(x, modulo);\n}\nfunction assertIsSquare(Fp, root, n) {\n    if (!Fp.eql(Fp.sqr(root), n))\n        throw new Error('Cannot find square root');\n}\n// Not all roots are possible! Example which will throw:\n// const NUM =\n// n = 72057594037927816n;\n// Fp = Field(BigInt('0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'));\nfunction sqrt3mod4(Fp, n) {\n    const p1div4 = (Fp.ORDER + _1n) / _4n;\n    const root = Fp.pow(n, p1div4);\n    assertIsSquare(Fp, root, n);\n    return root;\n}\nfunction sqrt5mod8(Fp, n) {\n    const p5div8 = (Fp.ORDER - _5n) / _8n;\n    const n2 = Fp.mul(n, _2n);\n    const v = Fp.pow(n2, p5div8);\n    const nv = Fp.mul(n, v);\n    const i = Fp.mul(Fp.mul(nv, _2n), v);\n    const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n    assertIsSquare(Fp, root, n);\n    return root;\n}\n// Based on RFC9380, Kong algorithm\n// prettier-ignore\nfunction sqrt9mod16(P) {\n    const Fp_ = Field(P);\n    const tn = tonelliShanks(P);\n    const c1 = tn(Fp_, Fp_.neg(Fp_.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n    const c2 = tn(Fp_, c1); //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n    const c3 = tn(Fp_, Fp_.neg(c1)); //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n    const c4 = (P + _7n) / _16n; //  4. c4 = (q + 7) / 16        # Integer arithmetic\n    return (Fp, n) => {\n        let tv1 = Fp.pow(n, c4); //  1. tv1 = x^c4\n        let tv2 = Fp.mul(tv1, c1); //  2. tv2 = c1 * tv1\n        const tv3 = Fp.mul(tv1, c2); //  3. tv3 = c2 * tv1\n        const tv4 = Fp.mul(tv1, c3); //  4. tv4 = c3 * tv1\n        const e1 = Fp.eql(Fp.sqr(tv2), n); //  5.  e1 = (tv2^2) == x\n        const e2 = Fp.eql(Fp.sqr(tv3), n); //  6.  e2 = (tv3^2) == x\n        tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n        tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n        const e3 = Fp.eql(Fp.sqr(tv2), n); //  9.  e3 = (tv2^2) == x\n        const root = Fp.cmov(tv1, tv2, e3); // 10.  z = CMOV(tv1, tv2, e3)   # Select sqrt from tv1 & tv2\n        assertIsSquare(Fp, root, n);\n        return root;\n    };\n}\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P) {\n    // Initialization (precomputation).\n    // Caching initialization could boost perf by 7%.\n    if (P < _3n)\n        throw new Error('sqrt is not defined for small field');\n    // Factor P - 1 = Q * 2^S, where Q is odd\n    let Q = P - _1n;\n    let S = 0;\n    while (Q % _2n === _0n) {\n        Q /= _2n;\n        S++;\n    }\n    // Find the first quadratic non-residue Z >= 2\n    let Z = _2n;\n    const _Fp = Field(P);\n    while (FpLegendre(_Fp, Z) === 1) {\n        // Basic primality test for P. After x iterations, chance of\n        // not finding quadratic non-residue is 2^x, so 2^1000.\n        if (Z++ > 1000)\n            throw new Error('Cannot find square root: probably non-prime P');\n    }\n    // Fast-path; usually done before Z, but we do \"primality test\".\n    if (S === 1)\n        return sqrt3mod4;\n    // Slow-path\n    // TODO: test on Fp2 and others\n    let cc = _Fp.pow(Z, Q); // c = z^Q\n    const Q1div2 = (Q + _1n) / _2n;\n    return function tonelliSlow(Fp, n) {\n        if (Fp.is0(n))\n            return n;\n        // Check if n is a quadratic residue using Legendre symbol\n        if (FpLegendre(Fp, n) !== 1)\n            throw new Error('Cannot find square root');\n        // Initialize variables for the main loop\n        let M = S;\n        let c = Fp.mul(Fp.ONE, cc); // c = z^Q, move cc from field _Fp into field Fp\n        let t = Fp.pow(n, Q); // t = n^Q, first guess at the fudge factor\n        let R = Fp.pow(n, Q1div2); // R = n^((Q+1)/2), first guess at the square root\n        // Main loop\n        // while t != 1\n        while (!Fp.eql(t, Fp.ONE)) {\n            if (Fp.is0(t))\n                return Fp.ZERO; // if t=0 return R=0\n            let i = 1;\n            // Find the smallest i >= 1 such that t^(2^i) ≡ 1 (mod P)\n            let t_tmp = Fp.sqr(t); // t^(2^1)\n            while (!Fp.eql(t_tmp, Fp.ONE)) {\n                i++;\n                t_tmp = Fp.sqr(t_tmp); // t^(2^2)...\n                if (i === M)\n                    throw new Error('Cannot find square root');\n            }\n            // Calculate the exponent for b: 2^(M - i - 1)\n            const exponent = _1n << BigInt(M - i - 1); // bigint is important\n            const b = Fp.pow(c, exponent); // b = 2^(M - i - 1)\n            // Update variables\n            M = i;\n            c = Fp.sqr(b); // c = b^2\n            t = Fp.mul(t, c); // t = (t * b^2)\n            R = Fp.mul(R, b); // R = R*b\n        }\n        return R;\n    };\n}\n/**\n * Square root for a finite field. Will try optimized versions first:\n *\n * 1. P ≡ 3 (mod 4)\n * 2. P ≡ 5 (mod 8)\n * 3. P ≡ 9 (mod 16)\n * 4. Tonelli-Shanks algorithm\n *\n * Different algorithms can give different roots, it is up to user to decide which one they want.\n * For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n */\nexport function FpSqrt(P) {\n    // P ≡ 3 (mod 4) => √n = n^((P+1)/4)\n    if (P % _4n === _3n)\n        return sqrt3mod4;\n    // P ≡ 5 (mod 8) => Atkin algorithm, page 10 of https://eprint.iacr.org/2012/685.pdf\n    if (P % _8n === _5n)\n        return sqrt5mod8;\n    // P ≡ 9 (mod 16) => Kong algorithm, page 11 of https://eprint.iacr.org/2012/685.pdf (algorithm 4)\n    if (P % _16n === _9n)\n        return sqrt9mod16(P);\n    // Tonelli-Shanks algorithm\n    return tonelliShanks(P);\n}\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;\n// prettier-ignore\nconst FIELD_FIELDS = [\n    'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n    'eql', 'add', 'sub', 'mul', 'pow', 'div',\n    'addN', 'subN', 'mulN', 'sqrN'\n];\nexport function validateField(field) {\n    const initial = {\n        ORDER: 'bigint',\n        MASK: 'bigint',\n        BYTES: 'number',\n        BITS: 'number',\n    };\n    const opts = FIELD_FIELDS.reduce((map, val) => {\n        map[val] = 'function';\n        return map;\n    }, initial);\n    _validateObject(field, opts);\n    // const max = 16384;\n    // if (field.BYTES < 1 || field.BYTES > max) throw new Error('invalid field');\n    // if (field.BITS < 1 || field.BITS > 8 * max) throw new Error('invalid field');\n    return field;\n}\n// Generic field functions\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow(Fp, num, power) {\n    if (power < _0n)\n        throw new Error('invalid exponent, negatives unsupported');\n    if (power === _0n)\n        return Fp.ONE;\n    if (power === _1n)\n        return num;\n    let p = Fp.ONE;\n    let d = num;\n    while (power > _0n) {\n        if (power & _1n)\n            p = Fp.mul(p, d);\n        d = Fp.sqr(d);\n        power >>= _1n;\n    }\n    return p;\n}\n/**\n * Efficiently invert an array of Field elements.\n * Exception-free. Will return `undefined` for 0 elements.\n * @param passZero map 0 to 0 (instead of undefined)\n */\nexport function FpInvertBatch(Fp, nums, passZero = false) {\n    const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : undefined);\n    // Walk from first to last, multiply them by each other MOD p\n    const multipliedAcc = nums.reduce((acc, num, i) => {\n        if (Fp.is0(num))\n            return acc;\n        inverted[i] = acc;\n        return Fp.mul(acc, num);\n    }, Fp.ONE);\n    // Invert last element\n    const invertedAcc = Fp.inv(multipliedAcc);\n    // Walk from last to first, multiply them by inverted each other MOD p\n    nums.reduceRight((acc, num, i) => {\n        if (Fp.is0(num))\n            return acc;\n        inverted[i] = Fp.mul(acc, inverted[i]);\n        return Fp.mul(acc, num);\n    }, invertedAcc);\n    return inverted;\n}\n// TODO: remove\nexport function FpDiv(Fp, lhs, rhs) {\n    return Fp.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, Fp.ORDER) : Fp.inv(rhs));\n}\n/**\n * Legendre symbol.\n * Legendre constant is used to calculate Legendre symbol (a | p)\n * which denotes the value of a^((p-1)/2) (mod p).\n *\n * * (a | p) ≡ 1    if a is a square (mod p), quadratic residue\n * * (a | p) ≡ -1   if a is not a square (mod p), quadratic non residue\n * * (a | p) ≡ 0    if a ≡ 0 (mod p)\n */\nexport function FpLegendre(Fp, n) {\n    // We can use 3rd argument as optional cache of this value\n    // but seems unneeded for now. The operation is very fast.\n    const p1mod2 = (Fp.ORDER - _1n) / _2n;\n    const powered = Fp.pow(n, p1mod2);\n    const yes = Fp.eql(powered, Fp.ONE);\n    const zero = Fp.eql(powered, Fp.ZERO);\n    const no = Fp.eql(powered, Fp.neg(Fp.ONE));\n    if (!yes && !zero && !no)\n        throw new Error('invalid Legendre symbol result');\n    return yes ? 1 : zero ? 0 : -1;\n}\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare(Fp, n) {\n    const l = FpLegendre(Fp, n);\n    return l === 1;\n}\n// CURVE.n lengths\nexport function nLength(n, nBitLength) {\n    // Bit size, byte size of CURVE.n\n    if (nBitLength !== undefined)\n        anumber(nBitLength);\n    const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n    const nByteLength = Math.ceil(_nBitLength / 8);\n    return { nBitLength: _nBitLength, nByteLength };\n}\n/**\n * Creates a finite field. Major performance optimizations:\n * * 1. Denormalized operations like mulN instead of mul.\n * * 2. Identical object shape: never add or remove keys.\n * * 3. `Object.freeze`.\n * Fragile: always run a benchmark on a change.\n * Security note: operations don't check 'isValid' for all elements for performance reasons,\n * it is caller responsibility to check this.\n * This is low-level code, please make sure you know what you're doing.\n *\n * Note about field properties:\n * * CHARACTERISTIC p = prime number, number of elements in main subgroup.\n * * ORDER q = similar to cofactor in curves, may be composite `q = p^m`.\n *\n * @param ORDER field order, probably prime, or could be composite\n * @param bitLen how many bits the field consumes\n * @param isLE (default: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER, bitLenOrOpts, // TODO: use opts only in v2?\nisLE = false, opts = {}) {\n    if (ORDER <= _0n)\n        throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);\n    let _nbitLength = undefined;\n    let _sqrt = undefined;\n    let modFromBytes = false;\n    let allowedLengths = undefined;\n    if (typeof bitLenOrOpts === 'object' && bitLenOrOpts != null) {\n        if (opts.sqrt || isLE)\n            throw new Error('cannot specify opts in two arguments');\n        const _opts = bitLenOrOpts;\n        if (_opts.BITS)\n            _nbitLength = _opts.BITS;\n        if (_opts.sqrt)\n            _sqrt = _opts.sqrt;\n        if (typeof _opts.isLE === 'boolean')\n            isLE = _opts.isLE;\n        if (typeof _opts.modFromBytes === 'boolean')\n            modFromBytes = _opts.modFromBytes;\n        allowedLengths = _opts.allowedLengths;\n    }\n    else {\n        if (typeof bitLenOrOpts === 'number')\n            _nbitLength = bitLenOrOpts;\n        if (opts.sqrt)\n            _sqrt = opts.sqrt;\n    }\n    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, _nbitLength);\n    if (BYTES > 2048)\n        throw new Error('invalid field: expected ORDER of <= 2048 bytes');\n    let sqrtP; // cached sqrtP\n    const f = Object.freeze({\n        ORDER,\n        isLE,\n        BITS,\n        BYTES,\n        MASK: bitMask(BITS),\n        ZERO: _0n,\n        ONE: _1n,\n        allowedLengths: allowedLengths,\n        create: (num) => mod(num, ORDER),\n        isValid: (num) => {\n            if (typeof num !== 'bigint')\n                throw new Error('invalid field element: expected bigint, got ' + typeof num);\n            return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n        },\n        is0: (num) => num === _0n,\n        // is valid and invertible\n        isValidNot0: (num) => !f.is0(num) && f.isValid(num),\n        isOdd: (num) => (num & _1n) === _1n,\n        neg: (num) => mod(-num, ORDER),\n        eql: (lhs, rhs) => lhs === rhs,\n        sqr: (num) => mod(num * num, ORDER),\n        add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n        sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n        mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n        pow: (num, power) => FpPow(f, num, power),\n        div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n        // Same as above, but doesn't normalize\n        sqrN: (num) => num * num,\n        addN: (lhs, rhs) => lhs + rhs,\n        subN: (lhs, rhs) => lhs - rhs,\n        mulN: (lhs, rhs) => lhs * rhs,\n        inv: (num) => invert(num, ORDER),\n        sqrt: _sqrt ||\n            ((n) => {\n                if (!sqrtP)\n                    sqrtP = FpSqrt(ORDER);\n                return sqrtP(f, n);\n            }),\n        toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n        fromBytes: (bytes, skipValidation = true) => {\n            if (allowedLengths) {\n                if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {\n                    throw new Error('Field.fromBytes: expected ' + allowedLengths + ' bytes, got ' + bytes.length);\n                }\n                const padded = new Uint8Array(BYTES);\n                // isLE add 0 to right, !isLE to the left.\n                padded.set(bytes, isLE ? 0 : padded.length - bytes.length);\n                bytes = padded;\n            }\n            if (bytes.length !== BYTES)\n                throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);\n            let scalar = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n            if (modFromBytes)\n                scalar = mod(scalar, ORDER);\n            if (!skipValidation)\n                if (!f.isValid(scalar))\n                    throw new Error('invalid field element: outside of range 0..ORDER');\n            // NOTE: we don't validate scalar here, please use isValid. This done such way because some\n            // protocol may allow non-reduced scalar that reduced later or changed some other way.\n            return scalar;\n        },\n        // TODO: we don't need it here, move out to separate fn\n        invertBatch: (lst) => FpInvertBatch(f, lst),\n        // We can't move this out because Fp6, Fp12 implement it\n        // and it's unclear what to return in there.\n        cmov: (a, b, c) => (c ? b : a),\n    });\n    return Object.freeze(f);\n}\n// Generic random scalar, we can do same for other fields if via Fp2.mul(Fp2.ONE, Fp2.random)?\n// This allows unsafe methods like ignore bias or zero. These unsafe, but often used in different protocols (if deterministic RNG).\n// which mean we cannot force this via opts.\n// Not sure what to do with randomBytes, we can accept it inside opts if wanted.\n// Probably need to export getMinHashLength somewhere?\n// random(bytes?: Uint8Array, unsafeAllowZero = false, unsafeAllowBias = false) {\n//   const LEN = !unsafeAllowBias ? getMinHashLength(ORDER) : BYTES;\n//   if (bytes === undefined) bytes = randomBytes(LEN); // _opts.randomBytes?\n//   const num = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n//   // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n//   const reduced = unsafeAllowZero ? mod(num, ORDER) : mod(num, ORDER - _1n) + _1n;\n//   return reduced;\n// },\nexport function FpSqrtOdd(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(\"Field doesn't have isOdd\");\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? root : Fp.neg(root);\n}\nexport function FpSqrtEven(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(\"Field doesn't have isOdd\");\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use `mapKeyToField` instead\n */\nexport function hashToPrivateScalar(hash, groupOrder, isLE = false) {\n    hash = ensureBytes('privateHash', hash);\n    const hashLen = hash.length;\n    const minLen = nLength(groupOrder).nByteLength + 8;\n    if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n        throw new Error('hashToPrivateScalar: expected ' + minLen + '-1024 bytes of input, got ' + hashLen);\n    const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n    return mod(num, groupOrder - _1n) + _1n;\n}\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder) {\n    if (typeof fieldOrder !== 'bigint')\n        throw new Error('field order must be bigint');\n    const bitLength = fieldOrder.toString(2).length;\n    return Math.ceil(bitLength / 8);\n}\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder) {\n    const length = getFieldBytesLength(fieldOrder);\n    return length + Math.ceil(length / 2);\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n    const len = key.length;\n    const fieldLen = getFieldBytesLength(fieldOrder);\n    const minLen = getMinHashLength(fieldOrder);\n    // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n    if (len < 16 || len < minLen || len > 1024)\n        throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);\n    const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);\n    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n    const reduced = mod(num, fieldOrder - _1n) + _1n;\n    return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n//# sourceMappingURL=modular.js.map","/**\n * Methods for elliptic curve multiplication by scalars.\n * Contains wNAF, pippenger.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { bitLen, bitMask, validateObject } from \"../utils.js\";\nimport { Field, FpInvertBatch, nLength, validateField } from \"./modular.js\";\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nexport function negateCt(condition, item) {\n    const neg = item.negate();\n    return condition ? neg : item;\n}\n/**\n * Takes a bunch of Projective Points but executes only one\n * inversion on all of them. Inversion is very slow operation,\n * so this improves performance massively.\n * Optimization: converts a list of projective points to a list of identical points with Z=1.\n */\nexport function normalizeZ(c, points) {\n    const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));\n    return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));\n}\nfunction validateW(W, bits) {\n    if (!Number.isSafeInteger(W) || W <= 0 || W > bits)\n        throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);\n}\nfunction calcWOpts(W, scalarBits) {\n    validateW(W, scalarBits);\n    const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero\n    const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero\n    const maxNumber = 2 ** W; // W=8 256\n    const mask = bitMask(W); // W=8 255 == mask 0b11111111\n    const shiftBy = BigInt(W); // W=8 8\n    return { windows, windowSize, mask, maxNumber, shiftBy };\n}\nfunction calcOffsets(n, window, wOpts) {\n    const { windowSize, mask, maxNumber, shiftBy } = wOpts;\n    let wbits = Number(n & mask); // extract W bits.\n    let nextN = n >> shiftBy; // shift number by W bits.\n    // What actually happens here:\n    // const highestBit = Number(mask ^ (mask >> 1n));\n    // let wbits2 = wbits - 1; // skip zero\n    // if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);\n    // split if bits > max: +224 => 256-32\n    if (wbits > windowSize) {\n        // we skip zero, which means instead of `>= size-1`, we do `> size`\n        wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.\n        nextN += _1n; // +256 (carry)\n    }\n    const offsetStart = window * windowSize;\n    const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero\n    const isZero = wbits === 0; // is current window slice a 0?\n    const isNeg = wbits < 0; // is current window slice negative?\n    const isNegF = window % 2 !== 0; // fake random statement for noise\n    const offsetF = offsetStart; // fake offset for noise\n    return { nextN, offset, isZero, isNeg, isNegF, offsetF };\n}\nfunction validateMSMPoints(points, c) {\n    if (!Array.isArray(points))\n        throw new Error('array expected');\n    points.forEach((p, i) => {\n        if (!(p instanceof c))\n            throw new Error('invalid point at index ' + i);\n    });\n}\nfunction validateMSMScalars(scalars, field) {\n    if (!Array.isArray(scalars))\n        throw new Error('array of scalars expected');\n    scalars.forEach((s, i) => {\n        if (!field.isValid(s))\n            throw new Error('invalid scalar at index ' + i);\n    });\n}\n// Since points in different groups cannot be equal (different object constructor),\n// we can have single place to store precomputes.\n// Allows to make points frozen / immutable.\nconst pointPrecomputes = new WeakMap();\nconst pointWindowSizes = new WeakMap();\nfunction getW(P) {\n    // To disable precomputes:\n    // return 1;\n    return pointWindowSizes.get(P) || 1;\n}\nfunction assert0(n) {\n    if (n !== _0n)\n        throw new Error('invalid wNAF');\n}\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Table generation takes **30MB of ram and 10ms on high-end CPU**,\n * but may take much longer on slow devices. Actual generation will happen on\n * first call of `multiply()`. By default, `BASE` point is precomputed.\n *\n * Scalars should always be less than curve order: this should be checked inside of a curve itself.\n * Creates precomputation tables for fast multiplication:\n * - private scalar is split by fixed size windows of W bits\n * - every window point is collected from window's table & added to accumulator\n * - since windows are different, same point inside tables won't be accessed more than once per calc\n * - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n * - +1 window is neccessary for wNAF\n * - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n *\n * @todo Research returning 2d JS array of windows, instead of a single window.\n * This would allow windows to be in different memory locations\n */\nexport class wNAF {\n    // Parametrized with a given Point class (not individual point)\n    constructor(Point, bits) {\n        this.BASE = Point.BASE;\n        this.ZERO = Point.ZERO;\n        this.Fn = Point.Fn;\n        this.bits = bits;\n    }\n    // non-const time multiplication ladder\n    _unsafeLadder(elm, n, p = this.ZERO) {\n        let d = elm;\n        while (n > _0n) {\n            if (n & _1n)\n                p = p.add(d);\n            d = d.double();\n            n >>= _1n;\n        }\n        return p;\n    }\n    /**\n     * Creates a wNAF precomputation window. Used for caching.\n     * Default window size is set by `utils.precompute()` and is equal to 8.\n     * Number of precomputed points depends on the curve size:\n     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n     * - 𝑊 is the window size\n     * - 𝑛 is the bitlength of the curve order.\n     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n     * @param point Point instance\n     * @param W window size\n     * @returns precomputed point tables flattened to a single array\n     */\n    precomputeWindow(point, W) {\n        const { windows, windowSize } = calcWOpts(W, this.bits);\n        const points = [];\n        let p = point;\n        let base = p;\n        for (let window = 0; window < windows; window++) {\n            base = p;\n            points.push(base);\n            // i=1, bc we skip 0\n            for (let i = 1; i < windowSize; i++) {\n                base = base.add(p);\n                points.push(base);\n            }\n            p = base.double();\n        }\n        return points;\n    }\n    /**\n     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n     * More compact implementation:\n     * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541\n     * @returns real and fake (for const-time) points\n     */\n    wNAF(W, precomputes, n) {\n        // Scalar should be smaller than field order\n        if (!this.Fn.isValid(n))\n            throw new Error('invalid scalar');\n        // Accumulators\n        let p = this.ZERO;\n        let f = this.BASE;\n        // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n        // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n        // there is negate now: it is possible that negated element from low value\n        // would be the same as high element, which will create carry into next window.\n        // It's not obvious how this can fail, but still worth investigating later.\n        const wo = calcWOpts(W, this.bits);\n        for (let window = 0; window < wo.windows; window++) {\n            // (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise\n            const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);\n            n = nextN;\n            if (isZero) {\n                // bits are 0: add garbage to fake point\n                // Important part for const-time getPublicKey: add random \"noise\" point to f.\n                f = f.add(negateCt(isNegF, precomputes[offsetF]));\n            }\n            else {\n                // bits are 1: add to result point\n                p = p.add(negateCt(isNeg, precomputes[offset]));\n            }\n        }\n        assert0(n);\n        // Return both real and fake points: JIT won't eliminate f.\n        // At this point there is a way to F be infinity-point even if p is not,\n        // which makes it less const-time: around 1 bigint multiply.\n        return { p, f };\n    }\n    /**\n     * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.\n     * @param acc accumulator point to add result of multiplication\n     * @returns point\n     */\n    wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {\n        const wo = calcWOpts(W, this.bits);\n        for (let window = 0; window < wo.windows; window++) {\n            if (n === _0n)\n                break; // Early-exit, skip 0 value\n            const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);\n            n = nextN;\n            if (isZero) {\n                // Window bits are 0: skip processing.\n                // Move to next window.\n                continue;\n            }\n            else {\n                const item = precomputes[offset];\n                acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM\n            }\n        }\n        assert0(n);\n        return acc;\n    }\n    getPrecomputes(W, point, transform) {\n        // Calculate precomputes on a first run, reuse them after\n        let comp = pointPrecomputes.get(point);\n        if (!comp) {\n            comp = this.precomputeWindow(point, W);\n            if (W !== 1) {\n                // Doing transform outside of if brings 15% perf hit\n                if (typeof transform === 'function')\n                    comp = transform(comp);\n                pointPrecomputes.set(point, comp);\n            }\n        }\n        return comp;\n    }\n    cached(point, scalar, transform) {\n        const W = getW(point);\n        return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);\n    }\n    unsafe(point, scalar, transform, prev) {\n        const W = getW(point);\n        if (W === 1)\n            return this._unsafeLadder(point, scalar, prev); // For W=1 ladder is ~x2 faster\n        return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);\n    }\n    // We calculate precomputes for elliptic curve point multiplication\n    // using windowed method. This specifies window size and\n    // stores precomputed values. Usually only base point would be precomputed.\n    createCache(P, W) {\n        validateW(W, this.bits);\n        pointWindowSizes.set(P, W);\n        pointPrecomputes.delete(P);\n    }\n    hasCache(elm) {\n        return getW(elm) !== 1;\n    }\n}\n/**\n * Endomorphism-specific multiplication for Koblitz curves.\n * Cost: 128 dbl, 0-256 adds.\n */\nexport function mulEndoUnsafe(Point, point, k1, k2) {\n    let acc = point;\n    let p1 = Point.ZERO;\n    let p2 = Point.ZERO;\n    while (k1 > _0n || k2 > _0n) {\n        if (k1 & _1n)\n            p1 = p1.add(acc);\n        if (k2 & _1n)\n            p2 = p2.add(acc);\n        acc = acc.double();\n        k1 >>= _1n;\n        k2 >>= _1n;\n    }\n    return { p1, p2 };\n}\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster than precomputes.\n * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.\n * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @param scalars array of L scalars (aka secret keys / bigints)\n */\nexport function pippenger(c, fieldN, points, scalars) {\n    // If we split scalars by some window (let's say 8 bits), every chunk will only\n    // take 256 buckets even if there are 4096 scalars, also re-uses double.\n    // TODO:\n    // - https://eprint.iacr.org/2024/750.pdf\n    // - https://tches.iacr.org/index.php/TCHES/article/view/10287\n    // 0 is accepted in scalars\n    validateMSMPoints(points, c);\n    validateMSMScalars(scalars, fieldN);\n    const plength = points.length;\n    const slength = scalars.length;\n    if (plength !== slength)\n        throw new Error('arrays of points and scalars must have equal length');\n    // if (plength === 0) throw new Error('array must be of length >= 2');\n    const zero = c.ZERO;\n    const wbits = bitLen(BigInt(plength));\n    let windowSize = 1; // bits\n    if (wbits > 12)\n        windowSize = wbits - 3;\n    else if (wbits > 4)\n        windowSize = wbits - 2;\n    else if (wbits > 0)\n        windowSize = 2;\n    const MASK = bitMask(windowSize);\n    const buckets = new Array(Number(MASK) + 1).fill(zero); // +1 for zero array\n    const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;\n    let sum = zero;\n    for (let i = lastBits; i >= 0; i -= windowSize) {\n        buckets.fill(zero);\n        for (let j = 0; j < slength; j++) {\n            const scalar = scalars[j];\n            const wbits = Number((scalar >> BigInt(i)) & MASK);\n            buckets[wbits] = buckets[wbits].add(points[j]);\n        }\n        let resI = zero; // not using this will do small speed-up, but will lose ct\n        // Skip first bucket, because it is zero\n        for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {\n            sumI = sumI.add(buckets[j]);\n            resI = resI.add(sumI);\n        }\n        sum = sum.add(resI);\n        if (i !== 0)\n            for (let j = 0; j < windowSize; j++)\n                sum = sum.double();\n    }\n    return sum;\n}\n/**\n * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @returns function which multiplies points with scaars\n */\nexport function precomputeMSMUnsafe(c, fieldN, points, windowSize) {\n    /**\n     * Performance Analysis of Window-based Precomputation\n     *\n     * Base Case (256-bit scalar, 8-bit window):\n     * - Standard precomputation requires:\n     *   - 31 additions per scalar × 256 scalars = 7,936 ops\n     *   - Plus 255 summary additions = 8,191 total ops\n     *   Note: Summary additions can be optimized via accumulator\n     *\n     * Chunked Precomputation Analysis:\n     * - Using 32 chunks requires:\n     *   - 255 additions per chunk\n     *   - 256 doublings\n     *   - Total: (255 × 32) + 256 = 8,416 ops\n     *\n     * Memory Usage Comparison:\n     * Window Size | Standard Points | Chunked Points\n     * ------------|-----------------|---------------\n     *     4-bit   |     520         |      15\n     *     8-bit   |    4,224        |     255\n     *    10-bit   |   13,824        |   1,023\n     *    16-bit   |  557,056        |  65,535\n     *\n     * Key Advantages:\n     * 1. Enables larger window sizes due to reduced memory overhead\n     * 2. More efficient for smaller scalar counts:\n     *    - 16 chunks: (16 × 255) + 256 = 4,336 ops\n     *    - ~2x faster than standard 8,191 ops\n     *\n     * Limitations:\n     * - Not suitable for plain precomputes (requires 256 constant doublings)\n     * - Performance degrades with larger scalar counts:\n     *   - Optimal for ~256 scalars\n     *   - Less efficient for 4096+ scalars (Pippenger preferred)\n     */\n    validateW(windowSize, fieldN.BITS);\n    validateMSMPoints(points, c);\n    const zero = c.ZERO;\n    const tableSize = 2 ** windowSize - 1; // table size (without zero)\n    const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item\n    const MASK = bitMask(windowSize);\n    const tables = points.map((p) => {\n        const res = [];\n        for (let i = 0, acc = p; i < tableSize; i++) {\n            res.push(acc);\n            acc = acc.add(p);\n        }\n        return res;\n    });\n    return (scalars) => {\n        validateMSMScalars(scalars, fieldN);\n        if (scalars.length > points.length)\n            throw new Error('array of scalars must be smaller than array of points');\n        let res = zero;\n        for (let i = 0; i < chunks; i++) {\n            // No need to double if accumulator is still zero.\n            if (res !== zero)\n                for (let j = 0; j < windowSize; j++)\n                    res = res.double();\n            const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);\n            for (let j = 0; j < scalars.length; j++) {\n                const n = scalars[j];\n                const curr = Number((n >> shiftBy) & MASK);\n                if (!curr)\n                    continue; // skip zero scalars chunks\n                res = res.add(tables[j][curr - 1]);\n            }\n        }\n        return res;\n    };\n}\n// TODO: remove\n/** @deprecated */\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\nfunction createField(order, field, isLE) {\n    if (field) {\n        if (field.ORDER !== order)\n            throw new Error('Field.ORDER must match order: Fp == p, Fn == n');\n        validateField(field);\n        return field;\n    }\n    else {\n        return Field(order, { isLE });\n    }\n}\n/** Validates CURVE opts and creates fields */\nexport function _createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {\n    if (FpFnLE === undefined)\n        FpFnLE = type === 'edwards';\n    if (!CURVE || typeof CURVE !== 'object')\n        throw new Error(`expected valid ${type} CURVE object`);\n    for (const p of ['p', 'n', 'h']) {\n        const val = CURVE[p];\n        if (!(typeof val === 'bigint' && val > _0n))\n            throw new Error(`CURVE.${p} must be positive bigint`);\n    }\n    const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);\n    const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);\n    const _b = type === 'weierstrass' ? 'b' : 'd';\n    const params = ['Gx', 'Gy', 'a', _b];\n    for (const p of params) {\n        // @ts-ignore\n        if (!Fp.isValid(CURVE[p]))\n            throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);\n    }\n    CURVE = Object.freeze(Object.assign({}, CURVE));\n    return { CURVE, Fp, Fn };\n}\n//# sourceMappingURL=curve.js.map","/**\n * Short Weierstrass curve methods. The formula is: y² = x³ + ax + b.\n *\n * ### Design rationale for types\n *\n * * Interaction between classes from different curves should fail:\n *   `k256.Point.BASE.add(p256.Point.BASE)`\n * * For this purpose we want to use `instanceof` operator, which is fast and works during runtime\n * * Different calls of `curve()` would return different classes -\n *   `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,\n *   it won't affect others\n *\n * TypeScript can't infer types for classes created inside a function. Classes is one instance\n * of nominative types in TypeScript and interfaces only check for shape, so it's hard to create\n * unique type for every function call.\n *\n * We can use generic types via some param, like curve opts, but that would:\n *     1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)\n *     which is hard to debug.\n *     2. Params can be generic and we can't enforce them to be constant value:\n *     if somebody creates curve from non-constant params,\n *     it would be allowed to interact with other curves with non-constant params\n *\n * @todo https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac as nobleHmac } from '@noble/hashes/hmac.js';\nimport { ahash } from '@noble/hashes/utils';\nimport { _validateObject, _abool2 as abool, _abytes2 as abytes, aInRange, bitLen, bitMask, bytesToHex, bytesToNumberBE, concatBytes, createHmacDrbg, ensureBytes, hexToBytes, inRange, isBytes, memoized, numberToHexUnpadded, randomBytes as randomBytesWeb, } from \"../utils.js\";\nimport { _createCurveFields, mulEndoUnsafe, negateCt, normalizeZ, pippenger, wNAF, } from \"./curve.js\";\nimport { Field, FpInvertBatch, getMinHashLength, mapHashToField, nLength, validateField, } from \"./modular.js\";\n// We construct basis in such way that den is always positive and equals n, but num sign depends on basis (not on secret value)\nconst divNearest = (num, den) => (num + (num >= 0 ? den : -den) / _2n) / den;\n/**\n * Splits scalar for GLV endomorphism.\n */\nexport function _splitEndoScalar(k, basis, n) {\n    // Split scalar into two such that part is ~half bits: `abs(part) < sqrt(N)`\n    // Since part can be negative, we need to do this on point.\n    // TODO: verifyScalar function which consumes lambda\n    const [[a1, b1], [a2, b2]] = basis;\n    const c1 = divNearest(b2 * k, n);\n    const c2 = divNearest(-b1 * k, n);\n    // |k1|/|k2| is < sqrt(N), but can be negative.\n    // If we do `k1 mod N`, we'll get big scalar (`> sqrt(N)`): so, we do cheaper negation instead.\n    let k1 = k - c1 * a1 - c2 * a2;\n    let k2 = -c1 * b1 - c2 * b2;\n    const k1neg = k1 < _0n;\n    const k2neg = k2 < _0n;\n    if (k1neg)\n        k1 = -k1;\n    if (k2neg)\n        k2 = -k2;\n    // Double check that resulting scalar less than half bits of N: otherwise wNAF will fail.\n    // This should only happen on wrong basises. Also, math inside is too complex and I don't trust it.\n    const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n; // Half bits of N\n    if (k1 < _0n || k1 >= MAX_NUM || k2 < _0n || k2 >= MAX_NUM) {\n        throw new Error('splitScalar (endomorphism): failed, k=' + k);\n    }\n    return { k1neg, k1, k2neg, k2 };\n}\nfunction validateSigFormat(format) {\n    if (!['compact', 'recovered', 'der'].includes(format))\n        throw new Error('Signature format must be \"compact\", \"recovered\", or \"der\"');\n    return format;\n}\nfunction validateSigOpts(opts, def) {\n    const optsn = {};\n    for (let optName of Object.keys(def)) {\n        // @ts-ignore\n        optsn[optName] = opts[optName] === undefined ? def[optName] : opts[optName];\n    }\n    abool(optsn.lowS, 'lowS');\n    abool(optsn.prehash, 'prehash');\n    if (optsn.format !== undefined)\n        validateSigFormat(optsn.format);\n    return optsn;\n}\nexport class DERErr extends Error {\n    constructor(m = '') {\n        super(m);\n    }\n}\n/**\n * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:\n *\n *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]\n *\n * Docs: https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/, https://luca.ntop.org/Teaching/Appunti/asn1.html\n */\nexport const DER = {\n    // asn.1 DER encoding utils\n    Err: DERErr,\n    // Basic building block is TLV (Tag-Length-Value)\n    _tlv: {\n        encode: (tag, data) => {\n            const { Err: E } = DER;\n            if (tag < 0 || tag > 256)\n                throw new E('tlv.encode: wrong tag');\n            if (data.length & 1)\n                throw new E('tlv.encode: unpadded data');\n            const dataLen = data.length / 2;\n            const len = numberToHexUnpadded(dataLen);\n            if ((len.length / 2) & 128)\n                throw new E('tlv.encode: long form length too big');\n            // length of length with long form flag\n            const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 128) : '';\n            const t = numberToHexUnpadded(tag);\n            return t + lenLen + len + data;\n        },\n        // v - value, l - left bytes (unparsed)\n        decode(tag, data) {\n            const { Err: E } = DER;\n            let pos = 0;\n            if (tag < 0 || tag > 256)\n                throw new E('tlv.encode: wrong tag');\n            if (data.length < 2 || data[pos++] !== tag)\n                throw new E('tlv.decode: wrong tlv');\n            const first = data[pos++];\n            const isLong = !!(first & 128); // First bit of first length byte is flag for short/long form\n            let length = 0;\n            if (!isLong)\n                length = first;\n            else {\n                // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]\n                const lenLen = first & 127;\n                if (!lenLen)\n                    throw new E('tlv.decode(long): indefinite length not supported');\n                if (lenLen > 4)\n                    throw new E('tlv.decode(long): byte length is too big'); // this will overflow u32 in js\n                const lengthBytes = data.subarray(pos, pos + lenLen);\n                if (lengthBytes.length !== lenLen)\n                    throw new E('tlv.decode: length bytes not complete');\n                if (lengthBytes[0] === 0)\n                    throw new E('tlv.decode(long): zero leftmost byte');\n                for (const b of lengthBytes)\n                    length = (length << 8) | b;\n                pos += lenLen;\n                if (length < 128)\n                    throw new E('tlv.decode(long): not minimal encoding');\n            }\n            const v = data.subarray(pos, pos + length);\n            if (v.length !== length)\n                throw new E('tlv.decode: wrong value length');\n            return { v, l: data.subarray(pos + length) };\n        },\n    },\n    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n    // since we always use positive integers here. It must always be empty:\n    // - add zero byte if exists\n    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n    _int: {\n        encode(num) {\n            const { Err: E } = DER;\n            if (num < _0n)\n                throw new E('integer: negative integers are not allowed');\n            let hex = numberToHexUnpadded(num);\n            // Pad with zero byte if negative flag is present\n            if (Number.parseInt(hex[0], 16) & 0b1000)\n                hex = '00' + hex;\n            if (hex.length & 1)\n                throw new E('unexpected DER parsing assertion: unpadded hex');\n            return hex;\n        },\n        decode(data) {\n            const { Err: E } = DER;\n            if (data[0] & 128)\n                throw new E('invalid signature integer: negative');\n            if (data[0] === 0x00 && !(data[1] & 128))\n                throw new E('invalid signature integer: unnecessary leading zero');\n            return bytesToNumberBE(data);\n        },\n    },\n    toSig(hex) {\n        // parse DER signature\n        const { Err: E, _int: int, _tlv: tlv } = DER;\n        const data = ensureBytes('signature', hex);\n        const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);\n        if (seqLeftBytes.length)\n            throw new E('invalid signature: left bytes after parsing');\n        const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);\n        const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);\n        if (sLeftBytes.length)\n            throw new E('invalid signature: left bytes after parsing');\n        return { r: int.decode(rBytes), s: int.decode(sBytes) };\n    },\n    hexFromSig(sig) {\n        const { _tlv: tlv, _int: int } = DER;\n        const rs = tlv.encode(0x02, int.encode(sig.r));\n        const ss = tlv.encode(0x02, int.encode(sig.s));\n        const seq = rs + ss;\n        return tlv.encode(0x30, seq);\n    },\n};\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\nexport function _normFnElement(Fn, key) {\n    const { BYTES: expected } = Fn;\n    let num;\n    if (typeof key === 'bigint') {\n        num = key;\n    }\n    else {\n        let bytes = ensureBytes('private key', key);\n        try {\n            num = Fn.fromBytes(bytes);\n        }\n        catch (error) {\n            throw new Error(`invalid private key: expected ui8a of size ${expected}, got ${typeof key}`);\n        }\n    }\n    if (!Fn.isValidNot0(num))\n        throw new Error('invalid private key: out of range [1..N-1]');\n    return num;\n}\n/**\n * Creates weierstrass Point constructor, based on specified curve options.\n *\n * @example\n```js\nconst opts = {\n  p: BigInt('0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff'),\n  n: BigInt('0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551'),\n  h: BigInt(1),\n  a: BigInt('0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc'),\n  b: BigInt('0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b'),\n  Gx: BigInt('0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296'),\n  Gy: BigInt('0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5'),\n};\nconst p256_Point = weierstrass(opts);\n```\n */\nexport function weierstrassN(params, extraOpts = {}) {\n    const validated = _createCurveFields('weierstrass', params, extraOpts);\n    const { Fp, Fn } = validated;\n    let CURVE = validated.CURVE;\n    const { h: cofactor, n: CURVE_ORDER } = CURVE;\n    _validateObject(extraOpts, {}, {\n        allowInfinityPoint: 'boolean',\n        clearCofactor: 'function',\n        isTorsionFree: 'function',\n        fromBytes: 'function',\n        toBytes: 'function',\n        endo: 'object',\n        wrapPrivateKey: 'boolean',\n    });\n    const { endo } = extraOpts;\n    if (endo) {\n        // validateObject(endo, { beta: 'bigint', splitScalar: 'function' });\n        if (!Fp.is0(CURVE.a) || typeof endo.beta !== 'bigint' || !Array.isArray(endo.basises)) {\n            throw new Error('invalid endo: expected \"beta\": bigint and \"basises\": array');\n        }\n    }\n    const lengths = getWLengths(Fp, Fn);\n    function assertCompressionIsSupported() {\n        if (!Fp.isOdd)\n            throw new Error('compression is not supported: Field does not have .isOdd()');\n    }\n    // Implements IEEE P1363 point encoding\n    function pointToBytes(_c, point, isCompressed) {\n        const { x, y } = point.toAffine();\n        const bx = Fp.toBytes(x);\n        abool(isCompressed, 'isCompressed');\n        if (isCompressed) {\n            assertCompressionIsSupported();\n            const hasEvenY = !Fp.isOdd(y);\n            return concatBytes(pprefix(hasEvenY), bx);\n        }\n        else {\n            return concatBytes(Uint8Array.of(0x04), bx, Fp.toBytes(y));\n        }\n    }\n    function pointFromBytes(bytes) {\n        abytes(bytes, undefined, 'Point');\n        const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths; // e.g. for 32-byte: 33, 65\n        const length = bytes.length;\n        const head = bytes[0];\n        const tail = bytes.subarray(1);\n        // No actual validation is done here: use .assertValidity()\n        if (length === comp && (head === 0x02 || head === 0x03)) {\n            const x = Fp.fromBytes(tail);\n            if (!Fp.isValid(x))\n                throw new Error('bad point: is not on curve, wrong x');\n            const y2 = weierstrassEquation(x); // y² = x³ + ax + b\n            let y;\n            try {\n                y = Fp.sqrt(y2); // y = y² ^ (p+1)/4\n            }\n            catch (sqrtError) {\n                const err = sqrtError instanceof Error ? ': ' + sqrtError.message : '';\n                throw new Error('bad point: is not on curve, sqrt error' + err);\n            }\n            assertCompressionIsSupported();\n            const isYOdd = Fp.isOdd(y); // (y & _1n) === _1n;\n            const isHeadOdd = (head & 1) === 1; // ECDSA-specific\n            if (isHeadOdd !== isYOdd)\n                y = Fp.neg(y);\n            return { x, y };\n        }\n        else if (length === uncomp && head === 0x04) {\n            // TODO: more checks\n            const L = Fp.BYTES;\n            const x = Fp.fromBytes(tail.subarray(0, L));\n            const y = Fp.fromBytes(tail.subarray(L, L * 2));\n            if (!isValidXY(x, y))\n                throw new Error('bad point: is not on curve');\n            return { x, y };\n        }\n        else {\n            throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);\n        }\n    }\n    const encodePoint = extraOpts.toBytes || pointToBytes;\n    const decodePoint = extraOpts.fromBytes || pointFromBytes;\n    function weierstrassEquation(x) {\n        const x2 = Fp.sqr(x); // x * x\n        const x3 = Fp.mul(x2, x); // x² * x\n        return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b); // x³ + a * x + b\n    }\n    // TODO: move top-level\n    /** Checks whether equation holds for given x, y: y² == x³ + ax + b */\n    function isValidXY(x, y) {\n        const left = Fp.sqr(y); // y²\n        const right = weierstrassEquation(x); // x³ + ax + b\n        return Fp.eql(left, right);\n    }\n    // Validate whether the passed curve params are valid.\n    // Test 1: equation y² = x³ + ax + b should work for generator point.\n    if (!isValidXY(CURVE.Gx, CURVE.Gy))\n        throw new Error('bad curve params: generator point');\n    // Test 2: discriminant Δ part should be non-zero: 4a³ + 27b² != 0.\n    // Guarantees curve is genus-1, smooth (non-singular).\n    const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n), _4n);\n    const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));\n    if (Fp.is0(Fp.add(_4a3, _27b2)))\n        throw new Error('bad curve params: a or b');\n    /** Asserts coordinate is valid: 0 <= n < Fp.ORDER. */\n    function acoord(title, n, banZero = false) {\n        if (!Fp.isValid(n) || (banZero && Fp.is0(n)))\n            throw new Error(`bad point coordinate ${title}`);\n        return n;\n    }\n    function aprjpoint(other) {\n        if (!(other instanceof Point))\n            throw new Error('ProjectivePoint expected');\n    }\n    function splitEndoScalarN(k) {\n        if (!endo || !endo.basises)\n            throw new Error('no endo');\n        return _splitEndoScalar(k, endo.basises, Fn.ORDER);\n    }\n    // Memoized toAffine / validity check. They are heavy. Points are immutable.\n    // Converts Projective point to affine (x, y) coordinates.\n    // Can accept precomputed Z^-1 - for example, from invertBatch.\n    // (X, Y, Z) ∋ (x=X/Z, y=Y/Z)\n    const toAffineMemo = memoized((p, iz) => {\n        const { X, Y, Z } = p;\n        // Fast-path for normalized points\n        if (Fp.eql(Z, Fp.ONE))\n            return { x: X, y: Y };\n        const is0 = p.is0();\n        // If invZ was 0, we return zero point. However we still want to execute\n        // all operations, so we replace invZ with a random number, 1.\n        if (iz == null)\n            iz = is0 ? Fp.ONE : Fp.inv(Z);\n        const x = Fp.mul(X, iz);\n        const y = Fp.mul(Y, iz);\n        const zz = Fp.mul(Z, iz);\n        if (is0)\n            return { x: Fp.ZERO, y: Fp.ZERO };\n        if (!Fp.eql(zz, Fp.ONE))\n            throw new Error('invZ was invalid');\n        return { x, y };\n    });\n    // NOTE: on exception this will crash 'cached' and no value will be set.\n    // Otherwise true will be return\n    const assertValidMemo = memoized((p) => {\n        if (p.is0()) {\n            // (0, 1, 0) aka ZERO is invalid in most contexts.\n            // In BLS, ZERO can be serialized, so we allow it.\n            // (0, 0, 0) is invalid representation of ZERO.\n            if (extraOpts.allowInfinityPoint && !Fp.is0(p.Y))\n                return;\n            throw new Error('bad point: ZERO');\n        }\n        // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`\n        const { x, y } = p.toAffine();\n        if (!Fp.isValid(x) || !Fp.isValid(y))\n            throw new Error('bad point: x or y not field elements');\n        if (!isValidXY(x, y))\n            throw new Error('bad point: equation left != right');\n        if (!p.isTorsionFree())\n            throw new Error('bad point: not in prime-order subgroup');\n        return true;\n    });\n    function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {\n        k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);\n        k1p = negateCt(k1neg, k1p);\n        k2p = negateCt(k2neg, k2p);\n        return k1p.add(k2p);\n    }\n    /**\n     * Projective Point works in 3d / projective (homogeneous) coordinates:(X, Y, Z) ∋ (x=X/Z, y=Y/Z).\n     * Default Point works in 2d / affine coordinates: (x, y).\n     * We're doing calculations in projective, because its operations don't require costly inversion.\n     */\n    class Point {\n        /** Does NOT validate if the point is valid. Use `.assertValidity()`. */\n        constructor(X, Y, Z) {\n            this.X = acoord('x', X);\n            this.Y = acoord('y', Y, true);\n            this.Z = acoord('z', Z);\n            Object.freeze(this);\n        }\n        static CURVE() {\n            return CURVE;\n        }\n        /** Does NOT validate if the point is valid. Use `.assertValidity()`. */\n        static fromAffine(p) {\n            const { x, y } = p || {};\n            if (!p || !Fp.isValid(x) || !Fp.isValid(y))\n                throw new Error('invalid affine point');\n            if (p instanceof Point)\n                throw new Error('projective point not allowed');\n            // (0, 0) would've produced (0, 0, 1) - instead, we need (0, 1, 0)\n            if (Fp.is0(x) && Fp.is0(y))\n                return Point.ZERO;\n            return new Point(x, y, Fp.ONE);\n        }\n        static fromBytes(bytes) {\n            const P = Point.fromAffine(decodePoint(abytes(bytes, undefined, 'point')));\n            P.assertValidity();\n            return P;\n        }\n        static fromHex(hex) {\n            return Point.fromBytes(ensureBytes('pointHex', hex));\n        }\n        get x() {\n            return this.toAffine().x;\n        }\n        get y() {\n            return this.toAffine().y;\n        }\n        /**\n         *\n         * @param windowSize\n         * @param isLazy true will defer table computation until the first multiplication\n         * @returns\n         */\n        precompute(windowSize = 8, isLazy = true) {\n            wnaf.createCache(this, windowSize);\n            if (!isLazy)\n                this.multiply(_3n); // random number\n            return this;\n        }\n        // TODO: return `this`\n        /** A point on curve is valid if it conforms to equation. */\n        assertValidity() {\n            assertValidMemo(this);\n        }\n        hasEvenY() {\n            const { y } = this.toAffine();\n            if (!Fp.isOdd)\n                throw new Error(\"Field doesn't support isOdd\");\n            return !Fp.isOdd(y);\n        }\n        /** Compare one point to another. */\n        equals(other) {\n            aprjpoint(other);\n            const { X: X1, Y: Y1, Z: Z1 } = this;\n            const { X: X2, Y: Y2, Z: Z2 } = other;\n            const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));\n            const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));\n            return U1 && U2;\n        }\n        /** Flips point to one corresponding to (x, -y) in Affine coordinates. */\n        negate() {\n            return new Point(this.X, Fp.neg(this.Y), this.Z);\n        }\n        // Renes-Costello-Batina exception-free doubling formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 3\n        // Cost: 8M + 3S + 3*a + 2*b3 + 15add.\n        double() {\n            const { a, b } = CURVE;\n            const b3 = Fp.mul(b, _3n);\n            const { X: X1, Y: Y1, Z: Z1 } = this;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            let t0 = Fp.mul(X1, X1); // step 1\n            let t1 = Fp.mul(Y1, Y1);\n            let t2 = Fp.mul(Z1, Z1);\n            let t3 = Fp.mul(X1, Y1);\n            t3 = Fp.add(t3, t3); // step 5\n            Z3 = Fp.mul(X1, Z1);\n            Z3 = Fp.add(Z3, Z3);\n            X3 = Fp.mul(a, Z3);\n            Y3 = Fp.mul(b3, t2);\n            Y3 = Fp.add(X3, Y3); // step 10\n            X3 = Fp.sub(t1, Y3);\n            Y3 = Fp.add(t1, Y3);\n            Y3 = Fp.mul(X3, Y3);\n            X3 = Fp.mul(t3, X3);\n            Z3 = Fp.mul(b3, Z3); // step 15\n            t2 = Fp.mul(a, t2);\n            t3 = Fp.sub(t0, t2);\n            t3 = Fp.mul(a, t3);\n            t3 = Fp.add(t3, Z3);\n            Z3 = Fp.add(t0, t0); // step 20\n            t0 = Fp.add(Z3, t0);\n            t0 = Fp.add(t0, t2);\n            t0 = Fp.mul(t0, t3);\n            Y3 = Fp.add(Y3, t0);\n            t2 = Fp.mul(Y1, Z1); // step 25\n            t2 = Fp.add(t2, t2);\n            t0 = Fp.mul(t2, t3);\n            X3 = Fp.sub(X3, t0);\n            Z3 = Fp.mul(t2, t1);\n            Z3 = Fp.add(Z3, Z3); // step 30\n            Z3 = Fp.add(Z3, Z3);\n            return new Point(X3, Y3, Z3);\n        }\n        // Renes-Costello-Batina exception-free addition formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 1\n        // Cost: 12M + 0S + 3*a + 3*b3 + 23add.\n        add(other) {\n            aprjpoint(other);\n            const { X: X1, Y: Y1, Z: Z1 } = this;\n            const { X: X2, Y: Y2, Z: Z2 } = other;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            const a = CURVE.a;\n            const b3 = Fp.mul(CURVE.b, _3n);\n            let t0 = Fp.mul(X1, X2); // step 1\n            let t1 = Fp.mul(Y1, Y2);\n            let t2 = Fp.mul(Z1, Z2);\n            let t3 = Fp.add(X1, Y1);\n            let t4 = Fp.add(X2, Y2); // step 5\n            t3 = Fp.mul(t3, t4);\n            t4 = Fp.add(t0, t1);\n            t3 = Fp.sub(t3, t4);\n            t4 = Fp.add(X1, Z1);\n            let t5 = Fp.add(X2, Z2); // step 10\n            t4 = Fp.mul(t4, t5);\n            t5 = Fp.add(t0, t2);\n            t4 = Fp.sub(t4, t5);\n            t5 = Fp.add(Y1, Z1);\n            X3 = Fp.add(Y2, Z2); // step 15\n            t5 = Fp.mul(t5, X3);\n            X3 = Fp.add(t1, t2);\n            t5 = Fp.sub(t5, X3);\n            Z3 = Fp.mul(a, t4);\n            X3 = Fp.mul(b3, t2); // step 20\n            Z3 = Fp.add(X3, Z3);\n            X3 = Fp.sub(t1, Z3);\n            Z3 = Fp.add(t1, Z3);\n            Y3 = Fp.mul(X3, Z3);\n            t1 = Fp.add(t0, t0); // step 25\n            t1 = Fp.add(t1, t0);\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.mul(b3, t4);\n            t1 = Fp.add(t1, t2);\n            t2 = Fp.sub(t0, t2); // step 30\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.add(t4, t2);\n            t0 = Fp.mul(t1, t4);\n            Y3 = Fp.add(Y3, t0);\n            t0 = Fp.mul(t5, t4); // step 35\n            X3 = Fp.mul(t3, X3);\n            X3 = Fp.sub(X3, t0);\n            t0 = Fp.mul(t3, t1);\n            Z3 = Fp.mul(t5, Z3);\n            Z3 = Fp.add(Z3, t0); // step 40\n            return new Point(X3, Y3, Z3);\n        }\n        subtract(other) {\n            return this.add(other.negate());\n        }\n        is0() {\n            return this.equals(Point.ZERO);\n        }\n        /**\n         * Constant time multiplication.\n         * Uses wNAF method. Windowed method may be 10% faster,\n         * but takes 2x longer to generate and consumes 2x memory.\n         * Uses precomputes when available.\n         * Uses endomorphism for Koblitz curves.\n         * @param scalar by which the point would be multiplied\n         * @returns New point\n         */\n        multiply(scalar) {\n            const { endo } = extraOpts;\n            if (!Fn.isValidNot0(scalar))\n                throw new Error('invalid scalar: out of range'); // 0 is invalid\n            let point, fake; // Fake point is used to const-time mult\n            const mul = (n) => wnaf.cached(this, n, (p) => normalizeZ(Point, p));\n            /** See docs for {@link EndomorphismOpts} */\n            if (endo) {\n                const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);\n                const { p: k1p, f: k1f } = mul(k1);\n                const { p: k2p, f: k2f } = mul(k2);\n                fake = k1f.add(k2f);\n                point = finishEndo(endo.beta, k1p, k2p, k1neg, k2neg);\n            }\n            else {\n                const { p, f } = mul(scalar);\n                point = p;\n                fake = f;\n            }\n            // Normalize `z` for both points, but return only real one\n            return normalizeZ(Point, [point, fake])[0];\n        }\n        /**\n         * Non-constant-time multiplication. Uses double-and-add algorithm.\n         * It's faster, but should only be used when you don't care about\n         * an exposed secret key e.g. sig verification, which works over *public* keys.\n         */\n        multiplyUnsafe(sc) {\n            const { endo } = extraOpts;\n            const p = this;\n            if (!Fn.isValid(sc))\n                throw new Error('invalid scalar: out of range'); // 0 is valid\n            if (sc === _0n || p.is0())\n                return Point.ZERO;\n            if (sc === _1n)\n                return p; // fast-path\n            if (wnaf.hasCache(this))\n                return this.multiply(sc);\n            if (endo) {\n                const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);\n                const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2); // 30% faster vs wnaf.unsafe\n                return finishEndo(endo.beta, p1, p2, k1neg, k2neg);\n            }\n            else {\n                return wnaf.unsafe(p, sc);\n            }\n        }\n        multiplyAndAddUnsafe(Q, a, b) {\n            const sum = this.multiplyUnsafe(a).add(Q.multiplyUnsafe(b));\n            return sum.is0() ? undefined : sum;\n        }\n        /**\n         * Converts Projective point to affine (x, y) coordinates.\n         * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch\n         */\n        toAffine(invertedZ) {\n            return toAffineMemo(this, invertedZ);\n        }\n        /**\n         * Checks whether Point is free of torsion elements (is in prime subgroup).\n         * Always torsion-free for cofactor=1 curves.\n         */\n        isTorsionFree() {\n            const { isTorsionFree } = extraOpts;\n            if (cofactor === _1n)\n                return true;\n            if (isTorsionFree)\n                return isTorsionFree(Point, this);\n            return wnaf.unsafe(this, CURVE_ORDER).is0();\n        }\n        clearCofactor() {\n            const { clearCofactor } = extraOpts;\n            if (cofactor === _1n)\n                return this; // Fast-path\n            if (clearCofactor)\n                return clearCofactor(Point, this);\n            return this.multiplyUnsafe(cofactor);\n        }\n        isSmallOrder() {\n            // can we use this.clearCofactor()?\n            return this.multiplyUnsafe(cofactor).is0();\n        }\n        toBytes(isCompressed = true) {\n            abool(isCompressed, 'isCompressed');\n            this.assertValidity();\n            return encodePoint(Point, this, isCompressed);\n        }\n        toHex(isCompressed = true) {\n            return bytesToHex(this.toBytes(isCompressed));\n        }\n        toString() {\n            return `<Point ${this.is0() ? 'ZERO' : this.toHex()}>`;\n        }\n        // TODO: remove\n        get px() {\n            return this.X;\n        }\n        get py() {\n            return this.X;\n        }\n        get pz() {\n            return this.Z;\n        }\n        toRawBytes(isCompressed = true) {\n            return this.toBytes(isCompressed);\n        }\n        _setWindowSize(windowSize) {\n            this.precompute(windowSize);\n        }\n        static normalizeZ(points) {\n            return normalizeZ(Point, points);\n        }\n        static msm(points, scalars) {\n            return pippenger(Point, Fn, points, scalars);\n        }\n        static fromPrivateKey(privateKey) {\n            return Point.BASE.multiply(_normFnElement(Fn, privateKey));\n        }\n    }\n    // base / generator point\n    Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n    // zero / infinity / identity point\n    Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO); // 0, 1, 0\n    // math field\n    Point.Fp = Fp;\n    // scalar field\n    Point.Fn = Fn;\n    const bits = Fn.BITS;\n    const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits);\n    Point.BASE.precompute(8); // Enable precomputes. Slows down first publicKey computation by 20ms.\n    return Point;\n}\n// Points start with byte 0x02 when y is even; otherwise 0x03\nfunction pprefix(hasEvenY) {\n    return Uint8Array.of(hasEvenY ? 0x02 : 0x03);\n}\n/**\n * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.\n * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.\n * b = True and y = sqrt(u / v) if (u / v) is square in F, and\n * b = False and y = sqrt(Z * (u / v)) otherwise.\n * @param Fp\n * @param Z\n * @returns\n */\nexport function SWUFpSqrtRatio(Fp, Z) {\n    // Generic implementation\n    const q = Fp.ORDER;\n    let l = _0n;\n    for (let o = q - _1n; o % _2n === _0n; o /= _2n)\n        l += _1n;\n    const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.\n    // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.\n    // 2n ** c1 == 2n << (c1-1)\n    const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);\n    const _2n_pow_c1 = _2n_pow_c1_1 * _2n;\n    const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic\n    const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic\n    const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic\n    const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic\n    const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2\n    const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)\n    let sqrtRatio = (u, v) => {\n        let tv1 = c6; // 1. tv1 = c6\n        let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4\n        let tv3 = Fp.sqr(tv2); // 3. tv3 = tv2^2\n        tv3 = Fp.mul(tv3, v); // 4. tv3 = tv3 * v\n        let tv5 = Fp.mul(u, tv3); // 5. tv5 = u * tv3\n        tv5 = Fp.pow(tv5, c3); // 6. tv5 = tv5^c3\n        tv5 = Fp.mul(tv5, tv2); // 7. tv5 = tv5 * tv2\n        tv2 = Fp.mul(tv5, v); // 8. tv2 = tv5 * v\n        tv3 = Fp.mul(tv5, u); // 9. tv3 = tv5 * u\n        let tv4 = Fp.mul(tv3, tv2); // 10. tv4 = tv3 * tv2\n        tv5 = Fp.pow(tv4, c5); // 11. tv5 = tv4^c5\n        let isQR = Fp.eql(tv5, Fp.ONE); // 12. isQR = tv5 == 1\n        tv2 = Fp.mul(tv3, c7); // 13. tv2 = tv3 * c7\n        tv5 = Fp.mul(tv4, tv1); // 14. tv5 = tv4 * tv1\n        tv3 = Fp.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)\n        tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)\n        // 17. for i in (c1, c1 - 1, ..., 2):\n        for (let i = c1; i > _1n; i--) {\n            let tv5 = i - _2n; // 18.    tv5 = i - 2\n            tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5\n            let tvv5 = Fp.pow(tv4, tv5); // 20.    tv5 = tv4^tv5\n            const e1 = Fp.eql(tvv5, Fp.ONE); // 21.    e1 = tv5 == 1\n            tv2 = Fp.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1\n            tv1 = Fp.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1\n            tvv5 = Fp.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1\n            tv3 = Fp.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)\n            tv4 = Fp.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)\n        }\n        return { isValid: isQR, value: tv3 };\n    };\n    if (Fp.ORDER % _4n === _3n) {\n        // sqrt_ratio_3mod4(u, v)\n        const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic\n        const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)\n        sqrtRatio = (u, v) => {\n            let tv1 = Fp.sqr(v); // 1. tv1 = v^2\n            const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n            tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n            let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n            y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n            const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n            const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n            const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n            let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n            return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n        };\n    }\n    // No curves uses that\n    // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n    return sqrtRatio;\n}\n/**\n * Simplified Shallue-van de Woestijne-Ulas Method\n * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2\n */\nexport function mapToCurveSimpleSWU(Fp, opts) {\n    validateField(Fp);\n    const { A, B, Z } = opts;\n    if (!Fp.isValid(A) || !Fp.isValid(B) || !Fp.isValid(Z))\n        throw new Error('mapToCurveSimpleSWU: invalid opts');\n    const sqrtRatio = SWUFpSqrtRatio(Fp, Z);\n    if (!Fp.isOdd)\n        throw new Error('Field does not have .isOdd()');\n    // Input: u, an element of F.\n    // Output: (x, y), a point on E.\n    return (u) => {\n        // prettier-ignore\n        let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n        tv1 = Fp.sqr(u); // 1.  tv1 = u^2\n        tv1 = Fp.mul(tv1, Z); // 2.  tv1 = Z * tv1\n        tv2 = Fp.sqr(tv1); // 3.  tv2 = tv1^2\n        tv2 = Fp.add(tv2, tv1); // 4.  tv2 = tv2 + tv1\n        tv3 = Fp.add(tv2, Fp.ONE); // 5.  tv3 = tv2 + 1\n        tv3 = Fp.mul(tv3, B); // 6.  tv3 = B * tv3\n        tv4 = Fp.cmov(Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)\n        tv4 = Fp.mul(tv4, A); // 8.  tv4 = A * tv4\n        tv2 = Fp.sqr(tv3); // 9.  tv2 = tv3^2\n        tv6 = Fp.sqr(tv4); // 10. tv6 = tv4^2\n        tv5 = Fp.mul(tv6, A); // 11. tv5 = A * tv6\n        tv2 = Fp.add(tv2, tv5); // 12. tv2 = tv2 + tv5\n        tv2 = Fp.mul(tv2, tv3); // 13. tv2 = tv2 * tv3\n        tv6 = Fp.mul(tv6, tv4); // 14. tv6 = tv6 * tv4\n        tv5 = Fp.mul(tv6, B); // 15. tv5 = B * tv6\n        tv2 = Fp.add(tv2, tv5); // 16. tv2 = tv2 + tv5\n        x = Fp.mul(tv1, tv3); // 17.   x = tv1 * tv3\n        const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)\n        y = Fp.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1\n        y = Fp.mul(y, value); // 20.   y = y * y1\n        x = Fp.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)\n        y = Fp.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)\n        const e1 = Fp.isOdd(u) === Fp.isOdd(y); // 23.  e1 = sgn0(u) == sgn0(y)\n        y = Fp.cmov(Fp.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)\n        const tv4_inv = FpInvertBatch(Fp, [tv4], true)[0];\n        x = Fp.mul(x, tv4_inv); // 25.   x = x / tv4\n        return { x, y };\n    };\n}\nfunction getWLengths(Fp, Fn) {\n    return {\n        secretKey: Fn.BYTES,\n        publicKey: 1 + Fp.BYTES,\n        publicKeyUncompressed: 1 + 2 * Fp.BYTES,\n        publicKeyHasPrefix: true,\n        signature: 2 * Fn.BYTES,\n    };\n}\n/**\n * Sometimes users only need getPublicKey, getSharedSecret, and secret key handling.\n * This helper ensures no signature functionality is present. Less code, smaller bundle size.\n */\nexport function ecdh(Point, ecdhOpts = {}) {\n    const { Fn } = Point;\n    const randomBytes_ = ecdhOpts.randomBytes || randomBytesWeb;\n    const lengths = Object.assign(getWLengths(Point.Fp, Fn), { seed: getMinHashLength(Fn.ORDER) });\n    function isValidSecretKey(secretKey) {\n        try {\n            return !!_normFnElement(Fn, secretKey);\n        }\n        catch (error) {\n            return false;\n        }\n    }\n    function isValidPublicKey(publicKey, isCompressed) {\n        const { publicKey: comp, publicKeyUncompressed } = lengths;\n        try {\n            const l = publicKey.length;\n            if (isCompressed === true && l !== comp)\n                return false;\n            if (isCompressed === false && l !== publicKeyUncompressed)\n                return false;\n            return !!Point.fromBytes(publicKey);\n        }\n        catch (error) {\n            return false;\n        }\n    }\n    /**\n     * Produces cryptographically secure secret key from random of size\n     * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.\n     */\n    function randomSecretKey(seed = randomBytes_(lengths.seed)) {\n        return mapHashToField(abytes(seed, lengths.seed, 'seed'), Fn.ORDER);\n    }\n    /**\n     * Computes public key for a secret key. Checks for validity of the secret key.\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns Public key, full when isCompressed=false; short when isCompressed=true\n     */\n    function getPublicKey(secretKey, isCompressed = true) {\n        return Point.BASE.multiply(_normFnElement(Fn, secretKey)).toBytes(isCompressed);\n    }\n    function keygen(seed) {\n        const secretKey = randomSecretKey(seed);\n        return { secretKey, publicKey: getPublicKey(secretKey) };\n    }\n    /**\n     * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n     */\n    function isProbPub(item) {\n        if (typeof item === 'bigint')\n            return false;\n        if (item instanceof Point)\n            return true;\n        const { secretKey, publicKey, publicKeyUncompressed } = lengths;\n        if (Fn.allowedLengths || secretKey === publicKey)\n            return undefined;\n        const l = ensureBytes('key', item).length;\n        return l === publicKey || l === publicKeyUncompressed;\n    }\n    /**\n     * ECDH (Elliptic Curve Diffie Hellman).\n     * Computes shared public key from secret key A and public key B.\n     * Checks: 1) secret key validity 2) shared key is on-curve.\n     * Does NOT hash the result.\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns shared public key\n     */\n    function getSharedSecret(secretKeyA, publicKeyB, isCompressed = true) {\n        if (isProbPub(secretKeyA) === true)\n            throw new Error('first arg must be private key');\n        if (isProbPub(publicKeyB) === false)\n            throw new Error('second arg must be public key');\n        const s = _normFnElement(Fn, secretKeyA);\n        const b = Point.fromHex(publicKeyB); // checks for being on-curve\n        return b.multiply(s).toBytes(isCompressed);\n    }\n    const utils = {\n        isValidSecretKey,\n        isValidPublicKey,\n        randomSecretKey,\n        // TODO: remove\n        isValidPrivateKey: isValidSecretKey,\n        randomPrivateKey: randomSecretKey,\n        normPrivateKeyToScalar: (key) => _normFnElement(Fn, key),\n        precompute(windowSize = 8, point = Point.BASE) {\n            return point.precompute(windowSize, false);\n        },\n    };\n    return Object.freeze({ getPublicKey, getSharedSecret, keygen, Point, utils, lengths });\n}\n/**\n * Creates ECDSA signing interface for given elliptic curve `Point` and `hash` function.\n * We need `hash` for 2 features:\n * 1. Message prehash-ing. NOT used if `sign` / `verify` are called with `prehash: false`\n * 2. k generation in `sign`, using HMAC-drbg(hash)\n *\n * ECDSAOpts are only rarely needed.\n *\n * @example\n * ```js\n * const p256_Point = weierstrass(...);\n * const p256_sha256 = ecdsa(p256_Point, sha256);\n * const p256_sha224 = ecdsa(p256_Point, sha224);\n * const p256_sha224_r = ecdsa(p256_Point, sha224, { randomBytes: (length) => { ... } });\n * ```\n */\nexport function ecdsa(Point, hash, ecdsaOpts = {}) {\n    ahash(hash);\n    _validateObject(ecdsaOpts, {}, {\n        hmac: 'function',\n        lowS: 'boolean',\n        randomBytes: 'function',\n        bits2int: 'function',\n        bits2int_modN: 'function',\n    });\n    const randomBytes = ecdsaOpts.randomBytes || randomBytesWeb;\n    const hmac = ecdsaOpts.hmac ||\n        ((key, ...msgs) => nobleHmac(hash, key, concatBytes(...msgs)));\n    const { Fp, Fn } = Point;\n    const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;\n    const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);\n    const defaultSigOpts = {\n        prehash: false,\n        lowS: typeof ecdsaOpts.lowS === 'boolean' ? ecdsaOpts.lowS : false,\n        format: undefined, //'compact' as ECDSASigFormat,\n        extraEntropy: false,\n    };\n    const defaultSigOpts_format = 'compact';\n    function isBiggerThanHalfOrder(number) {\n        const HALF = CURVE_ORDER >> _1n;\n        return number > HALF;\n    }\n    function validateRS(title, num) {\n        if (!Fn.isValidNot0(num))\n            throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);\n        return num;\n    }\n    function validateSigLength(bytes, format) {\n        validateSigFormat(format);\n        const size = lengths.signature;\n        const sizer = format === 'compact' ? size : format === 'recovered' ? size + 1 : undefined;\n        return abytes(bytes, sizer, `${format} signature`);\n    }\n    /**\n     * ECDSA signature with its (r, s) properties. Supports compact, recovered & DER representations.\n     */\n    class Signature {\n        constructor(r, s, recovery) {\n            this.r = validateRS('r', r); // r in [1..N-1];\n            this.s = validateRS('s', s); // s in [1..N-1];\n            if (recovery != null)\n                this.recovery = recovery;\n            Object.freeze(this);\n        }\n        static fromBytes(bytes, format = defaultSigOpts_format) {\n            validateSigLength(bytes, format);\n            let recid;\n            if (format === 'der') {\n                const { r, s } = DER.toSig(abytes(bytes));\n                return new Signature(r, s);\n            }\n            if (format === 'recovered') {\n                recid = bytes[0];\n                format = 'compact';\n                bytes = bytes.subarray(1);\n            }\n            const L = Fn.BYTES;\n            const r = bytes.subarray(0, L);\n            const s = bytes.subarray(L, L * 2);\n            return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid);\n        }\n        static fromHex(hex, format) {\n            return this.fromBytes(hexToBytes(hex), format);\n        }\n        addRecoveryBit(recovery) {\n            return new Signature(this.r, this.s, recovery);\n        }\n        recoverPublicKey(messageHash) {\n            const FIELD_ORDER = Fp.ORDER;\n            const { r, s, recovery: rec } = this;\n            if (rec == null || ![0, 1, 2, 3].includes(rec))\n                throw new Error('recovery id invalid');\n            // ECDSA recovery is hard for cofactor > 1 curves.\n            // In sign, `r = q.x mod n`, and here we recover q.x from r.\n            // While recovering q.x >= n, we need to add r+n for cofactor=1 curves.\n            // However, for cofactor>1, r+n may not get q.x:\n            // r+n*i would need to be done instead where i is unknown.\n            // To easily get i, we either need to:\n            // a. increase amount of valid recid values (4, 5...); OR\n            // b. prohibit non-prime-order signatures (recid > 1).\n            const hasCofactor = CURVE_ORDER * _2n < FIELD_ORDER;\n            if (hasCofactor && rec > 1)\n                throw new Error('recovery id is ambiguous for h>1 curve');\n            const radj = rec === 2 || rec === 3 ? r + CURVE_ORDER : r;\n            if (!Fp.isValid(radj))\n                throw new Error('recovery id 2 or 3 invalid');\n            const x = Fp.toBytes(radj);\n            const R = Point.fromBytes(concatBytes(pprefix((rec & 1) === 0), x));\n            const ir = Fn.inv(radj); // r^-1\n            const h = bits2int_modN(ensureBytes('msgHash', messageHash)); // Truncate hash\n            const u1 = Fn.create(-h * ir); // -hr^-1\n            const u2 = Fn.create(s * ir); // sr^-1\n            // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1). unsafe is fine: there is no private data.\n            const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));\n            if (Q.is0())\n                throw new Error('point at infinify');\n            Q.assertValidity();\n            return Q;\n        }\n        // Signatures should be low-s, to prevent malleability.\n        hasHighS() {\n            return isBiggerThanHalfOrder(this.s);\n        }\n        toBytes(format = defaultSigOpts_format) {\n            validateSigFormat(format);\n            if (format === 'der')\n                return hexToBytes(DER.hexFromSig(this));\n            const r = Fn.toBytes(this.r);\n            const s = Fn.toBytes(this.s);\n            if (format === 'recovered') {\n                if (this.recovery == null)\n                    throw new Error('recovery bit must be present');\n                return concatBytes(Uint8Array.of(this.recovery), r, s);\n            }\n            return concatBytes(r, s);\n        }\n        toHex(format) {\n            return bytesToHex(this.toBytes(format));\n        }\n        // TODO: remove\n        assertValidity() { }\n        static fromCompact(hex) {\n            return Signature.fromBytes(ensureBytes('sig', hex), 'compact');\n        }\n        static fromDER(hex) {\n            return Signature.fromBytes(ensureBytes('sig', hex), 'der');\n        }\n        normalizeS() {\n            return this.hasHighS() ? new Signature(this.r, Fn.neg(this.s), this.recovery) : this;\n        }\n        toDERRawBytes() {\n            return this.toBytes('der');\n        }\n        toDERHex() {\n            return bytesToHex(this.toBytes('der'));\n        }\n        toCompactRawBytes() {\n            return this.toBytes('compact');\n        }\n        toCompactHex() {\n            return bytesToHex(this.toBytes('compact'));\n        }\n    }\n    // RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.\n    // FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.\n    // bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.\n    // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors\n    const bits2int = ecdsaOpts.bits2int ||\n        function bits2int_def(bytes) {\n            // Our custom check \"just in case\", for protection against DoS\n            if (bytes.length > 8192)\n                throw new Error('input is too large');\n            // For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)\n            // for some cases, since bytes.length * 8 is not actual bitLength.\n            const num = bytesToNumberBE(bytes); // check for == u8 done here\n            const delta = bytes.length * 8 - fnBits; // truncate to nBitLength leftmost bits\n            return delta > 0 ? num >> BigInt(delta) : num;\n        };\n    const bits2int_modN = ecdsaOpts.bits2int_modN ||\n        function bits2int_modN_def(bytes) {\n            return Fn.create(bits2int(bytes)); // can't use bytesToNumberBE here\n        };\n    // Pads output with zero as per spec\n    const ORDER_MASK = bitMask(fnBits);\n    /** Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`. */\n    function int2octets(num) {\n        // IMPORTANT: the check ensures working for case `Fn.BYTES != Fn.BITS * 8`\n        aInRange('num < 2^' + fnBits, num, _0n, ORDER_MASK);\n        return Fn.toBytes(num);\n    }\n    function validateMsgAndHash(message, prehash) {\n        abytes(message, undefined, 'message');\n        return prehash ? abytes(hash(message), undefined, 'prehashed message') : message;\n    }\n    /**\n     * Steps A, D of RFC6979 3.2.\n     * Creates RFC6979 seed; converts msg/privKey to numbers.\n     * Used only in sign, not in verify.\n     *\n     * Warning: we cannot assume here that message has same amount of bytes as curve order,\n     * this will be invalid at least for P521. Also it can be bigger for P224 + SHA256.\n     */\n    function prepSig(message, privateKey, opts) {\n        if (['recovered', 'canonical'].some((k) => k in opts))\n            throw new Error('sign() legacy options not supported');\n        const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts);\n        message = validateMsgAndHash(message, prehash); // RFC6979 3.2 A: h1 = H(m)\n        // We can't later call bits2octets, since nested bits2int is broken for curves\n        // with fnBits % 8 !== 0. Because of that, we unwrap it here as int2octets call.\n        // const bits2octets = (bits) => int2octets(bits2int_modN(bits))\n        const h1int = bits2int_modN(message);\n        const d = _normFnElement(Fn, privateKey); // validate secret key, convert to bigint\n        const seedArgs = [int2octets(d), int2octets(h1int)];\n        // extraEntropy. RFC6979 3.6: additional k' (optional).\n        if (extraEntropy != null && extraEntropy !== false) {\n            // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')\n            // gen random bytes OR pass as-is\n            const e = extraEntropy === true ? randomBytes(lengths.secretKey) : extraEntropy;\n            seedArgs.push(ensureBytes('extraEntropy', e)); // check for being bytes\n        }\n        const seed = concatBytes(...seedArgs); // Step D of RFC6979 3.2\n        const m = h1int; // NOTE: no need to call bits2int second time here, it is inside truncateHash!\n        // Converts signature params into point w r/s, checks result for validity.\n        // To transform k => Signature:\n        // q = k⋅G\n        // r = q.x mod n\n        // s = k^-1(m + rd) mod n\n        // Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to\n        // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:\n        // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT\n        function k2sig(kBytes) {\n            // RFC 6979 Section 3.2, step 3: k = bits2int(T)\n            // Important: all mod() calls here must be done over N\n            const k = bits2int(kBytes); // mod n, not mod p\n            if (!Fn.isValidNot0(k))\n                return; // Valid scalars (including k) must be in 1..N-1\n            const ik = Fn.inv(k); // k^-1 mod n\n            const q = Point.BASE.multiply(k).toAffine(); // q = k⋅G\n            const r = Fn.create(q.x); // r = q.x mod n\n            if (r === _0n)\n                return;\n            const s = Fn.create(ik * Fn.create(m + r * d)); // Not using blinding here, see comment above\n            if (s === _0n)\n                return;\n            let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3, when q.x > n)\n            let normS = s;\n            if (lowS && isBiggerThanHalfOrder(s)) {\n                normS = Fn.neg(s); // if lowS was passed, ensure s is always\n                recovery ^= 1; // // in the bottom half of N\n            }\n            return new Signature(r, normS, recovery); // use normS, not s\n        }\n        return { seed, k2sig };\n    }\n    /**\n     * Signs message hash with a secret key.\n     *\n     * ```\n     * sign(m, d) where\n     *   k = rfc6979_hmac_drbg(m, d)\n     *   (x, y) = G × k\n     *   r = x mod n\n     *   s = (m + dr) / k mod n\n     * ```\n     */\n    function sign(message, secretKey, opts = {}) {\n        message = ensureBytes('message', message);\n        const { seed, k2sig } = prepSig(message, secretKey, opts); // Steps A, D of RFC6979 3.2.\n        const drbg = createHmacDrbg(hash.outputLen, Fn.BYTES, hmac);\n        const sig = drbg(seed, k2sig); // Steps B, C, D, E, F, G\n        return sig;\n    }\n    function tryParsingSig(sg) {\n        // Try to deduce format\n        let sig = undefined;\n        const isHex = typeof sg === 'string' || isBytes(sg);\n        const isObj = !isHex &&\n            sg !== null &&\n            typeof sg === 'object' &&\n            typeof sg.r === 'bigint' &&\n            typeof sg.s === 'bigint';\n        if (!isHex && !isObj)\n            throw new Error('invalid signature, expected Uint8Array, hex string or Signature instance');\n        if (isObj) {\n            sig = new Signature(sg.r, sg.s);\n        }\n        else if (isHex) {\n            try {\n                sig = Signature.fromBytes(ensureBytes('sig', sg), 'der');\n            }\n            catch (derError) {\n                if (!(derError instanceof DER.Err))\n                    throw derError;\n            }\n            if (!sig) {\n                try {\n                    sig = Signature.fromBytes(ensureBytes('sig', sg), 'compact');\n                }\n                catch (error) {\n                    return false;\n                }\n            }\n        }\n        if (!sig)\n            return false;\n        return sig;\n    }\n    /**\n     * Verifies a signature against message and public key.\n     * Rejects lowS signatures by default: see {@link ECDSAVerifyOpts}.\n     * Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:\n     *\n     * ```\n     * verify(r, s, h, P) where\n     *   u1 = hs^-1 mod n\n     *   u2 = rs^-1 mod n\n     *   R = u1⋅G + u2⋅P\n     *   mod(R.x, n) == r\n     * ```\n     */\n    function verify(signature, message, publicKey, opts = {}) {\n        const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);\n        publicKey = ensureBytes('publicKey', publicKey);\n        message = validateMsgAndHash(ensureBytes('message', message), prehash);\n        if ('strict' in opts)\n            throw new Error('options.strict was renamed to lowS');\n        const sig = format === undefined\n            ? tryParsingSig(signature)\n            : Signature.fromBytes(ensureBytes('sig', signature), format);\n        if (sig === false)\n            return false;\n        try {\n            const P = Point.fromBytes(publicKey);\n            if (lowS && sig.hasHighS())\n                return false;\n            const { r, s } = sig;\n            const h = bits2int_modN(message); // mod n, not mod p\n            const is = Fn.inv(s); // s^-1 mod n\n            const u1 = Fn.create(h * is); // u1 = hs^-1 mod n\n            const u2 = Fn.create(r * is); // u2 = rs^-1 mod n\n            const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2)); // u1⋅G + u2⋅P\n            if (R.is0())\n                return false;\n            const v = Fn.create(R.x); // v = r.x mod n\n            return v === r;\n        }\n        catch (e) {\n            return false;\n        }\n    }\n    function recoverPublicKey(signature, message, opts = {}) {\n        const { prehash } = validateSigOpts(opts, defaultSigOpts);\n        message = validateMsgAndHash(message, prehash);\n        return Signature.fromBytes(signature, 'recovered').recoverPublicKey(message).toBytes();\n    }\n    return Object.freeze({\n        keygen,\n        getPublicKey,\n        getSharedSecret,\n        utils,\n        lengths,\n        Point,\n        sign,\n        verify,\n        recoverPublicKey,\n        Signature,\n        hash,\n    });\n}\n/** @deprecated use `weierstrass` in newer releases */\nexport function weierstrassPoints(c) {\n    const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c);\n    const Point = weierstrassN(CURVE, curveOpts);\n    return _weierstrass_new_output_to_legacy(c, Point);\n}\nfunction _weierstrass_legacy_opts_to_new(c) {\n    const CURVE = {\n        a: c.a,\n        b: c.b,\n        p: c.Fp.ORDER,\n        n: c.n,\n        h: c.h,\n        Gx: c.Gx,\n        Gy: c.Gy,\n    };\n    const Fp = c.Fp;\n    let allowedLengths = c.allowedPrivateKeyLengths\n        ? Array.from(new Set(c.allowedPrivateKeyLengths.map((l) => Math.ceil(l / 2))))\n        : undefined;\n    const Fn = Field(CURVE.n, {\n        BITS: c.nBitLength,\n        allowedLengths: allowedLengths,\n        modFromBytes: c.wrapPrivateKey,\n    });\n    const curveOpts = {\n        Fp,\n        Fn,\n        allowInfinityPoint: c.allowInfinityPoint,\n        endo: c.endo,\n        isTorsionFree: c.isTorsionFree,\n        clearCofactor: c.clearCofactor,\n        fromBytes: c.fromBytes,\n        toBytes: c.toBytes,\n    };\n    return { CURVE, curveOpts };\n}\nfunction _ecdsa_legacy_opts_to_new(c) {\n    const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c);\n    const ecdsaOpts = {\n        hmac: c.hmac,\n        randomBytes: c.randomBytes,\n        lowS: c.lowS,\n        bits2int: c.bits2int,\n        bits2int_modN: c.bits2int_modN,\n    };\n    return { CURVE, curveOpts, hash: c.hash, ecdsaOpts };\n}\nexport function _legacyHelperEquat(Fp, a, b) {\n    /**\n     * y² = x³ + ax + b: Short weierstrass curve formula. Takes x, returns y².\n     * @returns y²\n     */\n    function weierstrassEquation(x) {\n        const x2 = Fp.sqr(x); // x * x\n        const x3 = Fp.mul(x2, x); // x² * x\n        return Fp.add(Fp.add(x3, Fp.mul(x, a)), b); // x³ + a * x + b\n    }\n    return weierstrassEquation;\n}\nfunction _weierstrass_new_output_to_legacy(c, Point) {\n    const { Fp, Fn } = Point;\n    function isWithinCurveOrder(num) {\n        return inRange(num, _1n, Fn.ORDER);\n    }\n    const weierstrassEquation = _legacyHelperEquat(Fp, c.a, c.b);\n    return Object.assign({}, {\n        CURVE: c,\n        Point: Point,\n        ProjectivePoint: Point,\n        normPrivateKeyToScalar: (key) => _normFnElement(Fn, key),\n        weierstrassEquation,\n        isWithinCurveOrder,\n    });\n}\nfunction _ecdsa_new_output_to_legacy(c, _ecdsa) {\n    const Point = _ecdsa.Point;\n    return Object.assign({}, _ecdsa, {\n        ProjectivePoint: Point,\n        CURVE: Object.assign({}, c, nLength(Point.Fn.ORDER, Point.Fn.BITS)),\n    });\n}\n// _ecdsa_legacy\nexport function weierstrass(c) {\n    const { CURVE, curveOpts, hash, ecdsaOpts } = _ecdsa_legacy_opts_to_new(c);\n    const Point = weierstrassN(CURVE, curveOpts);\n    const signs = ecdsa(Point, hash, ecdsaOpts);\n    return _ecdsa_new_output_to_legacy(c, signs);\n}\n//# sourceMappingURL=weierstrass.js.map","/**\n * Utilities for short weierstrass curves, combined with noble-hashes.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { weierstrass } from \"./abstract/weierstrass.js\";\n/** connects noble-curves to noble-hashes */\nexport function getHash(hash) {\n    return { hash };\n}\n/** @deprecated use new `weierstrass()` and `ecdsa()` methods */\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, hash: hash });\n    return { ...create(defHash), create };\n}\n//# sourceMappingURL=_shortw_utils.js.map","/**\n * SECG secp256k1. See [pdf](https://www.secg.org/sec2-v2.pdf).\n *\n * Belongs to Koblitz curves: it has efficiently-computable GLV endomorphism ψ,\n * check out {@link EndomorphismOpts}. Seems to be rigid (not backdoored).\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { randomBytes } from '@noble/hashes/utils.js';\nimport { createCurve } from \"./_shortw_utils.js\";\nimport { createHasher, isogenyMap, } from \"./abstract/hash-to-curve.js\";\nimport { Field, mapHashToField, mod, pow2 } from \"./abstract/modular.js\";\nimport { _normFnElement, mapToCurveSimpleSWU, } from \"./abstract/weierstrass.js\";\nimport { bytesToNumberBE, concatBytes, ensureBytes, inRange, numberToBytesBE, utf8ToBytes, } from \"./utils.js\";\n// Seems like generator was produced from some seed:\n// `Point.BASE.multiply(Point.Fn.inv(2n, N)).toAffine().x`\n// // gives short x 0x3b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63n\nconst secp256k1_CURVE = {\n    p: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),\n    n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),\n    h: BigInt(1),\n    a: BigInt(0),\n    b: BigInt(7),\n    Gx: BigInt('0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),\n    Gy: BigInt('0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'),\n};\nconst secp256k1_ENDO = {\n    beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n    basises: [\n        [BigInt('0x3086d221a7d46bcde86c90e49284eb15'), -BigInt('0xe4437ed6010e88286f547fa90abfe4c3')],\n        [BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8'), BigInt('0x3086d221a7d46bcde86c90e49284eb15')],\n    ],\n};\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\n/**\n * √n = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.\n * (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]\n */\nfunction sqrtMod(y) {\n    const P = secp256k1_CURVE.p;\n    // prettier-ignore\n    const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);\n    // prettier-ignore\n    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);\n    const b2 = (y * y * y) % P; // x^3, 11\n    const b3 = (b2 * b2 * y) % P; // x^7\n    const b6 = (pow2(b3, _3n, P) * b3) % P;\n    const b9 = (pow2(b6, _3n, P) * b3) % P;\n    const b11 = (pow2(b9, _2n, P) * b2) % P;\n    const b22 = (pow2(b11, _11n, P) * b11) % P;\n    const b44 = (pow2(b22, _22n, P) * b22) % P;\n    const b88 = (pow2(b44, _44n, P) * b44) % P;\n    const b176 = (pow2(b88, _88n, P) * b88) % P;\n    const b220 = (pow2(b176, _44n, P) * b44) % P;\n    const b223 = (pow2(b220, _3n, P) * b3) % P;\n    const t1 = (pow2(b223, _23n, P) * b22) % P;\n    const t2 = (pow2(t1, _6n, P) * b2) % P;\n    const root = pow2(t2, _2n, P);\n    if (!Fpk1.eql(Fpk1.sqr(root), y))\n        throw new Error('Cannot find square root');\n    return root;\n}\nconst Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });\n/**\n * secp256k1 curve, ECDSA and ECDH methods.\n *\n * Field: `2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n`\n *\n * @example\n * ```js\n * import { secp256k1 } from '@noble/curves/secp256k1';\n * const { secretKey, publicKey } = secp256k1.keygen();\n * const msg = new TextEncoder().encode('hello');\n * const sig = secp256k1.sign(msg, secretKey);\n * const isValid = secp256k1.verify(sig, msg, publicKey) === true;\n * ```\n */\nexport const secp256k1 = createCurve({ ...secp256k1_CURVE, Fp: Fpk1, lowS: true, endo: secp256k1_ENDO }, sha256);\n// Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.\n// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */\nconst TAGGED_HASH_PREFIXES = {};\nfunction taggedHash(tag, ...messages) {\n    let tagP = TAGGED_HASH_PREFIXES[tag];\n    if (tagP === undefined) {\n        const tagH = sha256(utf8ToBytes(tag));\n        tagP = concatBytes(tagH, tagH);\n        TAGGED_HASH_PREFIXES[tag] = tagP;\n    }\n    return sha256(concatBytes(tagP, ...messages));\n}\n// ECDSA compact points are 33-byte. Schnorr is 32: we strip first byte 0x02 or 0x03\nconst pointToBytes = (point) => point.toBytes(true).slice(1);\nconst Pointk1 = /* @__PURE__ */ (() => secp256k1.Point)();\nconst hasEven = (y) => y % _2n === _0n;\n// Calculate point, scalar and bytes\nfunction schnorrGetExtPubKey(priv) {\n    const { Fn, BASE } = Pointk1;\n    const d_ = _normFnElement(Fn, priv);\n    const p = BASE.multiply(d_); // P = d'⋅G; 0 < d' < n check is done inside\n    const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);\n    return { scalar, bytes: pointToBytes(p) };\n}\n/**\n * lift_x from BIP340. Convert 32-byte x coordinate to elliptic curve point.\n * @returns valid point checked for being on-curve\n */\nfunction lift_x(x) {\n    const Fp = Fpk1;\n    if (!Fp.isValidNot0(x))\n        throw new Error('invalid x: Fail if x ≥ p');\n    const xx = Fp.create(x * x);\n    const c = Fp.create(xx * x + BigInt(7)); // Let c = x³ + 7 mod p.\n    let y = Fp.sqrt(c); // Let y = c^(p+1)/4 mod p. Same as sqrt().\n    // Return the unique point P such that x(P) = x and\n    // y(P) = y if y mod 2 = 0 or y(P) = p-y otherwise.\n    if (!hasEven(y))\n        y = Fp.neg(y);\n    const p = Pointk1.fromAffine({ x, y });\n    p.assertValidity();\n    return p;\n}\nconst num = bytesToNumberBE;\n/**\n * Create tagged hash, convert it to bigint, reduce modulo-n.\n */\nfunction challenge(...args) {\n    return Pointk1.Fn.create(num(taggedHash('BIP0340/challenge', ...args)));\n}\n/**\n * Schnorr public key is just `x` coordinate of Point as per BIP340.\n */\nfunction schnorrGetPublicKey(secretKey) {\n    return schnorrGetExtPubKey(secretKey).bytes; // d'=int(sk). Fail if d'=0 or d'≥n. Ret bytes(d'⋅G)\n}\n/**\n * Creates Schnorr signature as per BIP340. Verifies itself before returning anything.\n * auxRand is optional and is not the sole source of k generation: bad CSPRNG won't be dangerous.\n */\nfunction schnorrSign(message, secretKey, auxRand = randomBytes(32)) {\n    const { Fn } = Pointk1;\n    const m = ensureBytes('message', message);\n    const { bytes: px, scalar: d } = schnorrGetExtPubKey(secretKey); // checks for isWithinCurveOrder\n    const a = ensureBytes('auxRand', auxRand, 32); // Auxiliary random data a: a 32-byte array\n    const t = Fn.toBytes(d ^ num(taggedHash('BIP0340/aux', a))); // Let t be the byte-wise xor of bytes(d) and hash/aux(a)\n    const rand = taggedHash('BIP0340/nonce', t, px, m); // Let rand = hash/nonce(t || bytes(P) || m)\n    // Let k' = int(rand) mod n. Fail if k' = 0. Let R = k'⋅G\n    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(rand);\n    const e = challenge(rx, px, m); // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.\n    const sig = new Uint8Array(64); // Let sig = bytes(R) || bytes((k + ed) mod n).\n    sig.set(rx, 0);\n    sig.set(Fn.toBytes(Fn.create(k + e * d)), 32);\n    // If Verify(bytes(P), m, sig) (see below) returns failure, abort\n    if (!schnorrVerify(sig, m, px))\n        throw new Error('sign: Invalid signature produced');\n    return sig;\n}\n/**\n * Verifies Schnorr signature.\n * Will swallow errors & return false except for initial type validation of arguments.\n */\nfunction schnorrVerify(signature, message, publicKey) {\n    const { Fn, BASE } = Pointk1;\n    const sig = ensureBytes('signature', signature, 64);\n    const m = ensureBytes('message', message);\n    const pub = ensureBytes('publicKey', publicKey, 32);\n    try {\n        const P = lift_x(num(pub)); // P = lift_x(int(pk)); fail if that fails\n        const r = num(sig.subarray(0, 32)); // Let r = int(sig[0:32]); fail if r ≥ p.\n        if (!inRange(r, _1n, secp256k1_CURVE.p))\n            return false;\n        const s = num(sig.subarray(32, 64)); // Let s = int(sig[32:64]); fail if s ≥ n.\n        if (!inRange(s, _1n, secp256k1_CURVE.n))\n            return false;\n        // int(challenge(bytes(r)||bytes(P)||m))%n\n        const e = challenge(Fn.toBytes(r), pointToBytes(P), m);\n        // R = s⋅G - e⋅P, where -eP == (n-e)P\n        const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));\n        const { x, y } = R.toAffine();\n        // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.\n        if (R.is0() || !hasEven(y) || x !== r)\n            return false;\n        return true;\n    }\n    catch (error) {\n        return false;\n    }\n}\n/**\n * Schnorr signatures over secp256k1.\n * https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n * @example\n * ```js\n * import { schnorr } from '@noble/curves/secp256k1';\n * const { secretKey, publicKey } = schnorr.keygen();\n * // const publicKey = schnorr.getPublicKey(secretKey);\n * const msg = new TextEncoder().encode('hello');\n * const sig = schnorr.sign(msg, secretKey);\n * const isValid = schnorr.verify(sig, msg, publicKey);\n * ```\n */\nexport const schnorr = /* @__PURE__ */ (() => {\n    const size = 32;\n    const seedLength = 48;\n    const randomSecretKey = (seed = randomBytes(seedLength)) => {\n        return mapHashToField(seed, secp256k1_CURVE.n);\n    };\n    // TODO: remove\n    secp256k1.utils.randomSecretKey;\n    function keygen(seed) {\n        const secretKey = randomSecretKey(seed);\n        return { secretKey, publicKey: schnorrGetPublicKey(secretKey) };\n    }\n    return {\n        keygen,\n        getPublicKey: schnorrGetPublicKey,\n        sign: schnorrSign,\n        verify: schnorrVerify,\n        Point: Pointk1,\n        utils: {\n            randomSecretKey: randomSecretKey,\n            randomPrivateKey: randomSecretKey,\n            taggedHash,\n            // TODO: remove\n            lift_x,\n            pointToBytes,\n            numberToBytesBE,\n            bytesToNumberBE,\n            mod,\n        },\n        lengths: {\n            secretKey: size,\n            publicKey: size,\n            publicKeyHasPrefix: false,\n            signature: size * 2,\n            seed: seedLength,\n        },\n    };\n})();\nconst isoMap = /* @__PURE__ */ (() => isogenyMap(Fpk1, [\n    // xNum\n    [\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7',\n        '0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581',\n        '0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262',\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c',\n    ],\n    // xDen\n    [\n        '0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b',\n        '0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n    // yNum\n    [\n        '0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c',\n        '0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3',\n        '0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931',\n        '0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84',\n    ],\n    // yDen\n    [\n        '0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b',\n        '0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573',\n        '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n].map((i) => i.map((j) => BigInt(j)))))();\nconst mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fpk1, {\n    A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),\n    B: BigInt('1771'),\n    Z: Fpk1.create(BigInt('-11')),\n}))();\n/** Hashing / encoding to secp256k1 points / field. RFC 9380 methods. */\nexport const secp256k1_hasher = /* @__PURE__ */ (() => createHasher(secp256k1.Point, (scalars) => {\n    const { x, y } = mapSWU(Fpk1.create(scalars[0]));\n    return isoMap(x, y);\n}, {\n    DST: 'secp256k1_XMD:SHA-256_SSWU_RO_',\n    encodeDST: 'secp256k1_XMD:SHA-256_SSWU_NU_',\n    p: Fpk1.ORDER,\n    m: 1,\n    k: 128,\n    expand: 'xmd',\n    hash: sha256,\n}))();\n/** @deprecated use `import { secp256k1_hasher } from '@noble/curves/secp256k1.js';` */\nexport const hashToCurve = /* @__PURE__ */ (() => secp256k1_hasher.hashToCurve)();\n/** @deprecated use `import { secp256k1_hasher } from '@noble/curves/secp256k1.js';` */\nexport const encodeToCurve = /* @__PURE__ */ (() => secp256k1_hasher.encodeToCurve)();\n//# sourceMappingURL=secp256k1.js.map","import { schnorr, secp256k1 } from \"@noble/curves/secp256k1.js\";\nimport { ripemd160 } from \"@noble/hashes/legacy.js\";\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport { bytesToHex, hexToBytes } from \"@noble/hashes/utils.js\";\nimport type { Hex } from \"viem\";\n\nimport { MAX_PAYOUT_SCRIPT_LEN } from \"../../primitives/psbt/constants\";\nimport { assertOnChainBtcPubkey } from \"./onChainBtcPubkey\";\n\nconst P2TR_SCRIPT_PREFIX = \"5120\";\nconst P2WPKH_SCRIPT_PREFIX = \"0014\";\nconst HASH160_BYTES = 20;\nconst COMPRESSED_PUBKEY_BYTES = 33;\nconst UNCOMPRESSED_PUBKEY_BYTES = 65;\nconst SEC1_EVEN_Y_PREFIX = 0x02;\nconst SEC1_ODD_Y_PREFIX = 0x03;\nconst SEC1_UNCOMPRESSED_PREFIX = 0x04;\n\nfunction normalizeHex(value: string, label: string): Hex {\n  const body =\n    value.startsWith(\"0x\") || value.startsWith(\"0X\") ? value.slice(2) : value;\n  if (!/^(?:[0-9a-fA-F]{2})+$/.test(body)) {\n    throw new Error(`${label} must be non-empty, even-length hex`);\n  }\n  return `0x${body.toLowerCase()}`;\n}\n\nfunction deriveP2trScript(xOnlyPubkey: string): Hex {\n  const pubkeyBytes = hexToBytes(xOnlyPubkey);\n  const internalKey = schnorr.utils.lift_x(BigInt(`0x${xOnlyPubkey}`));\n  const tweak = schnorr.utils.bytesToNumberBE(\n    schnorr.utils.taggedHash(\"TapTweak\", pubkeyBytes),\n  );\n  if (tweak >= secp256k1.CURVE.n) {\n    throw new Error(\"Proof of possession BTC pubkey has an invalid TapTweak\");\n  }\n  const outputKey =\n    tweak === 0n\n      ? internalKey\n      : internalKey.add(schnorr.Point.BASE.multiply(tweak));\n  return `0x${P2TR_SCRIPT_PREFIX}${bytesToHex(\n    schnorr.utils.pointToBytes(outputKey),\n  )}`;\n}\n\nfunction normalizePayoutPubkey(value: string): {\n  xOnlyPubkey: string;\n  compressedPubkey?: Uint8Array;\n} {\n  const normalized = normalizeHex(value, \"depositorBtcPubkeyRaw\");\n  const pubkey = hexToBytes(normalized.slice(2));\n  if (pubkey.length === 32) {\n    return {\n      xOnlyPubkey: assertOnChainBtcPubkey(normalized, \"Payout BTC pubkey\"),\n    };\n  }\n  const isCompressed =\n    pubkey.length === COMPRESSED_PUBKEY_BYTES &&\n    (pubkey[0] === SEC1_EVEN_Y_PREFIX || pubkey[0] === SEC1_ODD_Y_PREFIX);\n  const isUncompressed =\n    pubkey.length === UNCOMPRESSED_PUBKEY_BYTES &&\n    pubkey[0] === SEC1_UNCOMPRESSED_PREFIX;\n  if (!isCompressed && !isUncompressed) {\n    throw new Error(\n      \"depositorBtcPubkeyRaw must be x-only, compressed, or uncompressed\",\n    );\n  }\n  try {\n    secp256k1.Point.fromBytes(pubkey);\n  } catch {\n    throw new Error(\"depositorBtcPubkeyRaw is not a valid BTC pubkey\");\n  }\n  return {\n    xOnlyPubkey: bytesToHex(pubkey.subarray(1, COMPRESSED_PUBKEY_BYTES)),\n    compressedPubkey: isCompressed ? pubkey : undefined,\n  };\n}\n\nfunction deriveP2wpkhScript(pubkey: Uint8Array): Hex {\n  return `0x${P2WPKH_SCRIPT_PREFIX}${bytesToHex(ripemd160(sha256(pubkey)))}`;\n}\n\n/** Verify the irreversible payout script at the final submission boundary. */\nexport function assertPayoutScriptMatchesPopKey(\n  scriptPubKey: string,\n  depositorBtcPubkey: string,\n  depositorBtcPubkeyRaw: string,\n): Hex {\n  const payoutScript = normalizeHex(\n    scriptPubKey,\n    \"depositorPayoutScriptPubKey\",\n  );\n  if ((payoutScript.length - 2) / 2 > MAX_PAYOUT_SCRIPT_LEN) {\n    throw new Error(\n      `depositorPayoutScriptPubKey exceeds ${MAX_PAYOUT_SCRIPT_LEN} bytes`,\n    );\n  }\n  const keyBody =\n    depositorBtcPubkey.startsWith(\"0x\") || depositorBtcPubkey.startsWith(\"0X\")\n      ? depositorBtcPubkey.slice(2)\n      : depositorBtcPubkey;\n  const xOnlyPubkey = assertOnChainBtcPubkey(\n    `0x${keyBody}` as Hex,\n    \"Proof of possession BTC pubkey\",\n  );\n  const payoutPubkey = normalizePayoutPubkey(depositorBtcPubkeyRaw);\n  if (payoutPubkey.xOnlyPubkey !== xOnlyPubkey) {\n    throw new Error(\n      \"depositorBtcPubkeyRaw does not match the proof of possession BTC pubkey\",\n    );\n  }\n\n  if (payoutScript === deriveP2trScript(xOnlyPubkey)) {\n    return payoutScript;\n  }\n  if (\n    payoutScript.startsWith(`0x${P2WPKH_SCRIPT_PREFIX}`) &&\n    payoutScript.length ===\n      2 + P2WPKH_SCRIPT_PREFIX.length + HASH160_BYTES * 2\n  ) {\n    if (!payoutPubkey.compressedPubkey) {\n      throw new Error(\"A P2WPKH payout requires a compressed BTC pubkey\");\n    }\n    if (payoutScript === deriveP2wpkhScript(payoutPubkey.compressedPubkey)) {\n      return payoutScript;\n    }\n  }\n  throw new Error(\n    \"depositorPayoutScriptPubKey does not match the proof of possession BTC pubkey\",\n  );\n}\n","/**\n * Dependency-free Bitcoin txid and vault-ID helpers for Ethereum-only clients.\n * Transaction hex and vault-ID inputs accept an optional `0x` prefix.\n * Depositor addresses use strict EIP-55 validation.\n * Txids use a `0x` prefix. Vault IDs use no prefix. Both use lowercase hex.\n */\n\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport {\n  encodeAbiParameters,\n  isAddress,\n  keccak256,\n  type Address,\n  type Hex,\n} from \"viem\";\n\n/** Decode an optional-prefixed, even-length hex string. */\nfunction decodeHex(value: string, label: string): Uint8Array {\n  const clean = value.startsWith(\"0x\") ? value.slice(2) : value;\n  if (clean.length === 0 || clean.length % 2 !== 0) {\n    throw new Error(`${label} must be non-empty, even-length hex`);\n  }\n  if (!/^[0-9a-fA-F]+$/.test(clean)) {\n    throw new Error(`${label} contains non-hex characters`);\n  }\n\n  const bytes = new Uint8Array(clean.length / 2);\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);\n  }\n  return bytes;\n}\n\n/** Encode bytes as lowercase hex without a prefix. */\nfunction encodeHex(bytes: Uint8Array): string {\n  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, \"0\")).join(\n    \"\",\n  );\n}\n\n/** Concatenate byte chunks without a buffer dependency. */\nfunction concatBytes(chunks: readonly Uint8Array[]): Uint8Array {\n  const result = new Uint8Array(\n    chunks.reduce((length, chunk) => length + chunk.length, 0),\n  );\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return result;\n}\n\n/**\n * Parse enough of Bitcoin's consensus transaction encoding to serialize the\n * no-witness form used for txid calculation. Every length is bounds-checked;\n * malformed/trailing data is rejected rather than hashed as an opaque blob.\n */\nfunction serializeWithoutWitness(transaction: Uint8Array): Uint8Array {\n  let offset = 0;\n\n  const take = (length: number, label: string): Uint8Array => {\n    if (!Number.isSafeInteger(length) || length < 0) {\n      throw new Error(`Invalid ${label} length ${length}`);\n    }\n    if (offset + length > transaction.length) {\n      throw new Error(`Truncated Bitcoin transaction while reading ${label}`);\n    }\n    const value = transaction.slice(offset, offset + length);\n    offset += length;\n    return value;\n  };\n\n  const readLittleEndian = (length: number, label: string): bigint => {\n    const bytes = take(length, label);\n    let value = 0n;\n    for (let i = bytes.length - 1; i >= 0; i--) {\n      value = (value << 8n) | BigInt(bytes[i]);\n    }\n    return value;\n  };\n\n  const readCompactSize = (\n    label: string,\n  ): { encoded: Uint8Array; value: number } => {\n    const start = offset;\n    const prefix = take(1, label)[0];\n    let value: bigint;\n    if (prefix < 0xfd) {\n      value = BigInt(prefix);\n    } else if (prefix === 0xfd) {\n      value = readLittleEndian(2, label);\n      if (value < 0xfdn) throw new Error(`Non-canonical ${label}`);\n    } else if (prefix === 0xfe) {\n      value = readLittleEndian(4, label);\n      if (value <= 0xffffn) throw new Error(`Non-canonical ${label}`);\n    } else {\n      value = readLittleEndian(8, label);\n      if (value <= 0xffffffffn) throw new Error(`Non-canonical ${label}`);\n    }\n    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {\n      throw new Error(`${label} exceeds JavaScript's safe integer range`);\n    }\n    return {\n      encoded: transaction.slice(start, offset),\n      value: Number(value),\n    };\n  };\n\n  const version = take(4, \"version\");\n  const hasWitness =\n    transaction[offset] === 0x00 && transaction[offset + 1] === 0x01;\n  if (hasWitness) offset += 2;\n\n  const inputCount = readCompactSize(\"input count\");\n  const inputs: Uint8Array[] = [];\n  for (let i = 0; i < inputCount.value; i++) {\n    const start = offset;\n    take(32, `input ${i} previous transaction hash`);\n    take(4, `input ${i} previous output index`);\n    const scriptLength = readCompactSize(`input ${i} script length`);\n    take(scriptLength.value, `input ${i} script`);\n    take(4, `input ${i} sequence`);\n    inputs.push(transaction.slice(start, offset));\n  }\n\n  const outputCount = readCompactSize(\"output count\");\n  const outputs: Uint8Array[] = [];\n  for (let i = 0; i < outputCount.value; i++) {\n    const start = offset;\n    take(8, `output ${i} value`);\n    const scriptLength = readCompactSize(`output ${i} script length`);\n    take(scriptLength.value, `output ${i} script`);\n    outputs.push(transaction.slice(start, offset));\n  }\n\n  if (hasWitness) {\n    let hasWitnessData = false;\n    for (let i = 0; i < inputCount.value; i++) {\n      const itemCount = readCompactSize(`input ${i} witness item count`);\n      hasWitnessData ||= itemCount.value > 0;\n      for (let j = 0; j < itemCount.value; j++) {\n        const itemLength = readCompactSize(\n          `input ${i} witness item ${j} length`,\n        );\n        take(itemLength.value, `input ${i} witness item ${j}`);\n      }\n    }\n    if (!hasWitnessData) {\n      throw new Error(\"Bitcoin transaction has superfluous witness marker\");\n    }\n  }\n\n  const locktime = take(4, \"locktime\");\n  if (offset !== transaction.length) {\n    throw new Error(\n      `Bitcoin transaction has ${transaction.length - offset} trailing byte(s)`,\n    );\n  }\n\n  return concatBytes([\n    version,\n    inputCount.encoded,\n    ...inputs,\n    outputCount.encoded,\n    ...outputs,\n    locktime,\n  ]);\n}\n\n/** Calculate a Bitcoin txid without importing bitcoinjs-lib. */\nexport function calculateBtcTxHash(transactionHex: string): Hex {\n  const serialized = serializeWithoutWitness(\n    decodeHex(transactionHex, \"transactionHex\"),\n  );\n  const digest = sha256(sha256(serialized));\n  digest.reverse();\n  return `0x${encodeHex(digest)}`;\n}\n\n/**\n * Derive the Solidity vault ID without loading the Rust/WASM package.\n *\n * Inputs accept an optional `0x` prefix to match the current PeginManager\n * call sites. Address validation stays strict: lowercase and valid EIP-55\n * addresses pass, while uppercase and incorrectly checksummed mixed-case\n * addresses fail. The synchronous result is lowercase hex without a prefix,\n * matching the WASM helper that this function replaces.\n */\nexport function derivePeginVaultId(\n  peginTxHash: string,\n  depositor: string,\n): string {\n  const normalizedPeginTxHash = peginTxHash.startsWith(\"0x\")\n    ? peginTxHash\n    : `0x${peginTxHash}`;\n  if (!/^0x[0-9a-fA-F]{64}$/.test(normalizedPeginTxHash)) {\n    throw new Error(\"peginTxHash must be a 32-byte hex value\");\n  }\n  const normalizedDepositor = depositor.startsWith(\"0x\")\n    ? depositor\n    : `0x${depositor}`;\n  if (!isAddress(normalizedDepositor, { strict: true })) {\n    throw new Error(`Invalid depositor Ethereum address: ${depositor}`);\n  }\n  return keccak256(\n    encodeAbiParameters(\n      [{ type: \"bytes32\" }, { type: \"address\" }],\n      [normalizedPeginTxHash as Hex, normalizedDepositor as Address],\n    ),\n  ).slice(2);\n}\n","/**\n * Validation for protocol parameters fetched from the ProtocolParams contract.\n *\n * These values feed Bitcoin script construction and deposit validation.\n * Invalid params must be caught before they reach transaction-building code,\n * since errors after wallet signing prompts are unrecoverable.\n *\n * The {@link ViemProtocolParamsReader} runs these on every read; consumers\n * implementing their own reader against the same `ProtocolParamsReader`\n * interface should call them too.\n */\n\nimport { assertValidVaultCoreVersion } from \"../../primitives/vaultCoreVersion\";\n\nimport type {\n  PegInConfiguration,\n  TBVProtocolParams,\n  VersionedOffchainParams,\n} from \"./types\";\n\n/**\n * Maximum value for a Solidity uint16.\n * PeginLogic.sol casts timelockAssert to uint16, so values above this are invalid.\n */\nconst UINT16_MAX = 65535;\n\n/** Maximum valid value for basis points (100%) */\nconst MAX_BASIS_POINTS = 10000;\n\n/** Maximum value for a Solidity uint32. */\nconst UINT32_MAX = 4_294_967_295;\n\n/** Maximum valid value for a uint8 (e.g. maxHtlcOutputCount). */\nconst UINT8_MAX = 255;\n\n/**\n * Validate an `offchainParamsVersion` value sourced from a contract read.\n * `Number()` on a malformed payload yields `NaN` or a non-integer; both\n * silently break consumers that loop `1..version` or use the value as a\n * map key. Used by reader entry points that surface the version to JS.\n */\nexport function assertValidOffchainParamsVersion(version: number): void {\n  if (\n    !Number.isInteger(version) ||\n    version < 0 ||\n    version > UINT32_MAX\n  ) {\n    throw new Error(\n      `Invalid offchainParamsVersion from contract: must be a uint32, got ${version}`,\n    );\n  }\n}\n\n/**\n * Validate offchain params consistency and bounds.\n * @throws Error on invalid values to prevent constructing invalid Bitcoin scripts.\n */\nexport function validateOffchainParams(params: VersionedOffchainParams): void {\n  const errors: string[] = [];\n\n  if (params.timelockAssert <= 0n) {\n    errors.push(\n      `timelockAssert must be positive, got ${params.timelockAssert}`,\n    );\n  }\n  if (params.timelockAssert > BigInt(UINT16_MAX)) {\n    errors.push(\n      `timelockAssert ${params.timelockAssert} exceeds uint16 max (${UINT16_MAX})`,\n    );\n  }\n\n  if (params.timelockChallengeAssert <= 0n) {\n    errors.push(\n      `timelockChallengeAssert must be positive, got ${params.timelockChallengeAssert}`,\n    );\n  }\n\n  if (params.tRefund <= 0) {\n    errors.push(`tRefund must be positive, got ${params.tRefund}`);\n  }\n\n  if (params.tStale <= 0) {\n    errors.push(`tStale must be positive, got ${params.tStale}`);\n  }\n\n  if (params.securityCouncilKeys.length === 0) {\n    errors.push(\"securityCouncilKeys must not be empty\");\n  }\n\n  if (params.councilQuorum <= 0) {\n    errors.push(`councilQuorum must be positive, got ${params.councilQuorum}`);\n  }\n  if (params.councilQuorum > params.securityCouncilKeys.length) {\n    errors.push(\n      `councilQuorum (${params.councilQuorum}) exceeds securityCouncilKeys count (${params.securityCouncilKeys.length})`,\n    );\n  }\n\n  if (params.feeRate <= 0n) {\n    errors.push(`feeRate must be positive, got ${params.feeRate}`);\n  }\n\n  if (params.minPeginFeeRate <= 0n) {\n    errors.push(\n      `minPeginFeeRate must be positive, got ${params.minPeginFeeRate}`,\n    );\n  }\n\n  if (\n    !Number.isInteger(params.proverCircuitVersion) ||\n    params.proverCircuitVersion < 0 ||\n    params.proverCircuitVersion > UINT16_MAX\n  ) {\n    errors.push(\n      `proverCircuitVersion must be a uint16, got ${params.proverCircuitVersion}`,\n    );\n  }\n\n  if (\n    !Number.isInteger(params.minPrepeginDepth) ||\n    params.minPrepeginDepth <= 0 ||\n    params.minPrepeginDepth > UINT32_MAX\n  ) {\n    errors.push(\n      `minPrepeginDepth must be a uint32 in [1, ${UINT32_MAX}], got ${params.minPrepeginDepth}`,\n    );\n  }\n\n  if (params.babeTotalInstances <= 0) {\n    errors.push(\n      `babeTotalInstances must be positive, got ${params.babeTotalInstances}`,\n    );\n  }\n  if (params.babeInstancesToFinalize <= 0) {\n    errors.push(\n      `babeInstancesToFinalize must be positive, got ${params.babeInstancesToFinalize}`,\n    );\n  }\n  if (params.babeInstancesToFinalize > params.babeTotalInstances) {\n    errors.push(\n      `babeInstancesToFinalize (${params.babeInstancesToFinalize}) exceeds babeTotalInstances (${params.babeTotalInstances})`,\n    );\n  }\n\n  if (\n    params.minVpCommissionBps < 0 ||\n    params.minVpCommissionBps > MAX_BASIS_POINTS\n  ) {\n    errors.push(\n      `minVpCommissionBps must be in [0, ${MAX_BASIS_POINTS}], got ${params.minVpCommissionBps}`,\n    );\n  }\n\n  if (errors.length > 0) {\n    throw new Error(\n      `Invalid offchain protocol parameters: ${errors.join(\"; \")}`,\n    );\n  }\n}\n\n/**\n * Validate TBV protocol params returned from the contract.\n * @throws Error on invalid amounts or out-of-range bounded fields.\n */\nexport function validateTBVProtocolParams(params: TBVProtocolParams): void {\n  const errors: string[] = [];\n\n  if (params.minimumPegInAmount <= 0n) {\n    errors.push(\n      `minimumPegInAmount must be positive, got ${params.minimumPegInAmount}`,\n    );\n  }\n\n  if (params.maxPegInAmount < params.minimumPegInAmount) {\n    errors.push(\n      `maxPegInAmount (${params.maxPegInAmount}) must be >= minimumPegInAmount (${params.minimumPegInAmount})`,\n    );\n  }\n\n  if (params.pegInAckTimeout <= 0n) {\n    errors.push(\n      `pegInAckTimeout must be positive, got ${params.pegInAckTimeout}`,\n    );\n  }\n\n  if (params.pegInActivationTimeout <= 0n) {\n    errors.push(\n      `pegInActivationTimeout must be positive, got ${params.pegInActivationTimeout}`,\n    );\n  }\n\n  if (\n    !Number.isInteger(params.maxHtlcOutputCount) ||\n    params.maxHtlcOutputCount <= 0 ||\n    params.maxHtlcOutputCount > UINT8_MAX\n  ) {\n    errors.push(\n      `maxHtlcOutputCount must be an integer in [1, ${UINT8_MAX}], got ${params.maxHtlcOutputCount}`,\n    );\n  }\n\n  if (\n    typeof params.expiredPegInGraceBlocks !== \"bigint\" ||\n    params.expiredPegInGraceBlocks <= 0n\n  ) {\n    errors.push(\n      `expiredPegInGraceBlocks must be a positive bigint, got ${params.expiredPegInGraceBlocks}`,\n    );\n  }\n\n  if (errors.length > 0) {\n    throw new Error(`Invalid TBV protocol parameters: ${errors.join(\"; \")}`);\n  }\n}\n\n/**\n * Validate the full peg-in configuration after assembly.\n * Checks both TBV params and offchain params consistency, and the\n * top-level `offchainParamsVersion` (which originates from a separate\n * multicall result and so must be range-checked alongside the params it\n * names).\n */\nexport function validatePegInConfiguration(config: PegInConfiguration): void {\n  validateTBVProtocolParams(config);\n  validateOffchainParams(config.offchainParams);\n\n  if (\n    !Number.isInteger(config.offchainParamsVersion) ||\n    config.offchainParamsVersion < 0 ||\n    config.offchainParamsVersion > UINT32_MAX\n  ) {\n    throw new Error(\n      `Invalid peg-in configuration: offchainParamsVersion must be a uint32, got ${config.offchainParamsVersion}`,\n    );\n  }\n\n  // The contract enforces ≥ 1 (setter rejects 0); a 0 here means a\n  // mis-decoded read or a pre-vaultCoreVersion contract — fail closed.\n  assertValidVaultCoreVersion(\n    config.activeVaultCoreVersion,\n    \"ProtocolParams.activeVaultCoreVersion()\",\n  );\n}\n","/**\n * Concrete BTCVaultRegistry reader using viem's readContract.\n *\n * This is an optional utility — callers can use their own implementation\n * of the VaultRegistryReader interface.\n */\n\nimport type { Abi, Address, Hex, PublicClient } from \"viem\";\n\nimport { BTCVaultRegistryABI } from \"../../contracts/abis/BTCVaultRegistry.abi\";\nimport { BTCVaultRegistryKeyEpochsABI } from \"../../contracts/abis/BTCVaultRegistryKeyEpochs.abi\";\nimport { assertOnChainBtcPubkey } from \"./onChainBtcPubkey\";\nimport { assertValidOffchainParamsVersion } from \"./protocol-params-validation\";\nimport type {\n  KeyEpochs,\n  OnChainBtcPubkey,\n  VaultBasicInfo,\n  VaultData,\n  VaultProtocolInfo,\n  VaultRegistryReader,\n} from \"./types\";\n\n/**\n * Inclusive upper bound the BTCVaultRegistry contract enforces on a vault\n * provider's commission (the contract check is `< 10000`).\n */\nconst MAX_VP_COMMISSION_BPS = 9999;\n\n/** Raw `getBtcVaultBasicInfo` tuple as decoded by viem. */\ntype RawVaultBasicInfo = {\n  depositor: Address;\n  depositorBtcPubKey: Hex;\n  amount: bigint;\n  vaultProvider: Address;\n  status: number;\n  applicationEntryPoint: Address;\n  createdAt: bigint;\n};\n\n/**\n * Raw `getBtcVaultProtocolInfo` tuple as decoded by viem.\n *\n * Mirrors the ABI's components except `claimExpiredUntil`, which nothing\n * consumes: it is the post-expiry grace deadline for `claimExpired`, scoped to\n * vaults that expired without activating, and it is not a deadline on the\n * depositor's claim right. The ABI still declares it — the decode is\n * positional, so removing it there would shift `vaultCoreVersion`.\n */\ntype RawVaultProtocolInfo = {\n  depositorSignedPeginTx: Hex;\n  universalChallengersVersion: number;\n  appVaultKeepersVersion: number;\n  offchainParamsVersion: number;\n  verifiedAt: bigint;\n  depositorWotsPkHash: Hex;\n  hashlock: Hex;\n  htlcVout: number;\n  depositorPopSignature: Hex;\n  prePeginTxHash: Hex;\n  vaultProviderCommissionBps: number;\n  vaultCoreVersion: number;\n};\n\nfunction mapVaultBasicInfo(result: RawVaultBasicInfo): VaultBasicInfo {\n  return {\n    depositor: result.depositor,\n    depositorBtcPubKey: result.depositorBtcPubKey,\n    amount: result.amount,\n    vaultProvider: result.vaultProvider,\n    status: result.status,\n    applicationEntryPoint: result.applicationEntryPoint,\n    createdAt: result.createdAt,\n  };\n}\n\nfunction mapVaultProtocolInfo(result: RawVaultProtocolInfo): VaultProtocolInfo {\n  const offchainParamsVersion = Number(result.offchainParamsVersion);\n  assertValidOffchainParamsVersion(offchainParamsVersion);\n  return {\n    depositorSignedPeginTx: result.depositorSignedPeginTx,\n    universalChallengersVersion: result.universalChallengersVersion,\n    appVaultKeepersVersion: result.appVaultKeepersVersion,\n    offchainParamsVersion,\n    verifiedAt: result.verifiedAt,\n    depositorWotsPkHash: result.depositorWotsPkHash,\n    hashlock: result.hashlock,\n    htlcVout: result.htlcVout,\n    depositorPopSignature: result.depositorPopSignature,\n    prePeginTxHash: result.prePeginTxHash,\n    vaultProviderCommissionBps: result.vaultProviderCommissionBps,\n    vaultCoreVersion: result.vaultCoreVersion,\n  };\n}\n\n/**\n * Exclusive upper bound for a `uint64` epoch.\n *\n * viem does not range-check a decoded `uint64`, so a misaligned decode can\n * hand back a value far larger than the field can hold. Rejecting those is\n * cheap defence in depth against a mis-decode of the extended ABI.\n *\n * The state this is load-bearing for is narrower than \"a registry that predates\n * RFC-006\". Against a *fully* pre-RFC-006 registry the path fails closed on its\n * own: `resolveParticipantKeysAtEpochs` goes on to call\n * `getOperationBtcKeyAtEpochOrGenesis` on ApplicationRegistry and\n * ProtocolParams, which do not exist there, so the multicall reverts and these\n * epochs are never used. The reachable gap is a registry that *has* the\n * operation-key getters but whose `BTCVaultProtocolInfo` struct is not\n * extended — there the tail-data epochs resolve with no error at all, and this\n * range check is the only thing looking at them.\n *\n * Even for that case it is only a backstop, and a weak one: a misaligned decode\n * can land on a small, plausible-looking integer this range accepts. Correctness\n * rests on only ever pointing at an RFC-006 registry, which is a deployment\n * precondition rather than something this call can establish — see\n * https://github.com/babylonlabs-io/babylon-toolkit/issues/2192 for where that\n * check is owned, and `BTCVaultRegistryKeyEpochs.abi.ts` for the decode hazard.\n */\nconst UINT64_EXCLUSIVE_UPPER_BOUND = 1n << 64n;\n\n/**\n * The epoch a vault provider's registration key is bonded at.\n *\n * A provider's operation-key history is append-only and every appended version\n * is stamped at epoch 1 or later, so epoch 0 always resolves to the key set at\n * registration. This is what lets `getOperationBtcKeyAtEpoch` stand in for the\n * removed `getVaultProviderBTCKey` getter.\n */\nconst VP_GENESIS_KEY_EPOCH = 0n;\n\nfunction assertEpochInRange(\n  value: bigint,\n  field: string,\n  vaultId: Hex,\n): bigint {\n  if (value < 0n || value >= UINT64_EXCLUSIVE_UPPER_BOUND) {\n    throw new Error(\n      `getBtcVaultProtocolInfo returned ${field}=${value} for vault ${vaultId}, ` +\n        `outside the uint64 range — the registry may predate RFC-006`,\n    );\n  }\n  return value;\n}\n\nfunction mapKeyEpochs(result: KeyEpochs, vaultId: Hex): KeyEpochs {\n  return {\n    vpKeyEpoch: assertEpochInRange(result.vpKeyEpoch, \"vpKeyEpoch\", vaultId),\n    appKeeperKeyEpoch: assertEpochInRange(\n      result.appKeeperKeyEpoch,\n      \"appKeeperKeyEpoch\",\n      vaultId,\n    ),\n    ucKeyEpoch: assertEpochInRange(result.ucKeyEpoch, \"ucKeyEpoch\", vaultId),\n  };\n}\n\n/**\n * Concrete vault registry reader using viem.\n *\n * Usage:\n * ```ts\n * const reader = new ViemVaultRegistryReader(publicClient, registryAddress);\n * const data = await reader.getVaultData(vaultId);\n * ```\n */\nexport class ViemVaultRegistryReader implements VaultRegistryReader {\n  constructor(\n    private publicClient: PublicClient,\n    private contractAddress: Address,\n  ) {}\n\n  /**\n   * Read the VP's **genesis** (registration) x-only BTC pubkey — the key bonded\n   * at version 0, which never moves when the operator rotates.\n   *\n   * Resolved as \"the operation key at epoch 0\" rather than through the\n   * dedicated `getVaultProviderBTCKey` getter, which\n   * https://github.com/babylonlabs-io/vault-contracts-aave-v4/pull/539 removes.\n   * Epoch 0 predates any rotation — appended versions are stamped at epoch 1 or\n   * later — so it resolves to the registration key, and the contracts team has\n   * confirmed that is a property we can rely on rather than an implementation\n   * detail. The devnet comparison behind that claim — both getters returning the\n   * identical key for a provider that *has* rotated, while\n   * `getCurrentOperationBtcKey` differed — is recorded in\n   * https://github.com/babylonlabs-io/babylon-toolkit/issues/2188.\n   *\n   * This makes the read RFC-006-only, where the removed getter also existed on a\n   * legacy registry. That costs nothing: every caller of this method already\n   * resolves participant keys through `OperationKeyReader`, so all of them\n   * require an RFC-006 registry regardless.\n   *\n   * Validates length, hex form, and secp256k1 curve membership before minting\n   * the brand. Returns 64-char lowercase hex without the `0x` prefix.\n   */\n  async getVaultProviderGenesisBtcPubKey(\n    vpAddress: Address,\n    blockNumber?: bigint,\n  ): Promise<OnChainBtcPubkey> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: BTCVaultRegistryABI,\n      functionName: \"getOperationBtcKeyAtEpoch\",\n      args: [vpAddress, VP_GENESIS_KEY_EPOCH],\n      blockNumber,\n    })) as Hex;\n    return assertOnChainBtcPubkey(\n      result,\n      `getOperationBtcKeyAtEpoch (vp=${vpAddress}, epoch=${VP_GENESIS_KEY_EPOCH})`,\n    );\n  }\n\n  /**\n   * Read a vault provider's *current* RFC-006 operation BTC key.\n   *\n   * Falls back on-chain to the registration key when the provider has never\n   * rotated, so this returns the same value as\n   * `getVaultProviderGenesisBtcPubKey` until the first rotation.\n   *\n   * This is the key the VP's server signs its BIP-322 auth tokens with — a\n   * live per-operator identity, not a per-vault binding, so the auth pin uses\n   * the current key rather than any vault's frozen epoch.\n   */\n  async getCurrentVaultProviderOperationBtcKey(\n    vpAddress: Address,\n  ): Promise<OnChainBtcPubkey> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: BTCVaultRegistryABI,\n      functionName: \"getCurrentOperationBtcKey\",\n      args: [vpAddress],\n    })) as Hex;\n    return assertOnChainBtcPubkey(\n      result,\n      `getCurrentOperationBtcKey (vp=${vpAddress})`,\n    );\n  }\n\n  /**\n   * Read a vault's frozen RFC-006 operation-key epochs.\n   *\n   * Reads `getBtcVaultProtocolInfo` through the **extended** ABI, which is only\n   * valid against an RFC-006 registry: against one whose `BTCVaultProtocolInfo`\n   * struct is not extended this call does not fail for a populated vault, it\n   * silently returns three words of tail data as epochs. Nothing here can detect\n   * that, so the guarantee is a deployment one — every network this ships to has\n   * the RFC-006 getters, and mainnet is a fresh RFC-006 deploy.\n   *\n   * A registry missing the operation-key getters entirely is the *safer* of the\n   * two cases: `resolveParticipantKeysAtEpochs` reverts downstream and these\n   * epochs never reach key resolution. See {@link UINT64_EXCLUSIVE_UPPER_BOUND}\n   * for which state the range check actually guards, and\n   * `BTCVaultRegistryKeyEpochs.abi.ts` for the decode hazard.\n   */\n  async getVaultKeyEpochs(vaultId: Hex): Promise<KeyEpochs> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: BTCVaultRegistryKeyEpochsABI,\n      functionName: \"getBtcVaultProtocolInfo\",\n      args: [vaultId],\n    })) as unknown as KeyEpochs;\n\n    return mapKeyEpochs(result, vaultId);\n  }\n\n  async getVaultKeyEpochsBatch(vaultIds: readonly Hex[]): Promise<KeyEpochs[]> {\n    if (vaultIds.length === 0) return [];\n\n    const results = await this.publicClient.multicall({\n      contracts: vaultIds.map((vaultId) => ({\n        address: this.contractAddress,\n        abi: BTCVaultRegistryKeyEpochsABI as Abi,\n        functionName: \"getBtcVaultProtocolInfo\" as const,\n        args: [vaultId] as const,\n      })),\n      allowFailure: false,\n    });\n\n    return results.map((info, i) =>\n      mapKeyEpochs(info as unknown as KeyEpochs, vaultIds[i]),\n    );\n  }\n\n  async getVaultBasicInfo(vaultId: Hex): Promise<VaultBasicInfo> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: BTCVaultRegistryABI,\n      functionName: \"getBtcVaultBasicInfo\",\n      args: [vaultId],\n    })) as RawVaultBasicInfo;\n\n    return mapVaultBasicInfo(result);\n  }\n\n  async getVaultProtocolInfo(vaultId: Hex): Promise<VaultProtocolInfo> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: BTCVaultRegistryABI,\n      functionName: \"getBtcVaultProtocolInfo\",\n      args: [vaultId],\n    })) as RawVaultProtocolInfo;\n\n    return mapVaultProtocolInfo(result);\n  }\n\n  async getProtocolInfoBatch(\n    vaultIds: readonly Hex[],\n  ): Promise<VaultProtocolInfo[]> {\n    if (vaultIds.length === 0) return [];\n\n    const results = await this.publicClient.multicall({\n      contracts: vaultIds.map((vaultId) => ({\n        address: this.contractAddress,\n        abi: BTCVaultRegistryABI as Abi,\n        functionName: \"getBtcVaultProtocolInfo\" as const,\n        args: [vaultId] as const,\n      })),\n      allowFailure: false,\n    });\n\n    return results.map((info, i) => {\n      const result = info as unknown as RawVaultProtocolInfo;\n      if (\n        !result.depositorSignedPeginTx ||\n        result.depositorSignedPeginTx === \"0x\"\n      ) {\n        // An empty record is not proof the vault is absent: a lagging RPC\n        // node returns HTTP 200 with a zero struct, so no retry below this\n        // layer can see it. Single-shot is only safe because the finality\n        // gate (`waitForPeginRegistrationDepth`) runs first on the deposit\n        // path — move this ahead of it and the read-after-write race returns.\n        // The vault app matches this message to render \"still confirming\".\n        throw new Error(\n          `Vault ${vaultIds[i]} not found on-chain or has no pegin transaction`,\n        );\n      }\n      return mapVaultProtocolInfo(result);\n    });\n  }\n\n  /**\n   * Read the protocol pegin fee (in wei) for a given vault provider.\n   * Mirrors the `getPegInFee(address)` view on BTCVaultRegistry.\n   */\n  async getPegInFee(vaultProvider: Address): Promise<bigint> {\n    return (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: BTCVaultRegistryABI,\n      functionName: \"getPegInFee\",\n      args: [vaultProvider],\n    })) as bigint;\n  }\n\n  /**\n   * Read a vault provider's current commission in basis points from\n   * BTCVaultRegistry. The contract enforces `commissionBps < 10000`, so the\n   * legitimate range is `[0, 9999]`; anything outside indicates a wrong\n   * contract address or ABI drift and is surfaced as an error rather than\n   * trusted.\n   */\n  async getVaultProviderCommission(vaultProvider: Address): Promise<number> {\n    // viem infers `number` from the `uint16` return in the `as const` ABI.\n    const bps = await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: BTCVaultRegistryABI,\n      functionName: \"getVaultProviderCommission\",\n      args: [vaultProvider],\n    });\n\n    if (!Number.isInteger(bps) || bps < 0 || bps > MAX_VP_COMMISSION_BPS) {\n      throw new Error(\n        `getVaultProviderCommission returned ${bps} bps for ${vaultProvider}, ` +\n          `outside the protocol range [0, ${MAX_VP_COMMISSION_BPS}]`,\n      );\n    }\n\n    return bps;\n  }\n\n  async getVaultData(vaultId: Hex): Promise<VaultData> {\n    // One round-trip for both structs (hard-fail): they feed signing/refund/\n    // broadcast rebinds, so reading them in a single multicall also pins both\n    // to the same block — no basic/protocol skew across two `eth_call`s.\n    const [basicRaw, protocolRaw] = await this.publicClient.multicall({\n      contracts: [\n        {\n          address: this.contractAddress,\n          abi: BTCVaultRegistryABI,\n          functionName: \"getBtcVaultBasicInfo\",\n          args: [vaultId],\n        },\n        {\n          address: this.contractAddress,\n          abi: BTCVaultRegistryABI,\n          functionName: \"getBtcVaultProtocolInfo\",\n          args: [vaultId],\n        },\n      ],\n      allowFailure: false,\n    });\n\n    const basic = mapVaultBasicInfo(basicRaw);\n    const protocol = mapVaultProtocolInfo(protocolRaw);\n\n    if (\n      !protocol.depositorSignedPeginTx ||\n      protocol.depositorSignedPeginTx === \"0x\"\n    ) {\n      throw new Error(\n        `Vault ${vaultId} not found on-chain or has no pegin transaction`,\n      );\n    }\n\n    return { basic, protocol };\n  }\n\n}\n","import {\n  encodeFunctionData,\n  isAddressEqual,\n  zeroAddress,\n  type Address,\n  type Chain,\n  type Hex,\n  type PublicClient,\n  type WalletClient,\n} from \"viem\";\n\nimport { BTCVaultRegistryABI } from \"../../contracts/abis/BTCVaultRegistry.abi\";\nimport { handleContractError } from \"../../contracts/errors\";\nimport {\n  capMaxAcceptableCommissionBps,\n  COMMISSION_BPS_HEADROOM,\n} from \"../../deposit-terms/commissionCeiling\";\nimport { waitForTransactionReceiptSmartAware } from \"../../utils/eth\";\nimport { assertOnChainBtcPubkey } from \"./onChainBtcPubkey\";\nimport { assertPayoutScriptMatchesPopKey } from \"./payout-script\";\nimport { calculateBtcTxHash, derivePeginVaultId } from \"./pegin-transaction\";\nimport { ViemVaultRegistryReader } from \"./vault-registry-reader\";\n\n/** Referral code sent with peg-in registration. Zero means no referral. */\nexport const NO_REFERRAL_CODE = 0;\nconst UINT8_MAX = 255;\n// Match the prior vault-service timeout. A dropped transaction must not wait forever.\nconst RECEIPT_TIMEOUT_MS = 120_000;\n\nfunction ensureHex(value: string, label: string): Hex {\n  const prefixed = value.startsWith(\"0x\")\n    ? value\n    : value.startsWith(\"0X\")\n      ? `0x${value.slice(2)}`\n      : `0x${value}`;\n  if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(prefixed)) {\n    throw new Error(`${label} must be non-empty, even-length hex`);\n  }\n  return prefixed as Hex;\n}\n\nfunction assertBytes32(value: Hex, label: string): void {\n  if (!/^0x[0-9a-fA-F]{64}$/.test(value)) {\n    throw new Error(`${label} must be a 32-byte hex value`);\n  }\n}\n\nfunction assertHtlcVout(value: number): void {\n  if (!Number.isInteger(value) || value < 0 || value > UINT8_MAX) {\n    throw new Error(`htlcVout must be a uint8, got ${value}`);\n  }\n}\n\n/** A PoP prepared by a Bitcoin wallet, reusable by the ETH submit client. */\nexport interface PopSignature {\n  btcPopSignature: Hex;\n  depositorEthAddress: Address;\n  /** x-only secp256k1 public key, 64 hex chars without `0x`. */\n  depositorBtcPubkey: string;\n}\n\nexport interface ViemPeginRegistrationClientConfig {\n  ethWallet: WalletClient;\n  ethChain: Chain;\n  publicClient: PublicClient;\n  btcVaultRegistry: Address;\n  receiptTimeoutMs?: number;\n  /**\n   * Refuse to register without a `quotedCommissionBps`. Set it to `true` when\n   * the depositor approved deposit terms on a device: approval froze the\n   * commission ceiling from the quote, so the chain-current fallback could\n   * admit a commission the device would later refuse to pay out.\n   *\n   * Required, with no default: an omitted flag would silently pick the unsafe\n   * direction for the integrator least able to probe the wallet capability.\n   */\n  requireQuotedCommissionBps: boolean;\n}\n\nexport interface RegisterPeginOnChainParams {\n  unsignedPrePeginTx: string;\n  depositorSignedPeginTx: string;\n  vaultProvider: Address;\n  hashlock: Hex;\n  depositorWotsPkHash: Hex;\n  popSignature: PopSignature;\n  /** Raw x-only, compressed, or uncompressed BTC pubkey from the PoP wallet. */\n  depositorBtcPubkeyRaw: string;\n  htlcVout: number;\n  /**\n   * Bitcoin output script bytes, not an address. The client verifies that the\n   * script pays the proof-of-possession key before it submits the transaction.\n   */\n  depositorPayoutScriptPubKey: string;\n  quotedCommissionBps?: number;\n}\n\nexport interface PeginRegistrationResult {\n  ethTxHash: Hex;\n  vaultId: Hex;\n  peginTxHash: Hex;\n}\n\nexport interface BatchPeginRegistrationItem {\n  depositorSignedPeginTx: string;\n  hashlock: Hex;\n  htlcVout: number;\n  /**\n   * Bitcoin output script bytes, not an address. The client verifies that the\n   * script pays the proof-of-possession key before it submits the transaction.\n   */\n  depositorPayoutScriptPubKey: string;\n  depositorWotsPkHash: Hex;\n}\n\nexport interface RegisterPeginBatchOnChainParams {\n  vaultProvider: Address;\n  unsignedPrePeginTx: string;\n  requests: BatchPeginRegistrationItem[];\n  popSignature: PopSignature;\n  /** Raw x-only, compressed, or uncompressed BTC pubkey from the PoP wallet. */\n  depositorBtcPubkeyRaw: string;\n  quotedCommissionBps?: number;\n}\n\nexport interface BatchPeginRegistrationResultItem {\n  vaultId: Hex;\n  peginTxHash: Hex;\n}\n\nexport interface PeginBatchRegistrationResult {\n  ethTxHash: Hex;\n  vaults: BatchPeginRegistrationResultItem[];\n}\n\n/**\n * Ethereum-only client for the on-chain half of peg-in registration.\n *\n * It consumes Bitcoin artifacts that were prepared earlier, but owns no BTC\n * wallet and imports neither Bitcoin libraries nor the Rust/WASM package.\n */\nexport class ViemPeginRegistrationClient {\n  constructor(private readonly config: ViemPeginRegistrationClientConfig) {}\n\n  async registerPeginOnChain(\n    params: RegisterPeginOnChainParams,\n  ): Promise<PeginRegistrationResult> {\n    const request = {\n      ...params,\n      popSignature: { ...params.popSignature },\n    };\n    this.assertQuotedCommissionPresentWhenRequired(request.quotedCommissionBps);\n    const depositor = this.assertPopMatchesEthAccount(request.popSignature);\n    const depositorBtcPubkey = this.normalizeBtcPubkey(request.popSignature);\n    const btcPopSignature = ensureHex(\n      request.popSignature.btcPopSignature,\n      \"btcPopSignature\",\n    );\n    const normalized = this.normalizeRequest(\n      request,\n      depositor,\n      depositorBtcPubkey,\n    );\n\n    await this.assertVaultDoesNotExist(\n      normalized.vaultId,\n      normalized.peginTxHash,\n    );\n    const peginFee = await this.readPeginFee(request.vaultProvider);\n    const maxCommission = await this.resolveMaxAcceptableCommissionBps(\n      request.vaultProvider,\n      request.quotedCommissionBps,\n    );\n    const callData = encodeFunctionData({\n      abi: BTCVaultRegistryABI,\n      functionName: \"submitPeginRequest\",\n      args: [\n        depositor,\n        depositorBtcPubkey,\n        btcPopSignature,\n        normalized.unsignedPrePeginTx,\n        normalized.depositorSignedPeginTx,\n        request.vaultProvider,\n        maxCommission,\n        request.hashlock,\n        request.htlcVout,\n        normalized.payoutScript,\n        request.depositorWotsPkHash,\n      ],\n    });\n\n    const ethTxHash = await this.sendAndWait(\n      callData,\n      peginFee,\n      false,\n      depositor,\n    );\n    return {\n      ethTxHash,\n      vaultId: normalized.vaultId,\n      peginTxHash: normalized.peginTxHash,\n    };\n  }\n\n  async registerPeginBatchOnChain(\n    params: RegisterPeginBatchOnChainParams,\n  ): Promise<PeginBatchRegistrationResult> {\n    const batch = {\n      ...params,\n      popSignature: { ...params.popSignature },\n      requests: params.requests.map((request) => ({ ...request })),\n    };\n    if (batch.requests.length === 0) {\n      throw new Error(\"Batch pegin requires at least one request\");\n    }\n    this.assertQuotedCommissionPresentWhenRequired(batch.quotedCommissionBps);\n    const depositor = this.assertPopMatchesEthAccount(batch.popSignature);\n    const unsignedPrePeginTx = ensureHex(\n      batch.unsignedPrePeginTx,\n      \"unsignedPrePeginTx\",\n    );\n    const depositorBtcPubkey = this.normalizeBtcPubkey(batch.popSignature);\n    const btcPopSignature = ensureHex(\n      batch.popSignature.btcPopSignature,\n      \"btcPopSignature\",\n    );\n\n    const vaults: BatchPeginRegistrationResultItem[] = [];\n    const requests = [];\n    const seenVaultIds = new Set<string>();\n    for (const request of batch.requests) {\n      const normalized = this.normalizeRequest(\n        {\n          ...request,\n          unsignedPrePeginTx: batch.unsignedPrePeginTx,\n          vaultProvider: batch.vaultProvider,\n          depositorBtcPubkeyRaw: batch.depositorBtcPubkeyRaw,\n        },\n        depositor,\n        depositorBtcPubkey,\n      );\n      if (seenVaultIds.has(normalized.vaultId)) {\n        throw new Error(`Duplicate vault in batch: ${normalized.vaultId}`);\n      }\n      seenVaultIds.add(normalized.vaultId);\n      vaults.push({\n        vaultId: normalized.vaultId,\n        peginTxHash: normalized.peginTxHash,\n      });\n      requests.push({\n        depositorBtcPubKey: depositorBtcPubkey,\n        btcPopSignature,\n        unsignedPrePeginTx,\n        depositorSignedPeginTx: normalized.depositorSignedPeginTx,\n        hashlock: request.hashlock,\n        htlcVout: request.htlcVout,\n        referralCode: NO_REFERRAL_CODE,\n        depositorPayoutBtcAddress: normalized.payoutScript,\n        depositorWotsPkHash: request.depositorWotsPkHash,\n      });\n    }\n    for (const vault of vaults) {\n      await this.assertVaultDoesNotExist(vault.vaultId, vault.peginTxHash);\n    }\n\n    const peginFee = await this.readPeginFee(batch.vaultProvider);\n    const maxCommission = await this.resolveMaxAcceptableCommissionBps(\n      batch.vaultProvider,\n      batch.quotedCommissionBps,\n    );\n    const callData = encodeFunctionData({\n      abi: BTCVaultRegistryABI,\n      functionName: \"submitPeginRequestBatch\",\n      args: [depositor, batch.vaultProvider, maxCommission, requests],\n    });\n    const ethTxHash = await this.sendAndWait(\n      callData,\n      peginFee * BigInt(batch.requests.length),\n      true,\n      depositor,\n    );\n    return { ethTxHash, vaults };\n  }\n\n  private assertQuotedCommissionPresentWhenRequired(\n    quotedCommissionBps?: number,\n  ): void {\n    if (\n      quotedCommissionBps === undefined &&\n      this.config.requireQuotedCommissionBps\n    ) {\n      throw new Error(\n        \"quotedCommissionBps is required when the wallet approved deposit \" +\n          \"terms: the registration ceiling must anchor to the approved quote.\",\n      );\n    }\n  }\n\n  private assertPopMatchesEthAccount(pop: PopSignature): Address {\n    return this.assertEthAccount(pop.depositorEthAddress);\n  }\n\n  private assertEthAccount(expectedDepositor: Address): Address {\n    const account = this.config.ethWallet.account;\n    if (!account) throw new Error(\"Ethereum wallet account not found\");\n    if (!isAddressEqual(expectedDepositor, account.address)) {\n      throw new Error(\n        `Proof of possession was signed for ${expectedDepositor} ` +\n          `but the Ethereum wallet is currently connected to ${account.address}. ` +\n          `Reconnect the original account or sign a new proof of possession.`,\n      );\n    }\n    return account.address;\n  }\n\n  private normalizeBtcPubkey(pop: PopSignature): Hex {\n    return `0x${assertOnChainBtcPubkey(\n      ensureHex(pop.depositorBtcPubkey, \"Proof of possession BTC pubkey\"),\n      \"Proof of possession BTC pubkey\",\n    )}`;\n  }\n\n  private normalizeRequest(\n    params: Omit<RegisterPeginOnChainParams, \"popSignature\">,\n    depositor: Address,\n    depositorBtcPubkey: Hex,\n  ) {\n    assertBytes32(params.hashlock, \"hashlock\");\n    assertBytes32(params.depositorWotsPkHash, \"depositorWotsPkHash\");\n    assertHtlcVout(params.htlcVout);\n    const unsignedPrePeginTx = ensureHex(\n      params.unsignedPrePeginTx,\n      \"unsignedPrePeginTx\",\n    );\n    const depositorSignedPeginTx = ensureHex(\n      params.depositorSignedPeginTx,\n      \"depositorSignedPeginTx\",\n    );\n    const peginTxHash = calculateBtcTxHash(depositorSignedPeginTx);\n    return {\n      unsignedPrePeginTx,\n      depositorSignedPeginTx,\n      payoutScript: assertPayoutScriptMatchesPopKey(\n        params.depositorPayoutScriptPubKey,\n        depositorBtcPubkey,\n        params.depositorBtcPubkeyRaw,\n      ),\n      peginTxHash,\n      vaultId: ensureHex(derivePeginVaultId(peginTxHash, depositor), \"vaultId\"),\n    };\n  }\n\n  private async assertVaultDoesNotExist(\n    vaultId: Hex,\n    peginTxHash: Hex,\n  ): Promise<void> {\n    const result = (await this.config.publicClient.readContract({\n      address: this.config.btcVaultRegistry,\n      abi: BTCVaultRegistryABI,\n      functionName: \"getBtcVaultBasicInfo\",\n      args: [vaultId],\n    })) as { depositor: Address };\n    if (result.depositor !== zeroAddress) {\n      throw new Error(\n        `Vault already exists (ID: ${vaultId}, peginTxHash: ${peginTxHash}). ` +\n          `Vault IDs are derived from the pegin transaction hash and depositor address. ` +\n          `To create a new vault, use different UTXOs or a different amount to generate a unique transaction.`,\n      );\n    }\n  }\n\n  private async readPeginFee(vaultProvider: Address): Promise<bigint> {\n    try {\n      return (await this.config.publicClient.readContract({\n        address: this.config.btcVaultRegistry,\n        abi: BTCVaultRegistryABI,\n        functionName: \"getPegInFee\",\n        args: [vaultProvider],\n      })) as bigint;\n    } catch (error) {\n      throw new Error(\n        \"Failed to query pegin fee from the contract. \" +\n          \"Please check your network connection and contract address.\",\n        { cause: error },\n      );\n    }\n  }\n\n  private async resolveMaxAcceptableCommissionBps(\n    vaultProvider: Address,\n    quotedCommissionBps?: number,\n  ): Promise<number> {\n    let currentBps: number;\n    try {\n      currentBps = await new ViemVaultRegistryReader(\n        this.config.publicClient,\n        this.config.btcVaultRegistry,\n      ).getVaultProviderCommission(vaultProvider);\n    } catch (error) {\n      throw new Error(\n        \"Failed to query vault provider commission from the contract. \" +\n          \"Please check your network connection and contract address.\",\n        { cause: error },\n      );\n    }\n    if (quotedCommissionBps !== undefined) {\n      if (currentBps > quotedCommissionBps + COMMISSION_BPS_HEADROOM) {\n        throw new Error(\n          `Vault provider commission changed since quote: quoted ${quotedCommissionBps} bps, ` +\n            `chain currently reports ${currentBps} bps (allowed drift ${COMMISSION_BPS_HEADROOM} bps). ` +\n            `Please refresh and try again.`,\n        );\n      }\n      return capMaxAcceptableCommissionBps(quotedCommissionBps);\n    }\n    return capMaxAcceptableCommissionBps(currentBps);\n  }\n\n  private async sendAndWait(\n    data: Hex,\n    value: bigint,\n    batch: boolean,\n    depositor: Address,\n  ): Promise<Hex> {\n    let account = this.assertEthAccount(depositor);\n    let gas: bigint;\n    try {\n      gas = await this.config.publicClient.estimateGas({\n        to: this.config.btcVaultRegistry,\n        data,\n        value,\n        account,\n      });\n    } catch (error) {\n      handleContractError(error);\n    }\n\n    account = this.assertEthAccount(depositor);\n    let submittedHash: Hex;\n    try {\n      submittedHash = await this.config.ethWallet.sendTransaction({\n        to: this.config.btcVaultRegistry,\n        data,\n        value,\n        gas,\n        account,\n        chain: this.config.ethChain,\n      });\n    } catch (error) {\n      handleContractError(error);\n    }\n    const receipt = await waitForTransactionReceiptSmartAware({\n      publicClient: this.config.publicClient,\n      walletAddress: depositor,\n      hash: submittedHash,\n      timeout: this.config.receiptTimeoutMs ?? RECEIPT_TIMEOUT_MS,\n    });\n    if (receipt.status === \"reverted\") {\n      handleContractError(\n        new Error(\n          `${batch ? \"Batch transaction\" : \"Transaction\"} reverted. ` +\n            `Hash: ${receipt.transactionHash}. Check a block explorer for details.`,\n        ),\n      );\n    }\n    return receipt.transactionHash;\n  }\n}\n"],"names":["COMMISSION_BPS_HEADROOM","MAX_ACCEPTABLE_COMMISSION_BPS_CAP","capMaxAcceptableCommissionBps","bps","MAX_VP_COMMISSION_BPS_EXCLUSIVE","Rho160","Id160","_","i","Pi160","idxLR","res","j","k","idxL","idxR","shifts160","shiftsL160","idx","shiftsR160","Kl160","Kr160","ripemd_f","group","x","y","z","BUF_160","_RIPEMD160","HashMD","__publicField","h0","h1","h2","h3","h4","view","offset","al","ar","bl","br","cl","cr","dl","dr","el","er","rGroup","hbl","hbr","rl","rr","sl","sr","tl","rotl","tr","clean","ripemd160","createHasher","crypto","isBytes","a","anumber","n","abytes","b","lengths","ahash","h","aexists","instance","checkFinished","aoutput","out","min","arrays","createView","arr","rotr","word","shift","hasHexBuiltin","hexes","bytesToHex","bytes","hex","asciis","asciiToBase16","ch","hexToBytes","hl","array","ai","hi","n1","n2","char","utf8ToBytes","str","toBytes","data","concatBytes","sum","pad","Hash","hashCons","hashC","msg","tmp","randomBytes","bytesLength","setBigUint64","byteOffset","value","isLE","_32n","_u32_max","wh","wl","Chi","c","Maj","blockLen","outputLen","padOffset","buffer","len","pos","take","dataView","oview","outLen","state","to","length","finished","destroyed","SHA256_IV","SHA256_K","SHA256_W","SHA256","A","B","C","D","E","F","G","H","W15","W2","s0","s1","sigma1","T1","T2","sha256","HMAC","hash","_key","key","buf","oHash","iHash","hmac","message","_0n","_1n","_abool2","title","prefix","_abytes2","isBytes_","needsLen","ofLen","got","numberToHexUnpadded","num","hexToNumber","bytesToNumberBE","bytesToHex_","bytesToNumberLE","abytes_","numberToBytesBE","hexToBytes_","numberToBytesLE","ensureBytes","expectedLength","e","isPosBig","inRange","max","aInRange","bitLen","bitMask","createHmacDrbg","hashLen","qByteLen","hmacFn","u8n","u8of","byte","v","reset","reseed","seed","gen","concatBytes_","pred","_validateObject","object","fields","optFields","checkField","fieldName","expectedType","isOpt","val","current","memoized","fn","map","arg","args","computed","_2n","_3n","_4n","_5n","_7n","_8n","_9n","_16n","mod","result","pow2","power","modulo","invert","number","u","q","r","m","assertIsSquare","Fp","root","sqrt3mod4","p1div4","sqrt5mod8","p5div8","nv","sqrt9mod16","P","Fp_","Field","tn","tonelliShanks","c1","c2","c3","c4","tv1","tv2","tv3","tv4","e1","e2","e3","Q","S","Z","_Fp","FpLegendre","cc","Q1div2","M","t","R","t_tmp","exponent","FpSqrt","FIELD_FIELDS","validateField","field","initial","opts","FpPow","p","d","FpInvertBatch","nums","passZero","inverted","multipliedAcc","acc","invertedAcc","p1mod2","powered","yes","zero","no","nLength","nBitLength","_nBitLength","nByteLength","ORDER","bitLenOrOpts","_nbitLength","_sqrt","modFromBytes","allowedLengths","_opts","BITS","BYTES","sqrtP","f","lhs","rhs","skipValidation","padded","scalar","lst","getFieldBytesLength","fieldOrder","bitLength","getMinHashLength","mapHashToField","fieldLen","minLen","reduced","negateCt","condition","item","neg","normalizeZ","points","invertedZs","validateW","W","bits","calcWOpts","scalarBits","windows","windowSize","maxNumber","mask","shiftBy","calcOffsets","window","wOpts","wbits","nextN","offsetStart","isZero","isNeg","isNegF","validateMSMPoints","validateMSMScalars","scalars","s","pointPrecomputes","pointWindowSizes","getW","assert0","wNAF","Point","elm","point","base","precomputes","wo","offsetF","transform","comp","prev","mulEndoUnsafe","k1","k2","p1","p2","pippenger","fieldN","plength","slength","MASK","buckets","lastBits","resI","sumI","createField","order","_createCurveFields","type","CURVE","curveOpts","FpFnLE","Fn","params","divNearest","den","_splitEndoScalar","basis","a1","b1","a2","b2","k1neg","k2neg","MAX_NUM","validateSigFormat","format","validateSigOpts","def","optsn","optName","abool","DERErr","DER","tag","dataLen","lenLen","first","isLong","lengthBytes","int","tlv","seqBytes","seqLeftBytes","rBytes","rLeftBytes","sBytes","sLeftBytes","sig","rs","ss","seq","_normFnElement","expected","weierstrassN","extraOpts","validated","cofactor","CURVE_ORDER","endo","getWLengths","assertCompressionIsSupported","pointToBytes","_c","isCompressed","bx","hasEvenY","pprefix","pointFromBytes","uncomp","head","tail","y2","weierstrassEquation","sqrtError","err","isYOdd","L","isValidXY","encodePoint","decodePoint","x2","x3","left","right","_4a3","_27b2","acoord","banZero","aprjpoint","other","splitEndoScalarN","toAffineMemo","iz","X","Y","is0","zz","assertValidMemo","finishEndo","endoBeta","k1p","k2p","isLazy","wnaf","X1","Y1","Z1","X2","Y2","Z2","U1","U2","b3","X3","Y3","Z3","t0","t1","t2","t3","t4","t5","fake","mul","k1f","k2f","sc","invertedZ","isTorsionFree","clearCofactor","privateKey","ecdh","ecdhOpts","randomBytes_","randomBytesWeb","isValidSecretKey","secretKey","isValidPublicKey","publicKey","publicKeyUncompressed","l","randomSecretKey","getPublicKey","keygen","isProbPub","getSharedSecret","secretKeyA","publicKeyB","ecdsa","ecdsaOpts","msgs","nobleHmac","fnBits","utils","defaultSigOpts","defaultSigOpts_format","isBiggerThanHalfOrder","HALF","validateRS","validateSigLength","size","sizer","Signature","recovery","recid","messageHash","FIELD_ORDER","rec","radj","ir","bits2int_modN","u1","u2","bits2int","delta","ORDER_MASK","int2octets","validateMsgAndHash","prehash","prepSig","lowS","extraEntropy","h1int","seedArgs","k2sig","kBytes","ik","normS","sign","tryParsingSig","sg","isHex","isObj","derError","verify","signature","is","recoverPublicKey","_weierstrass_legacy_opts_to_new","_ecdsa_legacy_opts_to_new","_ecdsa_new_output_to_legacy","_ecdsa","weierstrass","signs","createCurve","curveDef","defHash","create","secp256k1_CURVE","secp256k1_ENDO","sqrtMod","_6n","_11n","_22n","_23n","_44n","_88n","b6","b9","b11","b22","b44","b88","b176","b220","b223","Fpk1","secp256k1","TAGGED_HASH_PREFIXES","taggedHash","messages","tagP","tagH","Pointk1","hasEven","schnorrGetExtPubKey","priv","BASE","d_","lift_x","xx","challenge","schnorrGetPublicKey","schnorrSign","auxRand","px","rand","rx","schnorrVerify","pub","schnorr","P2TR_SCRIPT_PREFIX","P2WPKH_SCRIPT_PREFIX","HASH160_BYTES","COMPRESSED_PUBKEY_BYTES","UNCOMPRESSED_PUBKEY_BYTES","SEC1_EVEN_Y_PREFIX","SEC1_ODD_Y_PREFIX","SEC1_UNCOMPRESSED_PREFIX","normalizeHex","label","body","deriveP2trScript","xOnlyPubkey","pubkeyBytes","internalKey","tweak","outputKey","normalizePayoutPubkey","normalized","pubkey","assertOnChainBtcPubkey","isUncompressed","deriveP2wpkhScript","assertPayoutScriptMatchesPopKey","scriptPubKey","depositorBtcPubkey","depositorBtcPubkeyRaw","payoutScript","MAX_PAYOUT_SCRIPT_LEN","keyBody","payoutPubkey","decodeHex","encodeHex","chunks","chunk","serializeWithoutWitness","transaction","readLittleEndian","readCompactSize","start","version","hasWitness","inputCount","inputs","scriptLength","outputCount","outputs","hasWitnessData","itemCount","itemLength","locktime","calculateBtcTxHash","transactionHex","serialized","digest","derivePeginVaultId","peginTxHash","depositor","normalizedPeginTxHash","normalizedDepositor","isAddress","keccak256","encodeAbiParameters","UINT16_MAX","MAX_BASIS_POINTS","UINT32_MAX","UINT8_MAX","assertValidOffchainParamsVersion","validateOffchainParams","errors","validateTBVProtocolParams","validatePegInConfiguration","config","assertValidVaultCoreVersion","MAX_VP_COMMISSION_BPS","mapVaultBasicInfo","mapVaultProtocolInfo","offchainParamsVersion","UINT64_EXCLUSIVE_UPPER_BOUND","VP_GENESIS_KEY_EPOCH","assertEpochInRange","vaultId","mapKeyEpochs","ViemVaultRegistryReader","publicClient","contractAddress","vpAddress","blockNumber","BTCVaultRegistryABI","BTCVaultRegistryKeyEpochsABI","vaultIds","info","vaultProvider","basicRaw","protocolRaw","basic","protocol","NO_REFERRAL_CODE","RECEIPT_TIMEOUT_MS","ensureHex","prefixed","assertBytes32","assertHtlcVout","ViemPeginRegistrationClient","request","btcPopSignature","peginFee","maxCommission","callData","encodeFunctionData","batch","unsignedPrePeginTx","vaults","requests","seenVaultIds","vault","quotedCommissionBps","pop","expectedDepositor","account","isAddressEqual","depositorSignedPeginTx","zeroAddress","error","currentBps","gas","handleContractError","submittedHash","receipt","waitForTransactionReceiptSmartAware"],"mappings":"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","x_google_ignoreList":[1,2,3,4,5,6,7,8,9,10,11,12]}