@ecency/hive-tx 7.1.0

package/dist/browser/hive-tx.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hive-tx.min.js","mappings":"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","sources":["webpack://hiveTx/webpack/universalModuleDefinition","webpack://hiveTx/webpack/bootstrap","webpack://hiveTx/webpack/runtime/define property getters","webpack://hiveTx/webpack/runtime/hasOwnProperty shorthand","webpack://hiveTx/webpack/runtime/make namespace object","webpack://hiveTx/./node_modules/@noble/hashes/utils.js","webpack://hiveTx/./src/helpers/ByteBuffer.ts","webpack://hiveTx/./node_modules/@noble/hashes/_md.js","webpack://hiveTx/./node_modules/@noble/hashes/legacy.js","webpack://hiveTx/./node_modules/bs58/src/esm/index.js","webpack://hiveTx/./node_modules/base-x/src/esm/index.js","webpack://hiveTx/./src/config.ts","webpack://hiveTx/./node_modules/@noble/hashes/_u64.js","webpack://hiveTx/./node_modules/@noble/hashes/sha2.js","webpack://hiveTx/./node_modules/@noble/curves/utils.js","webpack://hiveTx/./node_modules/@noble/curves/abstract/modular.js","webpack://hiveTx/./node_modules/@noble/curves/abstract/curve.js","webpack://hiveTx/./node_modules/@noble/curves/abstract/hash-to-curve.js","webpack://hiveTx/./node_modules/@noble/hashes/hmac.js","webpack://hiveTx/./node_modules/@noble/curves/abstract/weierstrass.js","webpack://hiveTx/./node_modules/@noble/curves/secp256k1.js","webpack://hiveTx/./src/helpers/Signature.ts","webpack://hiveTx/./src/helpers/PublicKey.ts","webpack://hiveTx/./src/helpers/Asset.ts","webpack://hiveTx/./src/helpers/HexBuffer.ts","webpack://hiveTx/./src/helpers/serializer.ts","webpack://hiveTx/./src/helpers/sleep.ts","webpack://hiveTx/./src/helpers/call.ts","webpack://hiveTx/./src/Transaction.ts","webpack://hiveTx/./src/helpers/PrivateKey.ts","webpack://hiveTx/./node_modules/@noble/ciphers/utils.js","webpack://hiveTx/./node_modules/@noble/ciphers/_polyval.js","webpack://hiveTx/./node_modules/@noble/ciphers/aes.js","webpack://hiveTx/./src/helpers/aes.ts","webpack://hiveTx/./src/helpers/deserializer.ts","webpack://hiveTx/./src/helpers/memo.ts","webpack://hiveTx/./src/helpers/utils.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"hiveTx\"] = factory();\n\telse\n\t\troot[\"hiveTx\"] = factory();\n})(self, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\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, title = '') {\n    if (!Number.isSafeInteger(n) || n < 0) {\n        const prefix = title && `\"${title}\" `;\n        throw new Error(`${prefix}expected integer >= 0, got ${n}`);\n    }\n}\n/** Asserts something is Uint8Array. */\nexport function abytes(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/** Asserts something is hash */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash must 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, undefined, 'digestInto() output');\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error('\"digestInto() output\" expected to be of length >=' + 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/** 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 * Built-in doesn't validate input to be string: we do the check.\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 * Helper for KDFs: consumes uint8array or string.\n * When string is passed, does utf8 decoding, using TextDecoder.\n */\nexport function kdfInputToBytes(data, errorTitle = '') {\n    if (typeof data === 'string')\n        return utf8ToBytes(data);\n    return abytes(data, undefined, errorTitle);\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}\n/** Merges default options and passed options. */\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n        throw new Error('options must be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/** Creates function with outputLen, blockLen, create properties from a class constructor. */\nexport function createHasher(hashCons, info = {}) {\n    const hashC = (msg, opts) => hashCons(opts).update(msg).digest();\n    const tmp = hashCons(undefined);\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    Object.assign(hashC, info);\n    return Object.freeze(hashC);\n}\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;\n    if (typeof cr?.getRandomValues !== 'function')\n        throw new Error('crypto.getRandomValues must be defined');\n    return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n/** Creates OID opts for NIST hashes, with prefix 06 09 60 86 48 01 65 03 04 02. */\nexport const oidNist = (suffix) => ({\n    oid: Uint8Array.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, suffix]),\n});\n//# sourceMappingURL=utils.js.map","/**\n * @license bytebuffer.ts (c) 2015 Daniel Wirtz <dcode@dcode.io>\n * Backing buffer: ArrayBuffer, Accessor: DataView\n * Released under the Apache License, Version 2.0\n * see: https://github.com/dcodeIO/bytebuffer.ts for details\n * modified by @xmcl/bytebuffer\n * And customized for hive-tx\n */\nconst EMPTY_BUFFER = new ArrayBuffer(0);\nconst textEncoder = new TextEncoder();\nconst textDecoder = new TextDecoder();\nexport class ByteBuffer {\n    constructor(capacity = ByteBuffer.DEFAULT_CAPACITY, littleEndian = ByteBuffer.DEFAULT_ENDIAN) {\n        this.readUInt32 = this.readUint32;\n        this.buffer = capacity === 0 ? EMPTY_BUFFER : new ArrayBuffer(capacity);\n        this.view = capacity === 0 ? new DataView(EMPTY_BUFFER) : new DataView(this.buffer);\n        this.offset = 0;\n        this.markedOffset = -1;\n        this.limit = capacity;\n        this.littleEndian = littleEndian;\n    }\n    static allocate(capacity, littleEndian) {\n        return new ByteBuffer(capacity, littleEndian);\n    }\n    static concat(buffers, littleEndian) {\n        let capacity = 0;\n        for (let i = 0; i < buffers.length; ++i) {\n            const buf = buffers[i];\n            if (buf instanceof ByteBuffer) {\n                capacity += buf.limit - buf.offset;\n            }\n            else if (buf instanceof Uint8Array) {\n                capacity += buf.length;\n            }\n            else if (buf instanceof ArrayBuffer) {\n                capacity += buf.byteLength;\n            }\n            else if (Array.isArray(buf)) {\n                capacity += buf.length;\n            }\n            else {\n                throw TypeError('Illegal buffer');\n            }\n        }\n        if (capacity === 0) {\n            return new ByteBuffer(0, littleEndian);\n        }\n        const bb = new ByteBuffer(capacity, littleEndian);\n        const view = new Uint8Array(bb.buffer);\n        let offset = 0;\n        for (let i = 0; i < buffers.length; ++i) {\n            let buf = buffers[i];\n            if (buf instanceof ByteBuffer) {\n                view.set(new Uint8Array(buf.buffer, buf.offset, buf.limit - buf.offset), offset);\n                offset += buf.limit - buf.offset;\n            }\n            else if (buf instanceof Uint8Array) {\n                view.set(buf, offset);\n                offset += buf.length;\n            }\n            else if (buf instanceof ArrayBuffer) {\n                view.set(new Uint8Array(buf), offset);\n                offset += buf.byteLength;\n            }\n            else {\n                // Array\n                view.set(buf, offset);\n                offset += buf.length;\n            }\n        }\n        bb.limit = bb.offset = offset;\n        bb.offset = 0;\n        return bb;\n    }\n    static wrap(buffer, littleEndian) {\n        if (buffer instanceof ByteBuffer) {\n            const bb = buffer.clone();\n            bb.markedOffset = -1;\n            return bb;\n        }\n        let bb;\n        if (buffer instanceof Uint8Array) {\n            bb = new ByteBuffer(0, littleEndian);\n            if (buffer.length > 0) {\n                bb.buffer = buffer.buffer;\n                bb.offset = buffer.byteOffset;\n                bb.limit = buffer.byteOffset + buffer.byteLength;\n                bb.view = new DataView(buffer.buffer);\n            }\n        }\n        else if (buffer instanceof ArrayBuffer) {\n            bb = new ByteBuffer(0, littleEndian);\n            if (buffer.byteLength > 0) {\n                bb.buffer = buffer;\n                bb.offset = 0;\n                bb.limit = buffer.byteLength;\n                bb.view = buffer.byteLength > 0 ? new DataView(buffer) : new DataView(EMPTY_BUFFER);\n            }\n        }\n        else if (Array.isArray(buffer)) {\n            bb = new ByteBuffer(buffer.length, littleEndian);\n            bb.limit = buffer.length;\n            new Uint8Array(bb.buffer).set(buffer);\n        }\n        else {\n            throw TypeError('Illegal buffer');\n        }\n        return bb;\n    }\n    writeBytes(source, offset) {\n        return this.append(source, offset);\n    }\n    writeInt8(value, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        if (offset + 1 > this.buffer.byteLength) {\n            this.resize(offset + 1);\n        }\n        this.view.setInt8(offset, value);\n        if (relative)\n            this.offset += 1;\n        return this;\n    }\n    writeByte(value, offset) {\n        return this.writeInt8(value, offset);\n    }\n    writeUint8(value, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        if (offset + 1 > this.buffer.byteLength) {\n            this.resize(offset + 1);\n        }\n        this.view.setUint8(offset, value);\n        if (relative)\n            this.offset += 1;\n        return this;\n    }\n    writeUInt8(value, offset) {\n        return this.writeUint8(value, offset);\n    }\n    readUint8(offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        const value = this.view.getUint8(offset);\n        if (relative)\n            this.offset += 1;\n        return value;\n    }\n    readUInt8(offset) {\n        return this.readUint8(offset);\n    }\n    writeInt16(value, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        if (offset + 2 > this.buffer.byteLength) {\n            this.resize(offset + 2);\n        }\n        this.view.setInt16(offset, value, this.littleEndian);\n        if (relative)\n            this.offset += 2;\n        return this;\n    }\n    writeShort(value, offset) {\n        return this.writeInt16(value, offset);\n    }\n    writeUint16(value, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        if (offset + 2 > this.buffer.byteLength) {\n            this.resize(offset + 2);\n        }\n        this.view.setUint16(offset, value, this.littleEndian);\n        if (relative)\n            this.offset += 2;\n        return this;\n    }\n    writeUInt16(value, offset) {\n        return this.writeUint16(value, offset);\n    }\n    writeInt32(value, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        if (offset + 4 > this.buffer.byteLength) {\n            this.resize(offset + 4);\n        }\n        this.view.setInt32(offset, value, this.littleEndian);\n        if (relative)\n            this.offset += 4;\n        return this;\n    }\n    writeInt(value, offset) {\n        return this.writeInt32(value, offset);\n    }\n    writeUint32(value, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        if (offset + 4 > this.buffer.byteLength) {\n            this.resize(offset + 4);\n        }\n        this.view.setUint32(offset, value, this.littleEndian);\n        if (relative)\n            this.offset += 4;\n        return this;\n    }\n    writeUInt32(value, offset) {\n        return this.writeUint32(value, offset);\n    }\n    readUint32(offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        const value = this.view.getUint32(offset, this.littleEndian);\n        if (relative) {\n            this.offset += 4;\n        }\n        return value;\n    }\n    append(source, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        let src;\n        if (source instanceof ByteBuffer) {\n            src = new Uint8Array(source.buffer, source.offset, source.limit - source.offset);\n            source.offset += src.length;\n        }\n        else if (source instanceof Uint8Array) {\n            src = source;\n        }\n        else if (source instanceof ArrayBuffer) {\n            src = new Uint8Array(source);\n        }\n        else {\n            src = new Uint8Array(source);\n        }\n        if (src.length <= 0)\n            return this;\n        if (offset + src.length > this.buffer.byteLength) {\n            this.resize(offset + src.length);\n        }\n        new Uint8Array(this.buffer).set(src, offset);\n        if (relative)\n            this.offset += src.length;\n        return this;\n    }\n    clone(copy) {\n        const bb = new ByteBuffer(0, this.littleEndian);\n        if (copy) {\n            bb.buffer = new ArrayBuffer(this.buffer.byteLength);\n            new Uint8Array(bb.buffer).set(new Uint8Array(this.buffer));\n            bb.view = new DataView(bb.buffer);\n        }\n        else {\n            bb.buffer = this.buffer;\n            bb.view = this.view;\n        }\n        bb.offset = this.offset;\n        bb.markedOffset = this.markedOffset;\n        bb.limit = this.limit;\n        return bb;\n    }\n    copy(begin, end) {\n        if (begin === undefined)\n            begin = this.offset;\n        if (end === undefined)\n            end = this.limit;\n        if (begin === end) {\n            return new ByteBuffer(0, this.littleEndian);\n        }\n        const capacity = end - begin;\n        const bb = new ByteBuffer(capacity, this.littleEndian);\n        bb.offset = 0;\n        bb.limit = capacity;\n        new Uint8Array(bb.buffer).set(new Uint8Array(this.buffer).subarray(begin, end), 0);\n        return bb;\n    }\n    copyTo(target, targetOffset, sourceOffset, sourceLimit) {\n        const targetRelative = typeof targetOffset === 'undefined';\n        const relative = typeof sourceOffset === 'undefined';\n        targetOffset = targetRelative ? target.offset : targetOffset;\n        sourceOffset = relative ? this.offset : sourceOffset;\n        sourceLimit = sourceLimit === undefined ? this.limit : sourceLimit;\n        const len = sourceLimit - sourceOffset;\n        if (len === 0)\n            return target;\n        target.ensureCapacity(targetOffset + len);\n        new Uint8Array(target.buffer).set(new Uint8Array(this.buffer).subarray(sourceOffset, sourceLimit), targetOffset);\n        if (relative)\n            this.offset += len;\n        if (targetRelative)\n            target.offset += len;\n        return this;\n    }\n    ensureCapacity(capacity) {\n        let current = this.buffer.byteLength;\n        if (current < capacity) {\n            return this.resize((current *= 2) > capacity ? current : capacity);\n        }\n        return this;\n    }\n    flip() {\n        this.limit = this.offset;\n        this.offset = 0;\n        return this;\n    }\n    resize(capacity) {\n        if (this.buffer.byteLength < capacity) {\n            const buffer = new ArrayBuffer(capacity);\n            new Uint8Array(buffer).set(new Uint8Array(this.buffer));\n            this.buffer = buffer;\n            this.view = new DataView(buffer);\n        }\n        return this;\n    }\n    skip(length) {\n        this.offset += length;\n        return this;\n    }\n    writeInt64(value, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        if (typeof value === 'number')\n            value = BigInt(value);\n        if (offset + 8 > this.buffer.byteLength) {\n            this.resize(offset + 8);\n        }\n        this.view.setBigInt64(offset, value, this.littleEndian);\n        if (relative)\n            this.offset += 8;\n        return this;\n    }\n    writeLong(value, offset) {\n        return this.writeInt64(value, offset);\n    }\n    readInt64(offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        const value = this.view.getBigInt64(offset, this.littleEndian);\n        if (relative)\n            this.offset += 8;\n        return value;\n    }\n    readLong(offset) {\n        return this.readInt64(offset);\n    }\n    writeUint64(value, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        if (typeof value === 'number')\n            value = BigInt(value);\n        if (offset + 8 > this.buffer.byteLength) {\n            this.resize(offset + 8);\n        }\n        this.view.setBigUint64(offset, value, this.littleEndian);\n        if (relative)\n            this.offset += 8;\n        return this;\n    }\n    writeUInt64(value, offset) {\n        return this.writeUint64(value, offset);\n    }\n    readUint64(offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        const value = this.view.getBigUint64(offset, this.littleEndian);\n        if (relative)\n            this.offset += 8;\n        return value;\n    }\n    readUInt64(offset) {\n        return this.readUint64(offset);\n    }\n    toBuffer(forceCopy) {\n        const offset = this.offset;\n        const limit = this.limit;\n        if (!forceCopy && offset === 0 && limit === this.buffer.byteLength) {\n            return this.buffer;\n        }\n        if (offset === limit)\n            return EMPTY_BUFFER;\n        return this.buffer.slice(offset, limit);\n    }\n    toArrayBuffer(forceCopy) {\n        return this.toBuffer(forceCopy);\n    }\n    writeVarint32(value, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        const size = this.calculateVarint32(value);\n        if (offset + size > this.buffer.byteLength) {\n            this.resize(offset + size);\n        }\n        value >>>= 0;\n        while (value >= 0x80) {\n            this.view.setUint8(offset++, (value & 0x7f) | 0x80);\n            value >>>= 7;\n        }\n        this.view.setUint8(offset++, value);\n        if (relative) {\n            this.offset = offset;\n            return this;\n        }\n        return size;\n    }\n    readVarint32(offset) {\n        const relative = typeof offset === 'undefined';\n        if (typeof offset === 'undefined') {\n            offset = this.offset;\n        }\n        let c = 0;\n        let value = 0 >>> 0;\n        let b;\n        do {\n            b = this.view.getUint8(offset++);\n            if (c < 5) {\n                value |= (b & 0x7f) << (7 * c);\n            }\n            ++c;\n        } while ((b & 0x80) !== 0);\n        value |= 0;\n        if (relative) {\n            this.offset = offset;\n            return value;\n        }\n        return { value, length: c };\n    }\n    calculateVarint32(value) {\n        value = value >>> 0;\n        if (value < 1 << 7)\n            return 1;\n        else if (value < 1 << 14)\n            return 2;\n        else if (value < 1 << 21)\n            return 3;\n        else if (value < 1 << 28)\n            return 4;\n        else\n            return 5;\n    }\n    writeVString(str, offset) {\n        const relative = typeof offset === 'undefined';\n        let currentOffset = relative ? this.offset : offset;\n        const encoded = textEncoder.encode(str);\n        const len = encoded.length;\n        const lenVarintSize = this.calculateVarint32(len);\n        if (currentOffset + lenVarintSize + len > this.buffer.byteLength) {\n            this.resize(currentOffset + lenVarintSize + len);\n        }\n        this.writeVarint32(len, currentOffset);\n        currentOffset += lenVarintSize;\n        new Uint8Array(this.buffer).set(encoded, currentOffset);\n        currentOffset += len;\n        if (relative) {\n            this.offset = currentOffset;\n            return this;\n        }\n        return currentOffset - (offset || 0);\n    }\n    readVString(offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        const start = offset;\n        const lenResult = this.readVarint32(offset);\n        const lenValue = lenResult.value;\n        const lenLength = lenResult.length;\n        offset += lenLength;\n        // TextDecoder can take Uint8Array view directly\n        const str = textDecoder.decode(new Uint8Array(this.buffer, offset, lenValue));\n        offset += lenValue;\n        if (relative) {\n            this.offset = offset;\n            return str;\n        }\n        else {\n            return {\n                string: str,\n                length: offset - start\n            };\n        }\n    }\n    readUTF8String(length, offset) {\n        const relative = typeof offset === 'undefined';\n        if (relative)\n            offset = this.offset;\n        else\n            offset = offset;\n        // const strBuffer = this.buffer.slice(offset, end)\n        // Faster to view if Shared? No, Decoder takes buffer or view.\n        // Making a view is cheap.\n        // But DataView vs Uint8Array. TextDecoder takes BufferSource (ArrayBuffer or ArrayBufferView).\n        const str = textDecoder.decode(new Uint8Array(this.buffer, offset, length));\n        if (relative) {\n            this.offset += length;\n            return str;\n        }\n        else {\n            return {\n                string: str,\n                length\n            };\n        }\n    }\n}\nByteBuffer.LITTLE_ENDIAN = true;\nByteBuffer.BIG_ENDIAN = false;\nByteBuffer.DEFAULT_CAPACITY = 16;\nByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN;\n","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { abytes, aexists, aoutput, clean, createView } from \"./utils.js\";\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 {\n    blockLen;\n    outputLen;\n    padOffset;\n    isLE;\n    // For partial updates less than block size\n    buffer;\n    view;\n    finished = false;\n    length = 0;\n    pos = 0;\n    destroyed = false;\n    constructor(blockLen, outputLen, padOffset, isLE) {\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        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        view.setBigUint64(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 must be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen must 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 ||= 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\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","import basex from 'base-x';\nvar ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\nexport default basex(ALPHABET);\n","// base-x encoding / decoding\n// Copyright (c) 2018 base-x contributors\n// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\nfunction base (ALPHABET) {\n  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }\n  const BASE_MAP = new Uint8Array(256)\n  for (let j = 0; j < BASE_MAP.length; j++) {\n    BASE_MAP[j] = 255\n  }\n  for (let i = 0; i < ALPHABET.length; i++) {\n    const x = ALPHABET.charAt(i)\n    const xc = x.charCodeAt(0)\n    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\n    BASE_MAP[xc] = i\n  }\n  const BASE = ALPHABET.length\n  const LEADER = ALPHABET.charAt(0)\n  const FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up\n  const iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up\n  function encode (source) {\n    // eslint-disable-next-line no-empty\n    if (source instanceof Uint8Array) { } else if (ArrayBuffer.isView(source)) {\n      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)\n    } else if (Array.isArray(source)) {\n      source = Uint8Array.from(source)\n    }\n    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }\n    if (source.length === 0) { return '' }\n    // Skip & count leading zeroes.\n    let zeroes = 0\n    let length = 0\n    let pbegin = 0\n    const pend = source.length\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++\n      zeroes++\n    }\n    // Allocate enough space in big-endian base58 representation.\n    const size = ((pend - pbegin) * iFACTOR + 1) >>> 0\n    const b58 = new Uint8Array(size)\n    // Process the bytes.\n    while (pbegin !== pend) {\n      let carry = source[pbegin]\n      // Apply \"b58 = b58 * 256 + ch\".\n      let i = 0\n      for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {\n        carry += (256 * b58[it1]) >>> 0\n        b58[it1] = (carry % BASE) >>> 0\n        carry = (carry / BASE) >>> 0\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i\n      pbegin++\n    }\n    // Skip leading zeroes in base58 result.\n    let it2 = size - length\n    while (it2 !== size && b58[it2] === 0) {\n      it2++\n    }\n    // Translate the result into a string.\n    let str = LEADER.repeat(zeroes)\n    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }\n    return str\n  }\n  function decodeUnsafe (source) {\n    if (typeof source !== 'string') { throw new TypeError('Expected String') }\n    if (source.length === 0) { return new Uint8Array() }\n    let psz = 0\n    // Skip and count leading '1's.\n    let zeroes = 0\n    let length = 0\n    while (source[psz] === LEADER) {\n      zeroes++\n      psz++\n    }\n    // Allocate enough space in big-endian base256 representation.\n    const size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.\n    const b256 = new Uint8Array(size)\n    // Process the characters.\n    while (psz < source.length) {\n      // Find code of next character\n      const charCode = source.charCodeAt(psz)\n      // Base map can not be indexed using char code\n      if (charCode > 255) { return }\n      // Decode character\n      let carry = BASE_MAP[charCode]\n      // Invalid character\n      if (carry === 255) { return }\n      let i = 0\n      for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {\n        carry += (BASE * b256[it3]) >>> 0\n        b256[it3] = (carry % 256) >>> 0\n        carry = (carry / 256) >>> 0\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i\n      psz++\n    }\n    // Skip leading zeroes in b256.\n    let it4 = size - length\n    while (it4 !== size && b256[it4] === 0) {\n      it4++\n    }\n    const vch = new Uint8Array(zeroes + (size - it4))\n    let j = zeroes\n    while (it4 !== size) {\n      vch[j++] = b256[it4++]\n    }\n    return vch\n  }\n  function decode (string) {\n    const buffer = decodeUnsafe(string)\n    if (buffer) { return buffer }\n    throw new Error('Non-base' + BASE + ' character')\n  }\n  return {\n    encode,\n    decodeUnsafe,\n    decode\n  }\n}\nexport default base\n","/**\n * Configuration object for customizing hive-tx library behavior.\n * Modify these values to change the default node endpoints, timeout, and other settings.\n */\nexport const config = {\n    /**\n     * Array of Hive API node endpoints for load balancing and failover.\n     * @default Array of multiple Hive API endpoints\n     */\n    nodes: [\n        'https://api.hive.blog',\n        'https://api.deathwing.me',\n        'https://api.openhive.network',\n        'https://rpc.mahdiyari.info',\n        'https://techcoderx.com',\n        'https://hiveapi.actifit.io',\n        'https://api.c0ff33a.uk'\n    ],\n    /**\n     * Array Hive API node endpoints that support REST APIs\n     * Note: Without the trailing /\n     */\n    restNodes: [\n        'https://api.hive.blog',\n        'https://rpc.mahdiyari.info',\n        'https://techcoderx.com',\n        'https://hiveapi.actifit.io',\n        'https://api.c0ff33a.uk'\n    ],\n    /**\n     * The Hive blockchain chain ID for transaction signing and verification.\n     * @default Mainnet chain ID\n     */\n    chain_id: 'beeab0de00000000000000000000000000000000000000000000000000000000',\n    /**\n     * Address prefix used for public key formatting (STM for mainnet).\n     * @default 'STM'\n     */\n    address_prefix: 'STM',\n    /**\n     * Timeout in milliseconds for individual API calls.\n     * @default 10000\n     */\n    timeout: 10000,\n    /**\n     * Number of retry attempts for failed API calls before throwing an error.\n     * @default 8\n     */\n    retry: 8\n};\n","/**\n * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.\n * @todo re-check https://issues.chromium.org/issues/42212588\n * @module\n */\nconst U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\nfunction fromBig(n, le = false) {\n    if (le)\n        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\nfunction split(lst, le = false) {\n    const len = lst.length;\n    let Ah = new Uint32Array(len);\n    let Al = new Uint32Array(len);\n    for (let i = 0; i < len; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h, _l, s) => h >>> s;\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h, l) => l;\nconst rotr32L = (h, _l) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\nfunction add(Ah, Al, Bh, Bl) {\n    const l = (Al >>> 0) + (Bl >>> 0);\n    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\n// Addition with more than 2 elements\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n// prettier-ignore\nexport { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };\n// prettier-ignore\nconst u64 = {\n    fromBig, split, toBig,\n    shrSH, shrSL,\n    rotrSH, rotrSL, rotrBH, rotrBL,\n    rotr32H, rotr32L,\n    rotlSH, rotlSL, rotlBH, rotlBL,\n    add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n//# sourceMappingURL=_u64.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://www.rfc-editor.org/rfc/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, oidNist, 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);\n/** Internal 32-byte base SHA2 hash class. */\nclass SHA2_32B extends HashMD {\n    constructor(outputLen) {\n        super(64, outputLen, 8, false);\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}\n/** Internal SHA2-256 hash class. */\nexport class _SHA256 extends SHA2_32B {\n    // We cannot use array here since array allows indexing by variable\n    // which means optimizer/compiler cannot use registers.\n    A = SHA256_IV[0] | 0;\n    B = SHA256_IV[1] | 0;\n    C = SHA256_IV[2] | 0;\n    D = SHA256_IV[3] | 0;\n    E = SHA256_IV[4] | 0;\n    F = SHA256_IV[5] | 0;\n    G = SHA256_IV[6] | 0;\n    H = SHA256_IV[7] | 0;\n    constructor() {\n        super(32);\n    }\n}\n/** Internal SHA2-224 hash class. */\nexport class _SHA224 extends SHA2_32B {\n    A = SHA224_IV[0] | 0;\n    B = SHA224_IV[1] | 0;\n    C = SHA224_IV[2] | 0;\n    D = SHA224_IV[3] | 0;\n    E = SHA224_IV[4] | 0;\n    F = SHA224_IV[5] | 0;\n    G = SHA224_IV[6] | 0;\n    H = SHA224_IV[7] | 0;\n    constructor() {\n        super(28);\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);\n/** Internal 64-byte base SHA2 hash class. */\nclass SHA2_64B extends HashMD {\n    constructor(outputLen) {\n        super(128, outputLen, 16, false);\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}\n/** Internal SHA2-512 hash class. */\nexport class _SHA512 extends SHA2_64B {\n    Ah = SHA512_IV[0] | 0;\n    Al = SHA512_IV[1] | 0;\n    Bh = SHA512_IV[2] | 0;\n    Bl = SHA512_IV[3] | 0;\n    Ch = SHA512_IV[4] | 0;\n    Cl = SHA512_IV[5] | 0;\n    Dh = SHA512_IV[6] | 0;\n    Dl = SHA512_IV[7] | 0;\n    Eh = SHA512_IV[8] | 0;\n    El = SHA512_IV[9] | 0;\n    Fh = SHA512_IV[10] | 0;\n    Fl = SHA512_IV[11] | 0;\n    Gh = SHA512_IV[12] | 0;\n    Gl = SHA512_IV[13] | 0;\n    Hh = SHA512_IV[14] | 0;\n    Hl = SHA512_IV[15] | 0;\n    constructor() {\n        super(64);\n    }\n}\n/** Internal SHA2-384 hash class. */\nexport class _SHA384 extends SHA2_64B {\n    Ah = SHA384_IV[0] | 0;\n    Al = SHA384_IV[1] | 0;\n    Bh = SHA384_IV[2] | 0;\n    Bl = SHA384_IV[3] | 0;\n    Ch = SHA384_IV[4] | 0;\n    Cl = SHA384_IV[5] | 0;\n    Dh = SHA384_IV[6] | 0;\n    Dl = SHA384_IV[7] | 0;\n    Eh = SHA384_IV[8] | 0;\n    El = SHA384_IV[9] | 0;\n    Fh = SHA384_IV[10] | 0;\n    Fl = SHA384_IV[11] | 0;\n    Gh = SHA384_IV[12] | 0;\n    Gl = SHA384_IV[13] | 0;\n    Hh = SHA384_IV[14] | 0;\n    Hl = SHA384_IV[15] | 0;\n    constructor() {\n        super(48);\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]);\n/** Internal SHA2-512/224 hash class. */\nexport class _SHA512_224 extends SHA2_64B {\n    Ah = T224_IV[0] | 0;\n    Al = T224_IV[1] | 0;\n    Bh = T224_IV[2] | 0;\n    Bl = T224_IV[3] | 0;\n    Ch = T224_IV[4] | 0;\n    Cl = T224_IV[5] | 0;\n    Dh = T224_IV[6] | 0;\n    Dl = T224_IV[7] | 0;\n    Eh = T224_IV[8] | 0;\n    El = T224_IV[9] | 0;\n    Fh = T224_IV[10] | 0;\n    Fl = T224_IV[11] | 0;\n    Gh = T224_IV[12] | 0;\n    Gl = T224_IV[13] | 0;\n    Hh = T224_IV[14] | 0;\n    Hl = T224_IV[15] | 0;\n    constructor() {\n        super(28);\n    }\n}\n/** Internal SHA2-512/256 hash class. */\nexport class _SHA512_256 extends SHA2_64B {\n    Ah = T256_IV[0] | 0;\n    Al = T256_IV[1] | 0;\n    Bh = T256_IV[2] | 0;\n    Bl = T256_IV[3] | 0;\n    Ch = T256_IV[4] | 0;\n    Cl = T256_IV[5] | 0;\n    Dh = T256_IV[6] | 0;\n    Dl = T256_IV[7] | 0;\n    Eh = T256_IV[8] | 0;\n    El = T256_IV[9] | 0;\n    Fh = T256_IV[10] | 0;\n    Fl = T256_IV[11] | 0;\n    Gh = T256_IV[12] | 0;\n    Gl = T256_IV[13] | 0;\n    Hh = T256_IV[14] | 0;\n    Hl = T256_IV[15] | 0;\n    constructor() {\n        super(32);\n    }\n}\n/**\n * SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:\n *\n * - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.\n * - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n * - Each sha256 hash is executing 2^18 bit operations.\n * - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new _SHA256(), \n/* @__PURE__ */ oidNist(0x01));\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new _SHA224(), \n/* @__PURE__ */ oidNist(0x04));\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new _SHA512(), \n/* @__PURE__ */ oidNist(0x03));\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new _SHA384(), \n/* @__PURE__ */ oidNist(0x02));\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/* @__PURE__ */ oidNist(0x06));\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/* @__PURE__ */ oidNist(0x05));\n//# sourceMappingURL=sha2.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_, anumber, bytesToHex as bytesToHex_, concatBytes as concatBytes_, hexToBytes as hexToBytes_, } from '@noble/hashes/utils.js';\nexport { abytes, anumber, bytesToHex, concatBytes, hexToBytes, isBytes, randomBytes, } from '@noble/hashes/utils.js';\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function abool(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// Used in weierstrass, der\nfunction abignumber(n) {\n    if (typeof n === 'bigint') {\n        if (!isPosBig(n))\n            throw new Error('positive bigint expected, got ' + n);\n    }\n    else\n        anumber(n);\n    return n;\n}\nexport function asafenumber(value, title = '') {\n    if (!Number.isSafeInteger(value)) {\n        const prefix = title && `\"${title}\" `;\n        throw new Error(prefix + 'expected safe integer, got type=' + typeof value);\n    }\n}\nexport function numberToHexUnpadded(num) {\n    const hex = abignumber(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    return hexToNumber(bytesToHex_(copyBytes(abytes_(bytes)).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    anumber(len);\n    n = abignumber(n);\n    const res = hexToBytes_(n.toString(16).padStart(len * 2, '0'));\n    if (res.length !== len)\n        throw new Error('number too large');\n    return res;\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(abignumber(n)));\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 `TextEncoder` 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// 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    anumber(hashLen, 'hashLen');\n    anumber(qByteLen, 'qByteLen');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    const u8n = (len) => new Uint8Array(len); // creates Uint8Array\n    const NULL = Uint8Array.of();\n    const byte0 = Uint8Array.of(0x00);\n    const byte1 = Uint8Array.of(0x01);\n    const _maxDrbgIters = 1000;\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...msgs) => hmacFn(k, concatBytes_(v, ...msgs)); // hmac(k)(v, ...values)\n    const reseed = (seed = NULL) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(byte0, seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(byte1, 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++ >= _maxDrbgIters)\n            throw new Error('drbg: tried max amount of iterations');\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}\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    const iter = (f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));\n    iter(fields, false);\n    iter(optFields, 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 { abytes, anumber, bytesToNumberBE, bytesToNumberLE, numberToBytesBE, numberToBytesLE, validateObject, } from \"../utils.js\";\n// Numbers aren't used in x25519 / x448 builds\n// prettier-ignore\nconst _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2);\n// prettier-ignore\nconst _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5);\n// prettier-ignore\nconst _7n = /* @__PURE__ */ BigInt(7), _8n = /* @__PURE__ */ BigInt(8), _9n = /* @__PURE__ */ BigInt(9);\nconst _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        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}\nclass _Field {\n    ORDER;\n    BITS;\n    BYTES;\n    isLE;\n    ZERO = _0n;\n    ONE = _1n;\n    _lengths;\n    _sqrt; // cached sqrt\n    _mod;\n    constructor(ORDER, opts = {}) {\n        if (ORDER <= _0n)\n            throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);\n        let _nbitLength = undefined;\n        this.isLE = false;\n        if (opts != null && typeof opts === 'object') {\n            if (typeof opts.BITS === 'number')\n                _nbitLength = opts.BITS;\n            if (typeof opts.sqrt === 'function')\n                this.sqrt = opts.sqrt;\n            if (typeof opts.isLE === 'boolean')\n                this.isLE = opts.isLE;\n            if (opts.allowedLengths)\n                this._lengths = opts.allowedLengths?.slice();\n            if (typeof opts.modFromBytes === 'boolean')\n                this._mod = opts.modFromBytes;\n        }\n        const { nBitLength, nByteLength } = nLength(ORDER, _nbitLength);\n        if (nByteLength > 2048)\n            throw new Error('invalid field: expected ORDER of <= 2048 bytes');\n        this.ORDER = ORDER;\n        this.BITS = nBitLength;\n        this.BYTES = nByteLength;\n        this._sqrt = undefined;\n        Object.preventExtensions(this);\n    }\n    create(num) {\n        return mod(num, this.ORDER);\n    }\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 < this.ORDER; // 0 is valid element, but it's not invertible\n    }\n    is0(num) {\n        return num === _0n;\n    }\n    // is valid and invertible\n    isValidNot0(num) {\n        return !this.is0(num) && this.isValid(num);\n    }\n    isOdd(num) {\n        return (num & _1n) === _1n;\n    }\n    neg(num) {\n        return mod(-num, this.ORDER);\n    }\n    eql(lhs, rhs) {\n        return lhs === rhs;\n    }\n    sqr(num) {\n        return mod(num * num, this.ORDER);\n    }\n    add(lhs, rhs) {\n        return mod(lhs + rhs, this.ORDER);\n    }\n    sub(lhs, rhs) {\n        return mod(lhs - rhs, this.ORDER);\n    }\n    mul(lhs, rhs) {\n        return mod(lhs * rhs, this.ORDER);\n    }\n    pow(num, power) {\n        return FpPow(this, num, power);\n    }\n    div(lhs, rhs) {\n        return mod(lhs * invert(rhs, this.ORDER), this.ORDER);\n    }\n    // Same as above, but doesn't normalize\n    sqrN(num) {\n        return num * num;\n    }\n    addN(lhs, rhs) {\n        return lhs + rhs;\n    }\n    subN(lhs, rhs) {\n        return lhs - rhs;\n    }\n    mulN(lhs, rhs) {\n        return lhs * rhs;\n    }\n    inv(num) {\n        return invert(num, this.ORDER);\n    }\n    sqrt(num) {\n        // Caching _sqrt speeds up sqrt9mod16 by 5x and tonneli-shanks by 10%\n        if (!this._sqrt)\n            this._sqrt = FpSqrt(this.ORDER);\n        return this._sqrt(this, num);\n    }\n    toBytes(num) {\n        return this.isLE ? numberToBytesLE(num, this.BYTES) : numberToBytesBE(num, this.BYTES);\n    }\n    fromBytes(bytes, skipValidation = false) {\n        abytes(bytes);\n        const { _lengths: allowedLengths, BYTES, isLE, ORDER, _mod: modFromBytes } = this;\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 (!this.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) {\n        return FpInvertBatch(this, lst);\n    }\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, condition) {\n        return condition ? b : a;\n    }\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, opts = {}) {\n    return new _Field(ORDER, opts);\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 * 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.Point.Fn.ORDER)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n    abytes(key);\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 } from \"../utils.js\";\nimport { Field, FpInvertBatch, validateField } from \"./modular.js\";\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function negateCt(condition, item) {\n    const neg = item.negate();\n    return condition ? neg : item;\n}\n/**\n * Takes a bunch of Projective Points but executes only one\n * inversion on all of them. Inversion is very slow operation,\n * so this improves performance massively.\n * Optimization: converts a list of projective points to a list of identical points with Z=1.\n */\nexport function normalizeZ(c, points) {\n    const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));\n    return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));\n}\nfunction validateW(W, bits) {\n    if (!Number.isSafeInteger(W) || W <= 0 || W > bits)\n        throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);\n}\nfunction calcWOpts(W, scalarBits) {\n    validateW(W, scalarBits);\n    const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero\n    const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero\n    const maxNumber = 2 ** W; // W=8 256\n    const mask = bitMask(W); // W=8 255 == mask 0b11111111\n    const shiftBy = BigInt(W); // W=8 8\n    return { windows, windowSize, mask, maxNumber, shiftBy };\n}\nfunction calcOffsets(n, window, wOpts) {\n    const { windowSize, mask, maxNumber, shiftBy } = wOpts;\n    let wbits = Number(n & mask); // extract W bits.\n    let nextN = n >> shiftBy; // shift number by W bits.\n    // What actually happens here:\n    // const highestBit = Number(mask ^ (mask >> 1n));\n    // let wbits2 = wbits - 1; // skip zero\n    // if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);\n    // split if bits > max: +224 => 256-32\n    if (wbits > windowSize) {\n        // we skip zero, which means instead of `>= size-1`, we do `> size`\n        wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.\n        nextN += _1n; // +256 (carry)\n    }\n    const offsetStart = window * windowSize;\n    const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero\n    const isZero = wbits === 0; // is current window slice a 0?\n    const isNeg = wbits < 0; // is current window slice negative?\n    const isNegF = window % 2 !== 0; // fake random statement for noise\n    const offsetF = offsetStart; // fake offset for noise\n    return { nextN, offset, isZero, isNeg, isNegF, offsetF };\n}\nfunction validateMSMPoints(points, c) {\n    if (!Array.isArray(points))\n        throw new Error('array expected');\n    points.forEach((p, i) => {\n        if (!(p instanceof c))\n            throw new Error('invalid point at index ' + i);\n    });\n}\nfunction validateMSMScalars(scalars, field) {\n    if (!Array.isArray(scalars))\n        throw new Error('array of scalars expected');\n    scalars.forEach((s, i) => {\n        if (!field.isValid(s))\n            throw new Error('invalid scalar at index ' + i);\n    });\n}\n// Since points in different groups cannot be equal (different object constructor),\n// we can have single place to store precomputes.\n// Allows to make points frozen / immutable.\nconst pointPrecomputes = new WeakMap();\nconst pointWindowSizes = new WeakMap();\nfunction getW(P) {\n    // To disable precomputes:\n    // return 1;\n    return pointWindowSizes.get(P) || 1;\n}\nfunction assert0(n) {\n    if (n !== _0n)\n        throw new Error('invalid wNAF');\n}\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Table generation takes **30MB of ram and 10ms on high-end CPU**,\n * but may take much longer on slow devices. Actual generation will happen on\n * first call of `multiply()`. By default, `BASE` point is precomputed.\n *\n * Scalars should always be less than curve order: this should be checked inside of a curve itself.\n * Creates precomputation tables for fast multiplication:\n * - private scalar is split by fixed size windows of W bits\n * - every window point is collected from window's table & added to accumulator\n * - since windows are different, same point inside tables won't be accessed more than once per calc\n * - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n * - +1 window is neccessary for wNAF\n * - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n *\n * @todo Research returning 2d JS array of windows, instead of a single window.\n * This would allow windows to be in different memory locations\n */\nexport class wNAF {\n    BASE;\n    ZERO;\n    Fn;\n    bits;\n    // Parametrized with a given Point class (not individual point)\n    constructor(Point, bits) {\n        this.BASE = Point.BASE;\n        this.ZERO = Point.ZERO;\n        this.Fn = Point.Fn;\n        this.bits = bits;\n    }\n    // non-const time multiplication ladder\n    _unsafeLadder(elm, n, p = this.ZERO) {\n        let d = elm;\n        while (n > _0n) {\n            if (n & _1n)\n                p = p.add(d);\n            d = d.double();\n            n >>= _1n;\n        }\n        return p;\n    }\n    /**\n     * Creates a wNAF precomputation window. Used for caching.\n     * Default window size is set by `utils.precompute()` and is equal to 8.\n     * Number of precomputed points depends on the curve size:\n     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n     * - 𝑊 is the window size\n     * - 𝑛 is the bitlength of the curve order.\n     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n     * @param point Point instance\n     * @param W window size\n     * @returns precomputed point tables flattened to a single array\n     */\n    precomputeWindow(point, W) {\n        const { windows, windowSize } = calcWOpts(W, this.bits);\n        const points = [];\n        let p = point;\n        let base = p;\n        for (let window = 0; window < windows; window++) {\n            base = p;\n            points.push(base);\n            // i=1, bc we skip 0\n            for (let i = 1; i < windowSize; i++) {\n                base = base.add(p);\n                points.push(base);\n            }\n            p = base.double();\n        }\n        return points;\n    }\n    /**\n     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n     * More compact implementation:\n     * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541\n     * @returns real and fake (for const-time) points\n     */\n    wNAF(W, precomputes, n) {\n        // Scalar should be smaller than field order\n        if (!this.Fn.isValid(n))\n            throw new Error('invalid scalar');\n        // Accumulators\n        let p = this.ZERO;\n        let f = this.BASE;\n        // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n        // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n        // there is negate now: it is possible that negated element from low value\n        // would be the same as high element, which will create carry into next window.\n        // It's not obvious how this can fail, but still worth investigating later.\n        const wo = calcWOpts(W, this.bits);\n        for (let window = 0; window < wo.windows; window++) {\n            // (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise\n            const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);\n            n = nextN;\n            if (isZero) {\n                // bits are 0: add garbage to fake point\n                // Important part for const-time getPublicKey: add random \"noise\" point to f.\n                f = f.add(negateCt(isNegF, precomputes[offsetF]));\n            }\n            else {\n                // bits are 1: add to result point\n                p = p.add(negateCt(isNeg, precomputes[offset]));\n            }\n        }\n        assert0(n);\n        // Return both real and fake points: JIT won't eliminate f.\n        // At this point there is a way to F be infinity-point even if p is not,\n        // which makes it less const-time: around 1 bigint multiply.\n        return { p, f };\n    }\n    /**\n     * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.\n     * @param acc accumulator point to add result of multiplication\n     * @returns point\n     */\n    wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {\n        const wo = calcWOpts(W, this.bits);\n        for (let window = 0; window < wo.windows; window++) {\n            if (n === _0n)\n                break; // Early-exit, skip 0 value\n            const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);\n            n = nextN;\n            if (isZero) {\n                // Window bits are 0: skip processing.\n                // Move to next window.\n                continue;\n            }\n            else {\n                const item = precomputes[offset];\n                acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM\n            }\n        }\n        assert0(n);\n        return acc;\n    }\n    getPrecomputes(W, point, transform) {\n        // Calculate precomputes on a first run, reuse them after\n        let comp = pointPrecomputes.get(point);\n        if (!comp) {\n            comp = this.precomputeWindow(point, W);\n            if (W !== 1) {\n                // Doing transform outside of if brings 15% perf hit\n                if (typeof transform === 'function')\n                    comp = transform(comp);\n                pointPrecomputes.set(point, comp);\n            }\n        }\n        return comp;\n    }\n    cached(point, scalar, transform) {\n        const W = getW(point);\n        return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);\n    }\n    unsafe(point, scalar, transform, prev) {\n        const W = getW(point);\n        if (W === 1)\n            return this._unsafeLadder(point, scalar, prev); // For W=1 ladder is ~x2 faster\n        return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);\n    }\n    // We calculate precomputes for elliptic curve point multiplication\n    // using windowed method. This specifies window size and\n    // stores precomputed values. Usually only base point would be precomputed.\n    createCache(P, W) {\n        validateW(W, this.bits);\n        pointWindowSizes.set(P, W);\n        pointPrecomputes.delete(P);\n    }\n    hasCache(elm) {\n        return getW(elm) !== 1;\n    }\n}\n/**\n * Endomorphism-specific multiplication for Koblitz curves.\n * Cost: 128 dbl, 0-256 adds.\n */\nexport function mulEndoUnsafe(Point, point, k1, k2) {\n    let acc = point;\n    let p1 = Point.ZERO;\n    let p2 = Point.ZERO;\n    while (k1 > _0n || k2 > _0n) {\n        if (k1 & _1n)\n            p1 = p1.add(acc);\n        if (k2 & _1n)\n            p2 = p2.add(acc);\n        acc = acc.double();\n        k1 >>= _1n;\n        k2 >>= _1n;\n    }\n    return { p1, p2 };\n}\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster than precomputes.\n * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.\n * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @param scalars array of L scalars (aka secret keys / bigints)\n */\nexport function pippenger(c, points, scalars) {\n    // If we split scalars by some window (let's say 8 bits), every chunk will only\n    // take 256 buckets even if there are 4096 scalars, also re-uses double.\n    // TODO:\n    // - https://eprint.iacr.org/2024/750.pdf\n    // - https://tches.iacr.org/index.php/TCHES/article/view/10287\n    // 0 is accepted in scalars\n    const fieldN = c.Fn;\n    validateMSMPoints(points, c);\n    validateMSMScalars(scalars, fieldN);\n    const plength = points.length;\n    const slength = scalars.length;\n    if (plength !== slength)\n        throw new Error('arrays of points and scalars must have equal length');\n    // if (plength === 0) throw new Error('array must be of length >= 2');\n    const zero = c.ZERO;\n    const wbits = bitLen(BigInt(plength));\n    let windowSize = 1; // bits\n    if (wbits > 12)\n        windowSize = wbits - 3;\n    else if (wbits > 4)\n        windowSize = wbits - 2;\n    else if (wbits > 0)\n        windowSize = 2;\n    const MASK = bitMask(windowSize);\n    const buckets = new Array(Number(MASK) + 1).fill(zero); // +1 for zero array\n    const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;\n    let sum = zero;\n    for (let i = lastBits; i >= 0; i -= windowSize) {\n        buckets.fill(zero);\n        for (let j = 0; j < slength; j++) {\n            const scalar = scalars[j];\n            const wbits = Number((scalar >> BigInt(i)) & MASK);\n            buckets[wbits] = buckets[wbits].add(points[j]);\n        }\n        let resI = zero; // not using this will do small speed-up, but will lose ct\n        // Skip first bucket, because it is zero\n        for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {\n            sumI = sumI.add(buckets[j]);\n            resI = resI.add(sumI);\n        }\n        sum = sum.add(resI);\n        if (i !== 0)\n            for (let j = 0; j < windowSize; j++)\n                sum = sum.double();\n    }\n    return sum;\n}\n/**\n * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @returns function which multiplies points with scaars\n */\nexport function precomputeMSMUnsafe(c, points, windowSize) {\n    /**\n     * Performance Analysis of Window-based Precomputation\n     *\n     * Base Case (256-bit scalar, 8-bit window):\n     * - Standard precomputation requires:\n     *   - 31 additions per scalar × 256 scalars = 7,936 ops\n     *   - Plus 255 summary additions = 8,191 total ops\n     *   Note: Summary additions can be optimized via accumulator\n     *\n     * Chunked Precomputation Analysis:\n     * - Using 32 chunks requires:\n     *   - 255 additions per chunk\n     *   - 256 doublings\n     *   - Total: (255 × 32) + 256 = 8,416 ops\n     *\n     * Memory Usage Comparison:\n     * Window Size | Standard Points | Chunked Points\n     * ------------|-----------------|---------------\n     *     4-bit   |     520         |      15\n     *     8-bit   |    4,224        |     255\n     *    10-bit   |   13,824        |   1,023\n     *    16-bit   |  557,056        |  65,535\n     *\n     * Key Advantages:\n     * 1. Enables larger window sizes due to reduced memory overhead\n     * 2. More efficient for smaller scalar counts:\n     *    - 16 chunks: (16 × 255) + 256 = 4,336 ops\n     *    - ~2x faster than standard 8,191 ops\n     *\n     * Limitations:\n     * - Not suitable for plain precomputes (requires 256 constant doublings)\n     * - Performance degrades with larger scalar counts:\n     *   - Optimal for ~256 scalars\n     *   - Less efficient for 4096+ scalars (Pippenger preferred)\n     */\n    const fieldN = c.Fn;\n    validateW(windowSize, fieldN.BITS);\n    validateMSMPoints(points, c);\n    const zero = c.ZERO;\n    const tableSize = 2 ** windowSize - 1; // table size (without zero)\n    const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item\n    const MASK = bitMask(windowSize);\n    const tables = points.map((p) => {\n        const res = [];\n        for (let i = 0, acc = p; i < tableSize; i++) {\n            res.push(acc);\n            acc = acc.add(p);\n        }\n        return res;\n    });\n    return (scalars) => {\n        validateMSMScalars(scalars, fieldN);\n        if (scalars.length > points.length)\n            throw new Error('array of scalars must be smaller than array of points');\n        let res = zero;\n        for (let i = 0; i < chunks; i++) {\n            // No need to double if accumulator is still zero.\n            if (res !== zero)\n                for (let j = 0; j < windowSize; j++)\n                    res = res.double();\n            const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);\n            for (let j = 0; j < scalars.length; j++) {\n                const n = scalars[j];\n                const curr = Number((n >> shiftBy) & MASK);\n                if (!curr)\n                    continue; // skip zero scalars chunks\n                res = res.add(tables[j][curr - 1]);\n            }\n        }\n        return res;\n    };\n}\nfunction createField(order, field, isLE) {\n    if (field) {\n        if (field.ORDER !== order)\n            throw new Error('Field.ORDER must match order: Fp == p, Fn == n');\n        validateField(field);\n        return field;\n    }\n    else {\n        return Field(order, { isLE });\n    }\n}\n/** Validates CURVE opts and creates fields */\nexport function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {\n    if (FpFnLE === undefined)\n        FpFnLE = type === 'edwards';\n    if (!CURVE || typeof CURVE !== 'object')\n        throw new Error(`expected valid ${type} CURVE object`);\n    for (const p of ['p', 'n', 'h']) {\n        const val = CURVE[p];\n        if (!(typeof val === 'bigint' && val > _0n))\n            throw new Error(`CURVE.${p} must be positive bigint`);\n    }\n    const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);\n    const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);\n    const _b = type === 'weierstrass' ? 'b' : 'd';\n    const params = ['Gx', 'Gy', 'a', _b];\n    for (const p of params) {\n        // @ts-ignore\n        if (!Fp.isValid(CURVE[p]))\n            throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);\n    }\n    CURVE = Object.freeze(Object.assign({}, CURVE));\n    return { CURVE, Fp, Fn };\n}\nexport function createKeygen(randomSecretKey, getPublicKey) {\n    return function keygen(seed) {\n        const secretKey = randomSecretKey(seed);\n        return { secretKey, publicKey: getPublicKey(secretKey) };\n    };\n}\n//# sourceMappingURL=curve.js.map","import { abytes, asafenumber, asciiToBytes, bytesToNumberBE, concatBytes, isBytes, validateObject, } from \"../utils.js\";\nimport { FpInvertBatch, mod } from \"./modular.js\";\n// Octet Stream to Integer. \"spec\" implementation of os2ip is 2.5x slower vs bytesToNumberBE.\nconst os2ip = bytesToNumberBE;\n// Integer to Octet Stream (numberToBytesBE)\nfunction i2osp(value, length) {\n    asafenumber(value);\n    asafenumber(length);\n    if (value < 0 || value >= 1 << (8 * length))\n        throw new Error('invalid I2OSP input: ' + value);\n    const res = Array.from({ length }).fill(0);\n    for (let i = length - 1; i >= 0; i--) {\n        res[i] = value & 0xff;\n        value >>>= 8;\n    }\n    return new Uint8Array(res);\n}\nfunction strxor(a, b) {\n    const arr = new Uint8Array(a.length);\n    for (let i = 0; i < a.length; i++) {\n        arr[i] = a[i] ^ b[i];\n    }\n    return arr;\n}\n// User can always use utf8 if they want, by passing Uint8Array.\n// If string is passed, we treat it as ASCII: other formats are likely a mistake.\nfunction normDST(DST) {\n    if (!isBytes(DST) && typeof DST !== 'string')\n        throw new Error('DST must be Uint8Array or ascii string');\n    return typeof DST === 'string' ? asciiToBytes(DST) : DST;\n}\n/**\n * Produces a uniformly random byte string using a cryptographic hash function H that outputs b bits.\n * [RFC 9380 5.3.1](https://www.rfc-editor.org/rfc/rfc9380#section-5.3.1).\n */\nexport function expand_message_xmd(msg, DST, lenInBytes, H) {\n    abytes(msg);\n    asafenumber(lenInBytes);\n    DST = normDST(DST);\n    // https://www.rfc-editor.org/rfc/rfc9380#section-5.3.3\n    if (DST.length > 255)\n        DST = H(concatBytes(asciiToBytes('H2C-OVERSIZE-DST-'), DST));\n    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;\n    const ell = Math.ceil(lenInBytes / b_in_bytes);\n    if (lenInBytes > 65535 || ell > 255)\n        throw new Error('expand_message_xmd: invalid lenInBytes');\n    const DST_prime = concatBytes(DST, i2osp(DST.length, 1));\n    const Z_pad = i2osp(0, r_in_bytes);\n    const l_i_b_str = i2osp(lenInBytes, 2); // len_in_bytes_str\n    const b = new Array(ell);\n    const b_0 = H(concatBytes(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));\n    b[0] = H(concatBytes(b_0, i2osp(1, 1), DST_prime));\n    for (let i = 1; i <= ell; i++) {\n        const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];\n        b[i] = H(concatBytes(...args));\n    }\n    const pseudo_random_bytes = concatBytes(...b);\n    return pseudo_random_bytes.slice(0, lenInBytes);\n}\n/**\n * Produces a uniformly random byte string using an extendable-output function (XOF) H.\n * 1. The collision resistance of H MUST be at least k bits.\n * 2. H MUST be an XOF that has been proved indifferentiable from\n *    a random oracle under a reasonable cryptographic assumption.\n * [RFC 9380 5.3.2](https://www.rfc-editor.org/rfc/rfc9380#section-5.3.2).\n */\nexport function expand_message_xof(msg, DST, lenInBytes, k, H) {\n    abytes(msg);\n    asafenumber(lenInBytes);\n    DST = normDST(DST);\n    // https://www.rfc-editor.org/rfc/rfc9380#section-5.3.3\n    // DST = H('H2C-OVERSIZE-DST-' || a_very_long_DST, Math.ceil((lenInBytes * k) / 8));\n    if (DST.length > 255) {\n        const dkLen = Math.ceil((2 * k) / 8);\n        DST = H.create({ dkLen }).update(asciiToBytes('H2C-OVERSIZE-DST-')).update(DST).digest();\n    }\n    if (lenInBytes > 65535 || DST.length > 255)\n        throw new Error('expand_message_xof: invalid lenInBytes');\n    return (H.create({ dkLen: lenInBytes })\n        .update(msg)\n        .update(i2osp(lenInBytes, 2))\n        // 2. DST_prime = DST || I2OSP(len(DST), 1)\n        .update(DST)\n        .update(i2osp(DST.length, 1))\n        .digest());\n}\n/**\n * Hashes arbitrary-length byte strings to a list of one or more elements of a finite field F.\n * [RFC 9380 5.2](https://www.rfc-editor.org/rfc/rfc9380#section-5.2).\n * @param msg a byte string containing the message to hash\n * @param count the number of elements of F to output\n * @param options `{DST: string, p: bigint, m: number, k: number, expand: 'xmd' | 'xof', hash: H}`, see above\n * @returns [u_0, ..., u_(count - 1)], a list of field elements.\n */\nexport function hash_to_field(msg, count, options) {\n    validateObject(options, {\n        p: 'bigint',\n        m: 'number',\n        k: 'number',\n        hash: 'function',\n    });\n    const { p, k, m, hash, expand, DST } = options;\n    asafenumber(hash.outputLen, 'valid hash');\n    abytes(msg);\n    asafenumber(count);\n    const log2p = p.toString(2).length;\n    const L = Math.ceil((log2p + k) / 8); // section 5.1 of ietf draft link above\n    const len_in_bytes = count * m * L;\n    let prb; // pseudo_random_bytes\n    if (expand === 'xmd') {\n        prb = expand_message_xmd(msg, DST, len_in_bytes, hash);\n    }\n    else if (expand === 'xof') {\n        prb = expand_message_xof(msg, DST, len_in_bytes, k, hash);\n    }\n    else if (expand === '_internal_pass') {\n        // for internal tests only\n        prb = msg;\n    }\n    else {\n        throw new Error('expand must be \"xmd\" or \"xof\"');\n    }\n    const u = new Array(count);\n    for (let i = 0; i < count; i++) {\n        const e = new Array(m);\n        for (let j = 0; j < m; j++) {\n            const elm_offset = L * (j + i * m);\n            const tv = prb.subarray(elm_offset, elm_offset + L);\n            e[j] = mod(os2ip(tv), p);\n        }\n        u[i] = e;\n    }\n    return u;\n}\nexport function isogenyMap(field, map) {\n    // Make same order as in spec\n    const coeff = map.map((i) => Array.from(i).reverse());\n    return (x, y) => {\n        const [xn, xd, yn, yd] = coeff.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));\n        // 6.6.3\n        // Exceptional cases of iso_map are inputs that cause the denominator of\n        // either rational function to evaluate to zero; such cases MUST return\n        // the identity point on E.\n        const [xd_inv, yd_inv] = FpInvertBatch(field, [xd, yd], true);\n        x = field.mul(xn, xd_inv); // xNum / xDen\n        y = field.mul(y, field.mul(yn, yd_inv)); // y * (yNum / yDev)\n        return { x, y };\n    };\n}\nexport const _DST_scalar = asciiToBytes('HashToScalar-');\n/** Creates hash-to-curve methods from EC Point and mapToCurve function. See {@link H2CHasher}. */\nexport function createHasher(Point, mapToCurve, defaults) {\n    if (typeof mapToCurve !== 'function')\n        throw new Error('mapToCurve() must be defined');\n    function map(num) {\n        return Point.fromAffine(mapToCurve(num));\n    }\n    function clear(initial) {\n        const P = initial.clearCofactor();\n        if (P.equals(Point.ZERO))\n            return Point.ZERO; // zero will throw in assert\n        P.assertValidity();\n        return P;\n    }\n    return {\n        defaults: Object.freeze(defaults),\n        Point,\n        hashToCurve(msg, options) {\n            const opts = Object.assign({}, defaults, options);\n            const u = hash_to_field(msg, 2, opts);\n            const u0 = map(u[0]);\n            const u1 = map(u[1]);\n            return clear(u0.add(u1));\n        },\n        encodeToCurve(msg, options) {\n            const optsDst = defaults.encodeDST ? { DST: defaults.encodeDST } : {};\n            const opts = Object.assign({}, defaults, optsDst, options);\n            const u = hash_to_field(msg, 1, opts);\n            const u0 = map(u[0]);\n            return clear(u0);\n        },\n        /** See {@link H2CHasher} */\n        mapToCurve(scalars) {\n            // Curves with m=1 accept only single scalar\n            if (defaults.m === 1) {\n                if (typeof scalars !== 'bigint')\n                    throw new Error('expected bigint (m=1)');\n                return clear(map([scalars]));\n            }\n            if (!Array.isArray(scalars))\n                throw new Error('expected array of bigints');\n            for (const i of scalars)\n                if (typeof i !== 'bigint')\n                    throw new Error('expected array of bigints');\n            return clear(map(scalars));\n        },\n        // hash_to_scalar can produce 0: https://www.rfc-editor.org/errata/eid8393\n        // RFC 9380, draft-irtf-cfrg-bbs-signatures-08\n        hashToScalar(msg, options) {\n            // @ts-ignore\n            const N = Point.Fn.ORDER;\n            const opts = Object.assign({}, defaults, { p: N, m: 1, DST: _DST_scalar }, options);\n            return hash_to_field(msg, 1, opts)[0][0];\n        },\n    };\n}\n//# sourceMappingURL=hash-to-curve.js.map","/**\n * HMAC: RFC2104 message authentication code.\n * @module\n */\nimport { abytes, aexists, ahash, clean } from \"./utils.js\";\n/** Internal class for HMAC. */\nexport class _HMAC {\n    oHash;\n    iHash;\n    blockLen;\n    outputLen;\n    finished = false;\n    destroyed = false;\n    constructor(hash, key) {\n        ahash(hash);\n        abytes(key, undefined, '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, 'output');\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 ||= 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 * 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.js';\nimport { abool, abytes, aInRange, bitLen, bitMask, bytesToHex, bytesToNumberBE, concatBytes, createHmacDrbg, hexToBytes, isBytes, memoized, numberToHexUnpadded, validateObject, randomBytes as wcRandomBytes, } from \"../utils.js\";\nimport { createCurveFields, createKeygen, mulEndoUnsafe, negateCt, normalizeZ, wNAF, } from \"./curve.js\";\nimport { FpInvertBatch, getMinHashLength, mapHashToField, 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) & 0b1000_0000)\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) | 0b1000_0000) : '';\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 & 0b1000_0000); // 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 & 0b0111_1111;\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] & 0b1000_0000)\n                throw new E('invalid signature integer: negative');\n            if (data[0] === 0x00 && !(data[1] & 0b1000_0000))\n                throw new E('invalid signature integer: unnecessary leading zero');\n            return bytesToNumberBE(data);\n        },\n    },\n    toSig(bytes) {\n        // parse DER signature\n        const { Err: E, _int: int, _tlv: tlv } = DER;\n        const data = abytes(bytes, undefined, 'signature');\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);\n/**\n * Creates weierstrass Point constructor, based on specified curve options.\n *\n * See {@link WeierstrassOpts}.\n *\n * @example\n```js\nconst opts = {\n  p: 0xfffffffffffffffffffffffffffffffeffffac73n,\n  n: 0x100000000000000000001b8fa16dfab9aca16b6b3n,\n  h: 1n,\n  a: 0n,\n  b: 7n,\n  Gx: 0x3b4c382ce37aa192a4019e763036f4f5dd4d7ebbn,\n  Gy: 0x938cf935318fdced6bc28286531733c3f03c4feen,\n};\nconst secp160k1_Point = weierstrass(opts);\n```\n */\nexport function weierstrass(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    });\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 evenY = Fp.isOdd(y);\n            const evenH = (head & 1) === 1; // ECDSA-specific\n            if (evenH !== evenY)\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('Weierstrass Point 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        // base / generator point\n        static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n        // zero / infinity / identity point\n        static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO); // 0, 1, 0\n        // math field\n        static Fp = Fp;\n        // scalar field\n        static Fn = Fn;\n        X;\n        Y;\n        Z;\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(hexToBytes(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; // 0\n            if (sc === _1n)\n                return p; // 1\n            if (wnaf.hasCache(this))\n                return this.multiply(sc); // precomputes\n            // We don't have method for double scalar multiplication (aP + bQ):\n            // Even with using Strauss-Shamir trick, it's 35% slower than naïve mul+add.\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        /**\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    }\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 || wcRandomBytes;\n    const lengths = Object.assign(getWLengths(Point.Fp, Fn), { seed: getMinHashLength(Fn.ORDER) });\n    function isValidSecretKey(secretKey) {\n        try {\n            const num = Fn.fromBytes(secretKey);\n            return Fn.isValidNot0(num);\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(Fn.fromBytes(secretKey)).toBytes(isCompressed);\n    }\n    /**\n     * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n     */\n    function isProbPub(item) {\n        const { secretKey, publicKey, publicKeyUncompressed } = lengths;\n        if (!isBytes(item))\n            return undefined;\n        if (('_lengths' in Fn && Fn._lengths) || secretKey === publicKey)\n            return undefined;\n        const l = abytes(item, undefined, 'key').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 = Fn.fromBytes(secretKeyA);\n        const b = Point.fromBytes(publicKeyB); // checks for being on-curve\n        return b.multiply(s).toBytes(isCompressed);\n    }\n    const utils = {\n        isValidSecretKey,\n        isValidPublicKey,\n        randomSecretKey,\n    };\n    const keygen = createKeygen(randomSecretKey, getPublicKey);\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 *\n * @param Point created using {@link weierstrass} function\n * @param hash used for 1) message prehash-ing 2) k generation in `sign`, using hmac_drbg(hash)\n * @param ecdsaOpts rarely needed, see {@link ECDSAOpts}\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    ecdsaOpts = Object.assign({}, ecdsaOpts);\n    const randomBytes = ecdsaOpts.randomBytes || wcRandomBytes;\n    const hmac = ecdsaOpts.hmac || ((key, msg) => nobleHmac(hash, key, msg));\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: true,\n        lowS: typeof ecdsaOpts.lowS === 'boolean' ? ecdsaOpts.lowS : true,\n        format: 'compact',\n        extraEntropy: false,\n    };\n    const hasLargeCofactor = CURVE_ORDER * _2n < Fp.ORDER; // Won't CURVE().h > 2n be more effective?\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 assertSmallCofactor() {\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        if (hasLargeCofactor)\n            throw new Error('\"recovered\" sig type is not supported for cofactor >2 curves');\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);\n    }\n    /**\n     * ECDSA signature with its (r, s) properties. Supports compact, recovered & DER representations.\n     */\n    class Signature {\n        r;\n        s;\n        recovery;\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                assertSmallCofactor();\n                if (![0, 1, 2, 3].includes(recovery))\n                    throw new Error('invalid recovery id');\n                this.recovery = recovery;\n            }\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 = lengths.signature / 2;\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        assertRecovery() {\n            const { recovery } = this;\n            if (recovery == null)\n                throw new Error('invalid recovery id: must be present');\n            return recovery;\n        }\n        addRecoveryBit(recovery) {\n            return new Signature(this.r, this.s, recovery);\n        }\n        recoverPublicKey(messageHash) {\n            const { r, s } = this;\n            const recovery = this.assertRecovery();\n            const radj = recovery === 2 || recovery === 3 ? r + CURVE_ORDER : r;\n            if (!Fp.isValid(radj))\n                throw new Error('invalid recovery id: sig.r+curve.n != R.x');\n            const x = Fp.toBytes(radj);\n            const R = Point.fromBytes(concatBytes(pprefix((recovery & 1) === 0), x));\n            const ir = Fn.inv(radj); // r^-1\n            const h = bits2int_modN(abytes(messageHash, undefined, 'msgHash')); // 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('invalid recovery: 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, s } = this;\n            const rb = Fn.toBytes(r);\n            const sb = Fn.toBytes(s);\n            if (format === 'recovered') {\n                assertSmallCofactor();\n                return concatBytes(Uint8Array.of(this.assertRecovery()), rb, sb);\n            }\n            return concatBytes(rb, sb);\n        }\n        toHex(format) {\n            return bytesToHex(this.toBytes(format));\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, secretKey, opts) {\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 = Fn.fromBytes(secretKey); // validate secret key, convert to bigint\n        if (!Fn.isValidNot0(d))\n            throw new Error('invalid private key');\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(abytes(e, undefined, 'extraEntropy')); // check for being bytes\n        }\n        const seed = concatBytes(...seedArgs); // Step D of RFC6979 3.2\n        const m = h1int; // 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); // Cannot use fields methods, since it is group element\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)); // s = k^-1(m + rd) mod n\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 in the bottom half of N\n                recovery ^= 1;\n            }\n            return new Signature(r, normS, hasLargeCofactor ? undefined : recovery);\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        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.toBytes(opts.format);\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 = abytes(publicKey, undefined, 'publicKey');\n        message = validateMsgAndHash(message, prehash);\n        if (!isBytes(signature)) {\n            const end = signature instanceof Signature ? ', use sig.toBytes()' : '';\n            throw new Error('verify expects Uint8Array signature' + end);\n        }\n        validateSigLength(signature, format); // execute this twice because we want loud error\n        try {\n            const sig = Signature.fromBytes(signature, format);\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//# sourceMappingURL=weierstrass.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 { createKeygen } from \"./abstract/curve.js\";\nimport { createHasher, isogenyMap } from \"./abstract/hash-to-curve.js\";\nimport { Field, mapHashToField, pow2 } from \"./abstract/modular.js\";\nimport { ecdsa, mapToCurveSimpleSWU, weierstrass, } from \"./abstract/weierstrass.js\";\nimport { abytes, asciiToBytes, bytesToNumberBE, concatBytes } from \"./utils.js\";\n// Seems like generator was produced from some seed:\n// `Pointk1.BASE.multiply(Pointk1.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 _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 });\nconst Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {\n    Fp: Fpk1,\n    endo: secp256k1_ENDO,\n});\n/**\n * secp256k1 curve: ECDSA and ECDH methods.\n *\n * Uses sha256 to hash messages. To use a different hash,\n * pass `{ prehash: false }` to sign / verify.\n *\n * @example\n * ```js\n * import { secp256k1 } from '@noble/curves/secp256k1.js';\n * const { secretKey, publicKey } = secp256k1.keygen();\n * // const publicKey = secp256k1.getPublicKey(secretKey);\n * const msg = new TextEncoder().encode('hello noble');\n * const sig = secp256k1.sign(msg, secretKey);\n * const isValid = secp256k1.verify(sig, msg, publicKey);\n * // const sigKeccak = secp256k1.sign(keccak256(msg), secretKey, { prehash: false });\n * ```\n */\nexport const secp256k1 = /* @__PURE__ */ ecdsa(Pointk1, 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(asciiToBytes(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 hasEven = (y) => y % _2n === _0n;\n// Calculate point, scalar and bytes\nfunction schnorrGetExtPubKey(priv) {\n    const { Fn, BASE } = Pointk1;\n    const d_ = Fn.fromBytes(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 = abytes(message, undefined, 'message');\n    const { bytes: px, scalar: d } = schnorrGetExtPubKey(secretKey); // checks for isWithinCurveOrder\n    const a = abytes(auxRand, 32, 'auxRand'); // 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 { Fp, Fn, BASE } = Pointk1;\n    const sig = abytes(signature, 64, 'signature');\n    const m = abytes(message, undefined, 'message');\n    const pub = abytes(publicKey, 32, 'publicKey');\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 (!Fp.isValidNot0(r))\n            return false;\n        const s = num(sig.subarray(32, 64)); // Let s = int(sig[32:64]); fail if s ≥ n.\n        if (!Fn.isValidNot0(s))\n            return false;\n        const e = challenge(Fn.toBytes(r), pointToBytes(P), m); // int(challenge(bytes(r)||bytes(P)||m))%n\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.js';\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    return {\n        keygen: createKeygen(randomSecretKey, schnorrGetPublicKey),\n        getPublicKey: schnorrGetPublicKey,\n        sign: schnorrSign,\n        verify: schnorrVerify,\n        Point: Pointk1,\n        utils: {\n            randomSecretKey,\n            taggedHash,\n            lift_x,\n            pointToBytes,\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(Pointk1, (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//# sourceMappingURL=secp256k1.js.map","import { PublicKey } from './PublicKey';\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\nexport class Signature {\n    /**\n     * Creates a new Signature instance.\n     * @param data Raw signature data (64 bytes)\n     * @param recovery Recovery byte (0-3)\n     * @param compressed Whether signature is compressed (default: true)\n     */\n    constructor(data, recovery, compressed) {\n        this.data = data;\n        this.recovery = recovery;\n        this.compressed = compressed ?? true;\n    }\n    /**\n     * Creates a Signature from a hex string.\n     * @param string 130-character hex string containing signature and recovery data\n     * @returns New Signature instance\n     * @throws Error if input is not a string\n     */\n    static from(string) {\n        if (typeof string === 'string') {\n            const temp = hexToBytes(string);\n            let recovery = parseInt(bytesToHex(temp.subarray(0, 1)), 16) - 31;\n            let compressed = true;\n            // non-compressed signatures have -4\n            // https://github.com/bitcoin/bitcoin/blob/95ea54ba089610019a74c1176a2c7c0dba144b1c/src/key.cpp#L257\n            if (recovery < 0) {\n                compressed = false;\n                recovery = recovery + 4;\n            }\n            const data = temp.subarray(1);\n            return new Signature(data, recovery, compressed);\n        }\n        else {\n            throw new Error('Expected string for data');\n        }\n    }\n    /**\n     * Converts signature to 65-byte buffer format.\n     * @returns 65-byte buffer containing recovery byte + signature data\n     */\n    toBuffer() {\n        const buffer = new Uint8Array(65).fill(0);\n        if (this.compressed) {\n            buffer[0] = (this.recovery + 31) & 0xff;\n        }\n        else {\n            buffer[0] = (this.recovery + 27) & 0xff;\n        }\n        buffer.set(this.data, 1);\n        return buffer;\n    }\n    /**\n     * Returns signature as 130-character hex string.\n     * @returns Hex string representation of signature\n     */\n    customToString() {\n        return bytesToHex(this.toBuffer());\n    }\n    /**\n     * Recovers the public key from this signature and message.\n     * @param message 32-byte message hash (Uint8Array) or 64-character hex string\n     * @returns PublicKey that created this signature\n     * @throws Error if message is not a valid 32-byte SHA256 hash\n     */\n    getPublicKey(message) {\n        if ((message instanceof Uint8Array && message.length !== 32) ||\n            (typeof message === 'string' && message.length !== 64)) {\n            throw new Error('Expected a valid sha256 hash as message');\n        }\n        if (typeof message === 'string') {\n            message = hexToBytes(message);\n        }\n        const sig = secp256k1.Signature.fromBytes(this.data, 'compact');\n        const temp = new secp256k1.Signature(sig.r, sig.s, this.recovery);\n        return new PublicKey(temp.recoverPublicKey(message).toBytes());\n    }\n}\n","import { ripemd160 } from '@noble/hashes/legacy.js';\nimport bs58 from 'bs58';\nimport { config } from '../config';\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport { Signature } from './Signature';\nconst DEFAULT_ADDRESS_PREFIX = config.address_prefix;\nexport class PublicKey {\n    /**\n     * Creates a new PublicKey instance from raw bytes.\n     * @param key Raw public key bytes (33 bytes, compressed format)\n     * @param prefix Optional address prefix (defaults to config.address_prefix)\n     */\n    constructor(key, prefix) {\n        this.key = key;\n        this.prefix = prefix ?? DEFAULT_ADDRESS_PREFIX;\n        // assert(secp256k1.publicKeyVerify(key), 'invalid public key')\n    }\n    /**\n     * Creates a PublicKey from a string representation.\n     * @param wif Public key string (e.g., \"STM8m5UgaFAAYQRuaNejYdS8FVLVp9Ss3K1qAVk5de6F8s3HnVbvA\")\n     * @returns New PublicKey instance\n     * @throws Error if the key format is invalid\n     */\n    static fromString(wif) {\n        const { key, prefix } = decodePublic(wif);\n        return new PublicKey(key, prefix);\n    }\n    /**\n     * Creates a PublicKey from a string or returns the instance if already a PublicKey.\n     * @param value Public key string or PublicKey instance\n     * @returns New or existing PublicKey instance\n     */\n    static from(value) {\n        if (value instanceof PublicKey) {\n            return value;\n        }\n        else {\n            return PublicKey.fromString(value);\n        }\n    }\n    /**\n     * Verifies a signature against a message hash.\n     * @param message 32-byte message hash to verify\n     * @param signature Signature to verify\n     * @returns True if signature is valid, false otherwise\n     */\n    verify(message, signature) {\n        if (typeof signature === 'string') {\n            signature = Signature.from(signature);\n        }\n        return secp256k1.verify(signature.data, message, this.key, {\n            prehash: false,\n            format: 'compact'\n        });\n    }\n    /**\n     * Returns the public key as a string for storage or transmission.\n     * @returns Public key string with prefix (e.g., \"STM8m5UgaFAAYQRuaNejYdS8FVLVp9Ss3K1qAVk5de6F8s3HnVbvA\")\n     */\n    toString() {\n        return encodePublic(this.key, this.prefix);\n    }\n    /**\n     * Returns JSON representation (same as toString()).\n     * @returns Public key string\n     */\n    toJSON() {\n        return this.toString();\n    }\n    /**\n     * Returns a string representation for debugging.\n     * @returns Formatted public key string\n     */\n    inspect() {\n        return `PublicKey: ${this.toString()}`;\n    }\n}\nconst encodePublic = (key, prefix) => {\n    const checksum = ripemd160(key);\n    return prefix + bs58.encode(new Uint8Array([...key, ...checksum.subarray(0, 4)]));\n};\n/** Decode bs58+ripemd160-checksum encoded public key. */\nconst decodePublic = (encodedKey) => {\n    const prefix = encodedKey.slice(0, 3);\n    encodedKey = encodedKey.slice(3);\n    const buffer = bs58.decode(encodedKey);\n    const key = buffer.subarray(0, buffer.length - 4);\n    return { key: key, prefix };\n};\n","/** Class representing a hive asset,\n * e.g. `1.000 HIVE` or `12.112233 VESTS`. */\nexport class Asset {\n    constructor(amount, symbol) {\n        this.amount = amount;\n        this.symbol = symbol === 'HIVE' ? 'STEEM' : symbol === 'HBD' ? 'SBD' : symbol;\n    }\n    /** Create a new Asset instance from a string, e.g. `42.000 HIVE`. */\n    static fromString(string, expectedSymbol = null) {\n        const [amountString, symbol] = string.split(' ');\n        if (['STEEM', 'VESTS', 'SBD', 'TESTS', 'TBD', 'HIVE', 'HBD'].indexOf(symbol) === -1) {\n            throw new Error(`Invalid asset symbol: ${symbol}`);\n        }\n        if (expectedSymbol && symbol !== expectedSymbol) {\n            throw new Error(`Invalid asset, expected symbol: ${expectedSymbol} got: ${symbol}`);\n        }\n        const amount = Number.parseFloat(amountString);\n        if (!Number.isFinite(amount)) {\n            throw new Error(`Invalid asset amount: ${amountString}`);\n        }\n        return new Asset(amount, symbol);\n    }\n    /**\n     * Convenience to create new Asset.\n     * @param symbol Symbol to use when created from number. Will also be used to validate\n     *               the asset, throws if the passed value has a different symbol than this.\n     */\n    static from(value, symbol) {\n        if (value instanceof Asset) {\n            if (symbol && value.symbol !== symbol) {\n                throw new Error(`Invalid asset, expected symbol: ${symbol} got: ${value.symbol}`);\n            }\n            return value;\n        }\n        else if (typeof value === 'number' && Number.isFinite(value)) {\n            return new Asset(value, symbol || 'STEEM');\n        }\n        else if (typeof value === 'string') {\n            return Asset.fromString(value, symbol);\n        }\n        else {\n            throw new Error(`Invalid asset '${String(value)}'`);\n        }\n    }\n    // We convert HIVE & HBD strings to STEEM & SBD because the serialization should be based on STEEM & SBD\n    /** Return asset precision. */\n    getPrecision() {\n        switch (this.symbol) {\n            case 'TESTS':\n            case 'TBD':\n            case 'STEEM':\n            case 'SBD':\n            case 'HBD':\n            case 'HIVE':\n                return 3;\n            case 'VESTS':\n                return 6;\n            default:\n                return 3;\n        }\n    }\n    /** Return a string representation of this asset, e.g. `42.000 HIVE`. */\n    toString() {\n        return `${this.amount.toFixed(this.getPrecision())} ${this.symbol}`;\n    }\n    toJSON() {\n        return this.toString();\n    }\n}\n","import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n/** Buffer wrapper that serializes to a hex-encoded string. */\nexport class HexBuffer {\n    /** Convenience to create a new HexBuffer, does not copy data if value passed is already a buffer. */\n    static from(value) {\n        if (value instanceof HexBuffer) {\n            return value;\n        }\n        else if (value instanceof Uint8Array) {\n            return new HexBuffer(value);\n        }\n        else if (typeof value === 'string') {\n            return new HexBuffer(hexToBytes(value));\n        }\n        else {\n            return new HexBuffer(new Uint8Array(value));\n        }\n    }\n    constructor(buffer) {\n        this.buffer = buffer;\n    }\n    toString() {\n        return bytesToHex(this.buffer);\n    }\n    toJSON() {\n        return this.toString();\n    }\n}\n","import { PublicKey } from './PublicKey';\nimport { Asset } from './Asset';\nimport { HexBuffer } from './HexBuffer';\n// Operation ID constants for better maintainability\nconst OPERATION_IDS = {\n    vote: 0,\n    comment: 1,\n    transfer: 2,\n    transfer_to_vesting: 3,\n    withdraw_vesting: 4,\n    limit_order_create: 5,\n    limit_order_cancel: 6,\n    feed_publish: 7,\n    convert: 8,\n    account_create: 9,\n    account_update: 10,\n    witness_update: 11,\n    account_witness_vote: 12,\n    account_witness_proxy: 13,\n    // pow: 14,\n    custom: 15,\n    // report_over_production: 16,\n    delete_comment: 17,\n    custom_json: 18,\n    comment_options: 19,\n    set_withdraw_vesting_route: 20,\n    limit_order_create2: 21,\n    claim_account: 22,\n    create_claimed_account: 23,\n    request_account_recovery: 24,\n    recover_account: 25,\n    change_recovery_account: 26,\n    escrow_transfer: 27,\n    escrow_dispute: 28,\n    escrow_release: 29,\n    // pow2: 30,\n    escrow_approve: 31,\n    transfer_to_savings: 32,\n    transfer_from_savings: 33,\n    cancel_transfer_from_savings: 34,\n    // custom_binary: 35,\n    decline_voting_rights: 36,\n    reset_account: 37,\n    set_reset_account: 38,\n    claim_reward_balance: 39,\n    delegate_vesting_shares: 40,\n    account_create_with_delegation: 41,\n    witness_set_properties: 42,\n    account_update2: 43,\n    create_proposal: 44,\n    update_proposal_votes: 45,\n    remove_proposal: 46,\n    update_proposal: 47,\n    collateralized_convert: 48,\n    recurrent_transfer: 49\n};\nconst VoidSerializer = () => {\n    throw new Error('Void can not be serialized');\n};\nconst StringSerializer = (buffer, data) => {\n    buffer.writeVString(data);\n};\nconst Int8Serializer = (buffer, data) => {\n    buffer.writeInt8(data);\n};\nconst Int16Serializer = (buffer, data) => {\n    buffer.writeInt16(data);\n};\nconst Int32Serializer = (buffer, data) => {\n    buffer.writeInt32(data);\n};\nconst Int64Serializer = (buffer, data) => {\n    buffer.writeInt64(data);\n};\nconst UInt8Serializer = (buffer, data) => {\n    buffer.writeUint8(data);\n};\nconst UInt16Serializer = (buffer, data) => {\n    buffer.writeUint16(data);\n};\nconst UInt32Serializer = (buffer, data) => {\n    buffer.writeUint32(data);\n};\nconst UInt64Serializer = (buffer, data) => {\n    buffer.writeUint64(data);\n};\nconst BooleanSerializer = (buffer, data) => {\n    buffer.writeByte(data ? 1 : 0);\n};\nconst StaticVariantSerializer = (itemSerializers) => {\n    // return (buffer: ByteBuffer, data: any[]) => {\n    //   let id = data[0]\n    //   const item = data[1]\n    //   // id was/is supposed to be 0 or integer here but seems to have been changed in e.g. comment_options\n    //   // extensions: [\n    //   //   [\n    //   //     \"comment_payout_beneficiaries\",\n    //   //     {\n    //   //       \"beneficiaries\": [\n    //   //         {\n    //   //           \"account\": \"vimm\",\n    //   //           \"weight\": 1000\n    //   //         }\n    //   //       ]\n    //   //     }\n    //   //   ]\n    //   // ]\n    //   // Keep it here just in case\n    //   // https://gitlab.syncad.com/hive/hive/-/issues/722\n    //   // \"comment_payout_beneficiaries\" was 0 and at some point it got changed\n    //   // It should still be serialized as a 0 or an integer\n    //   // Now the question is, always 0? will need an example transaction to prove otherwise\n    //   if (typeof id === 'string') {\n    //     if (id === 'update_proposal_end_date') {\n    //       id = 1\n    //     } else {\n    //       id = 0\n    //     }\n    //   }\n    //   buffer.writeVarint32(id)\n    //   itemSerializers[id](buffer, item)\n    return (buffer, data) => {\n        const [id, item] = data;\n        buffer.writeVarint32(id);\n        itemSerializers[id](buffer, item);\n    };\n};\n/**\n * Serialize asset.\n * @note This looses precision for amounts larger than 2^53-1/10^precision.\n *       Should not be a problem in real-word usage.\n */\nconst AssetSerializer = (buffer, data) => {\n    const asset = Asset.from(data);\n    const precision = asset.getPrecision();\n    buffer.writeInt64(Math.round(asset.amount * Math.pow(10, precision)));\n    buffer.writeUint8(precision);\n    for (let i = 0; i < 7; i++) {\n        buffer.writeUint8(asset.symbol.charCodeAt(i) || 0);\n    }\n};\nconst DateSerializer = (buffer, data) => {\n    buffer.writeUint32(Math.floor(new Date(data + 'Z').getTime() / 1000));\n};\nconst PublicKeySerializer = (buffer, data) => {\n    if (data === null ||\n        (typeof data === 'string' && data.slice(-39) === '1111111111111111111111111111111114T1Anm')) {\n        buffer.append(new Uint8Array(33).fill(0));\n    }\n    else {\n        buffer.append(PublicKey.from(data).key);\n    }\n};\nconst BinarySerializer = (size = null) => {\n    return (buffer, data) => {\n        data = HexBuffer.from(data);\n        const len = data.buffer.length;\n        if (size) {\n            if (len !== size) {\n                throw new Error(`Unable to serialize binary. Expected ${size} bytes, got ${len}`);\n            }\n        }\n        else {\n            buffer.writeVarint32(len);\n        }\n        buffer.append(data.buffer);\n    };\n};\nconst VariableBinarySerializer = BinarySerializer();\nconst FlatMapSerializer = (keySerializer, valueSerializer) => {\n    return (buffer, data) => {\n        buffer.writeVarint32(data.length);\n        for (const [key, value] of data) {\n            keySerializer(buffer, key);\n            valueSerializer(buffer, value);\n        }\n    };\n};\nconst ArraySerializer = (itemSerializer) => {\n    return (buffer, data) => {\n        buffer.writeVarint32(data.length);\n        for (const item of data) {\n            itemSerializer(buffer, item);\n        }\n    };\n};\nconst ObjectSerializer = (keySerializers) => {\n    return (buffer, data) => {\n        for (const [key, serializer] of keySerializers) {\n            try {\n                serializer(buffer, data[key]);\n            }\n            catch (error) {\n                error.message = `${key}: ${error.message}`;\n                throw error;\n            }\n        }\n    };\n};\nconst OptionalSerializer = (valueSerializer) => {\n    return (buffer, data) => {\n        if (data !== undefined) {\n            buffer.writeByte(1);\n            valueSerializer(buffer, data);\n        }\n        else {\n            buffer.writeByte(0);\n        }\n    };\n};\nconst AuthoritySerializer = ObjectSerializer([\n    ['weight_threshold', UInt32Serializer],\n    ['account_auths', FlatMapSerializer(StringSerializer, UInt16Serializer)],\n    ['key_auths', FlatMapSerializer(PublicKeySerializer, UInt16Serializer)]\n]);\nconst BeneficiarySerializer = ObjectSerializer([\n    ['account', StringSerializer],\n    ['weight', UInt16Serializer]\n]);\nconst PriceSerializer = ObjectSerializer([\n    ['base', AssetSerializer],\n    ['quote', AssetSerializer]\n]);\n// const SignedBlockHeaderSerializer = ObjectSerializer([\n//   ['previous', BinarySerializer(20)],\n//   ['timestamp', DateSerializer],\n//   ['witness', StringSerializer],\n//   ['transaction_merkle_root', BinarySerializer(20)],\n//   ['extensions', ArraySerializer(VoidSerializer)],\n//   ['witness_signature', BinarySerializer(65)]\n// ])\nconst ChainPropertiesSerializer = ObjectSerializer([\n    ['account_creation_fee', AssetSerializer],\n    ['maximum_block_size', UInt32Serializer],\n    ['hbd_interest_rate', UInt16Serializer]\n]);\nconst OperationDataSerializer = (operationId, definitions) => {\n    const objectSerializer = ObjectSerializer(definitions);\n    return (buffer, data) => {\n        buffer.writeVarint32(operationId);\n        objectSerializer(buffer, data);\n    };\n};\nconst OperationSerializers = {};\nOperationSerializers.account_create = OperationDataSerializer(OPERATION_IDS.account_create, [\n    ['fee', AssetSerializer],\n    ['creator', StringSerializer],\n    ['new_account_name', StringSerializer],\n    ['owner', AuthoritySerializer],\n    ['active', AuthoritySerializer],\n    ['posting', AuthoritySerializer],\n    ['memo_key', PublicKeySerializer],\n    ['json_metadata', StringSerializer]\n]);\nOperationSerializers.account_create_with_delegation = OperationDataSerializer(OPERATION_IDS.account_create_with_delegation, [\n    ['fee', AssetSerializer],\n    ['delegation', AssetSerializer],\n    ['creator', StringSerializer],\n    ['new_account_name', StringSerializer],\n    ['owner', AuthoritySerializer],\n    ['active', AuthoritySerializer],\n    ['posting', AuthoritySerializer],\n    ['memo_key', PublicKeySerializer],\n    ['json_metadata', StringSerializer],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nOperationSerializers.account_update = OperationDataSerializer(OPERATION_IDS.account_update, [\n    ['account', StringSerializer],\n    ['owner', OptionalSerializer(AuthoritySerializer)],\n    ['active', OptionalSerializer(AuthoritySerializer)],\n    ['posting', OptionalSerializer(AuthoritySerializer)],\n    ['memo_key', PublicKeySerializer],\n    ['json_metadata', StringSerializer]\n]);\nOperationSerializers.account_witness_proxy = OperationDataSerializer(OPERATION_IDS.account_witness_proxy, [\n    ['account', StringSerializer],\n    ['proxy', StringSerializer]\n]);\nOperationSerializers.account_witness_vote = OperationDataSerializer(OPERATION_IDS.account_witness_vote, [\n    ['account', StringSerializer],\n    ['witness', StringSerializer],\n    ['approve', BooleanSerializer]\n]);\nOperationSerializers.cancel_transfer_from_savings = OperationDataSerializer(OPERATION_IDS.cancel_transfer_from_savings, [\n    ['from', StringSerializer],\n    ['request_id', UInt32Serializer]\n]);\nOperationSerializers.change_recovery_account = OperationDataSerializer(OPERATION_IDS.change_recovery_account, [\n    ['account_to_recover', StringSerializer],\n    ['new_recovery_account', StringSerializer],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nOperationSerializers.claim_account = OperationDataSerializer(OPERATION_IDS.claim_account, [\n    ['creator', StringSerializer],\n    ['fee', AssetSerializer],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nOperationSerializers.claim_reward_balance = OperationDataSerializer(OPERATION_IDS.claim_reward_balance, [\n    ['account', StringSerializer],\n    ['reward_hive', AssetSerializer],\n    ['reward_hbd', AssetSerializer],\n    ['reward_vests', AssetSerializer]\n]);\nOperationSerializers.comment = OperationDataSerializer(OPERATION_IDS.comment, [\n    ['parent_author', StringSerializer],\n    ['parent_permlink', StringSerializer],\n    ['author', StringSerializer],\n    ['permlink', StringSerializer],\n    ['title', StringSerializer],\n    ['body', StringSerializer],\n    ['json_metadata', StringSerializer]\n]);\nOperationSerializers.comment_options = OperationDataSerializer(OPERATION_IDS.comment_options, [\n    ['author', StringSerializer],\n    ['permlink', StringSerializer],\n    ['max_accepted_payout', AssetSerializer],\n    ['percent_hbd', UInt16Serializer],\n    ['allow_votes', BooleanSerializer],\n    ['allow_curation_rewards', BooleanSerializer],\n    [\n        'extensions',\n        ArraySerializer(StaticVariantSerializer([\n            ObjectSerializer([['beneficiaries', ArraySerializer(BeneficiarySerializer)]])\n        ]))\n    ]\n]);\nOperationSerializers.convert = OperationDataSerializer(OPERATION_IDS.convert, [\n    ['owner', StringSerializer],\n    ['requestid', UInt32Serializer],\n    ['amount', AssetSerializer]\n]);\nOperationSerializers.create_claimed_account = OperationDataSerializer(OPERATION_IDS.create_claimed_account, [\n    ['creator', StringSerializer],\n    ['new_account_name', StringSerializer],\n    ['owner', AuthoritySerializer],\n    ['active', AuthoritySerializer],\n    ['posting', AuthoritySerializer],\n    ['memo_key', PublicKeySerializer],\n    ['json_metadata', StringSerializer],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nOperationSerializers.custom = OperationDataSerializer(OPERATION_IDS.custom, [\n    ['required_auths', ArraySerializer(StringSerializer)],\n    ['id', UInt16Serializer],\n    ['data', VariableBinarySerializer]\n]);\n// Not used on chain\n// OperationSerializers.custom_binary = OperationDataSerializer(OPERATION_IDS.custom_binary, [\n//   ['required_owner_auths', ArraySerializer(StringSerializer)],\n//   ['required_active_auths', ArraySerializer(StringSerializer)],\n//   ['required_posting_auths', ArraySerializer(StringSerializer)],\n//   ['required_auths', ArraySerializer(AuthoritySerializer)],\n//   ['id', StringSerializer],\n//   ['data', VariableBinarySerializer]\n// ])\nOperationSerializers.custom_json = OperationDataSerializer(OPERATION_IDS.custom_json, [\n    ['required_auths', ArraySerializer(StringSerializer)],\n    ['required_posting_auths', ArraySerializer(StringSerializer)],\n    ['id', StringSerializer],\n    ['json', StringSerializer]\n]);\nOperationSerializers.decline_voting_rights = OperationDataSerializer(OPERATION_IDS.decline_voting_rights, [\n    ['account', StringSerializer],\n    ['decline', BooleanSerializer]\n]);\nOperationSerializers.delegate_vesting_shares = OperationDataSerializer(OPERATION_IDS.delegate_vesting_shares, [\n    ['delegator', StringSerializer],\n    ['delegatee', StringSerializer],\n    ['vesting_shares', AssetSerializer]\n]);\nOperationSerializers.delete_comment = OperationDataSerializer(OPERATION_IDS.delete_comment, [\n    ['author', StringSerializer],\n    ['permlink', StringSerializer]\n]);\nOperationSerializers.escrow_approve = OperationDataSerializer(OPERATION_IDS.escrow_approve, [\n    ['from', StringSerializer],\n    ['to', StringSerializer],\n    ['agent', StringSerializer],\n    ['who', StringSerializer],\n    ['escrow_id', UInt32Serializer],\n    ['approve', BooleanSerializer]\n]);\nOperationSerializers.escrow_dispute = OperationDataSerializer(OPERATION_IDS.escrow_dispute, [\n    ['from', StringSerializer],\n    ['to', StringSerializer],\n    ['agent', StringSerializer],\n    ['who', StringSerializer],\n    ['escrow_id', UInt32Serializer]\n]);\nOperationSerializers.escrow_release = OperationDataSerializer(OPERATION_IDS.escrow_release, [\n    ['from', StringSerializer],\n    ['to', StringSerializer],\n    ['agent', StringSerializer],\n    ['who', StringSerializer],\n    ['receiver', StringSerializer],\n    ['escrow_id', UInt32Serializer],\n    ['hbd_amount', AssetSerializer],\n    ['hive_amount', AssetSerializer]\n]);\nOperationSerializers.escrow_transfer = OperationDataSerializer(OPERATION_IDS.escrow_transfer, [\n    ['from', StringSerializer],\n    ['to', StringSerializer],\n    ['hbd_amount', AssetSerializer],\n    ['hive_amount', AssetSerializer],\n    ['escrow_id', UInt32Serializer],\n    ['agent', StringSerializer],\n    ['fee', AssetSerializer],\n    ['json_meta', StringSerializer],\n    ['ratification_deadline', DateSerializer],\n    ['escrow_expiration', DateSerializer]\n]);\nOperationSerializers.feed_publish = OperationDataSerializer(OPERATION_IDS.feed_publish, [\n    ['publisher', StringSerializer],\n    ['exchange_rate', PriceSerializer]\n]);\nOperationSerializers.limit_order_cancel = OperationDataSerializer(OPERATION_IDS.limit_order_cancel, [\n    ['owner', StringSerializer],\n    ['orderid', UInt32Serializer]\n]);\nOperationSerializers.limit_order_create = OperationDataSerializer(OPERATION_IDS.limit_order_create, [\n    ['owner', StringSerializer],\n    ['orderid', UInt32Serializer],\n    ['amount_to_sell', AssetSerializer],\n    ['min_to_receive', AssetSerializer],\n    ['fill_or_kill', BooleanSerializer],\n    ['expiration', DateSerializer]\n]);\nOperationSerializers.limit_order_create2 = OperationDataSerializer(OPERATION_IDS.limit_order_create2, [\n    ['owner', StringSerializer],\n    ['orderid', UInt32Serializer],\n    ['amount_to_sell', AssetSerializer],\n    ['exchange_rate', PriceSerializer],\n    ['fill_or_kill', BooleanSerializer],\n    ['expiration', DateSerializer]\n]);\nOperationSerializers.recover_account = OperationDataSerializer(OPERATION_IDS.recover_account, [\n    ['account_to_recover', StringSerializer],\n    ['new_owner_authority', AuthoritySerializer],\n    ['recent_owner_authority', AuthoritySerializer],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\n// Not used on chain\n// OperationSerializers.report_over_production = OperationDataSerializer(\n//   OPERATION_IDS.report_over_production,\n//   [\n//     ['reporter', StringSerializer],\n//     ['first_block', SignedBlockHeaderSerializer],\n//     ['second_block', SignedBlockHeaderSerializer]\n//   ]\n// )\nOperationSerializers.request_account_recovery = OperationDataSerializer(OPERATION_IDS.request_account_recovery, [\n    ['recovery_account', StringSerializer],\n    ['account_to_recover', StringSerializer],\n    ['new_owner_authority', AuthoritySerializer],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nOperationSerializers.reset_account = OperationDataSerializer(OPERATION_IDS.reset_account, [\n    ['reset_account', StringSerializer],\n    ['account_to_reset', StringSerializer],\n    ['new_owner_authority', AuthoritySerializer]\n]);\nOperationSerializers.set_reset_account = OperationDataSerializer(OPERATION_IDS.set_reset_account, [\n    ['account', StringSerializer],\n    ['current_reset_account', StringSerializer],\n    ['reset_account', StringSerializer]\n]);\nOperationSerializers.set_withdraw_vesting_route = OperationDataSerializer(OPERATION_IDS.set_withdraw_vesting_route, [\n    ['from_account', StringSerializer],\n    ['to_account', StringSerializer],\n    ['percent', UInt16Serializer],\n    ['auto_vest', BooleanSerializer]\n]);\nOperationSerializers.transfer = OperationDataSerializer(OPERATION_IDS.transfer, [\n    ['from', StringSerializer],\n    ['to', StringSerializer],\n    ['amount', AssetSerializer],\n    ['memo', StringSerializer]\n]);\nOperationSerializers.transfer_from_savings = OperationDataSerializer(OPERATION_IDS.transfer_from_savings, [\n    ['from', StringSerializer],\n    ['request_id', UInt32Serializer],\n    ['to', StringSerializer],\n    ['amount', AssetSerializer],\n    ['memo', StringSerializer]\n]);\nOperationSerializers.transfer_to_savings = OperationDataSerializer(OPERATION_IDS.transfer_to_savings, [\n    ['from', StringSerializer],\n    ['to', StringSerializer],\n    ['amount', AssetSerializer],\n    ['memo', StringSerializer]\n]);\nOperationSerializers.transfer_to_vesting = OperationDataSerializer(OPERATION_IDS.transfer_to_vesting, [\n    ['from', StringSerializer],\n    ['to', StringSerializer],\n    ['amount', AssetSerializer]\n]);\nOperationSerializers.vote = OperationDataSerializer(OPERATION_IDS.vote, [\n    ['voter', StringSerializer],\n    ['author', StringSerializer],\n    ['permlink', StringSerializer],\n    ['weight', Int16Serializer]\n]);\nOperationSerializers.withdraw_vesting = OperationDataSerializer(OPERATION_IDS.withdraw_vesting, [\n    ['account', StringSerializer],\n    ['vesting_shares', AssetSerializer]\n]);\nOperationSerializers.witness_update = OperationDataSerializer(OPERATION_IDS.witness_update, [\n    ['owner', StringSerializer],\n    ['url', StringSerializer],\n    ['block_signing_key', PublicKeySerializer],\n    ['props', ChainPropertiesSerializer],\n    ['fee', AssetSerializer]\n]);\nOperationSerializers.witness_set_properties = OperationDataSerializer(OPERATION_IDS.witness_set_properties, [\n    ['owner', StringSerializer],\n    ['props', FlatMapSerializer(StringSerializer, VariableBinarySerializer)],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nOperationSerializers.account_update2 = OperationDataSerializer(OPERATION_IDS.account_update2, [\n    ['account', StringSerializer],\n    ['owner', OptionalSerializer(AuthoritySerializer)],\n    ['active', OptionalSerializer(AuthoritySerializer)],\n    ['posting', OptionalSerializer(AuthoritySerializer)],\n    ['memo_key', OptionalSerializer(PublicKeySerializer)],\n    ['json_metadata', StringSerializer],\n    ['posting_json_metadata', StringSerializer],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nOperationSerializers.create_proposal = OperationDataSerializer(OPERATION_IDS.create_proposal, [\n    ['creator', StringSerializer],\n    ['receiver', StringSerializer],\n    ['start_date', DateSerializer],\n    ['end_date', DateSerializer],\n    ['daily_pay', AssetSerializer],\n    ['subject', StringSerializer],\n    ['permlink', StringSerializer],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nOperationSerializers.update_proposal_votes = OperationDataSerializer(OPERATION_IDS.update_proposal_votes, [\n    ['voter', StringSerializer],\n    ['proposal_ids', ArraySerializer(Int64Serializer)],\n    ['approve', BooleanSerializer],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nOperationSerializers.remove_proposal = OperationDataSerializer(OPERATION_IDS.remove_proposal, [\n    ['proposal_owner', StringSerializer],\n    ['proposal_ids', ArraySerializer(Int64Serializer)],\n    ['extensions', ArraySerializer(VoidSerializer)]\n]);\nconst ProposalUpdateSerializer = ObjectSerializer([['end_date', DateSerializer]]);\nOperationSerializers.update_proposal = OperationDataSerializer(OPERATION_IDS.update_proposal, [\n    ['proposal_id', UInt64Serializer],\n    ['creator', StringSerializer],\n    ['daily_pay', AssetSerializer],\n    ['subject', StringSerializer],\n    ['permlink', StringSerializer],\n    [\n        'extensions',\n        ArraySerializer(StaticVariantSerializer([VoidSerializer, ProposalUpdateSerializer]))\n    ]\n]);\nOperationSerializers.collateralized_convert = OperationDataSerializer(OPERATION_IDS.collateralized_convert, [\n    ['owner', StringSerializer],\n    ['requestid', UInt32Serializer],\n    ['amount', AssetSerializer]\n]);\nOperationSerializers.recurrent_transfer = OperationDataSerializer(OPERATION_IDS.recurrent_transfer, [\n    ['from', StringSerializer],\n    ['to', StringSerializer],\n    ['amount', AssetSerializer],\n    ['memo', StringSerializer],\n    ['recurrence', UInt16Serializer],\n    ['executions', UInt16Serializer],\n    [\n        'extensions',\n        ArraySerializer(ObjectSerializer([\n            ['type', UInt8Serializer],\n            ['value', ObjectSerializer([['pair_id', UInt8Serializer]])]\n        ]))\n    ]\n]);\nconst OperationSerializer = (buffer, operation) => {\n    const serializer = OperationSerializers[operation[0]];\n    if (!serializer) {\n        throw new Error(`No serializer for operation: ${operation[0]}`);\n    }\n    try {\n        serializer(buffer, operation[1]);\n    }\n    catch (error) {\n        error.message = `${operation[0]}: ${error.message}`;\n        throw error;\n    }\n};\nconst TransactionSerializer = ObjectSerializer([\n    ['ref_block_num', UInt16Serializer],\n    ['ref_block_prefix', UInt32Serializer],\n    ['expiration', DateSerializer],\n    ['operations', ArraySerializer(OperationSerializer)],\n    ['extensions', ArraySerializer(StringSerializer)]\n]);\nconst EncryptedMemoSerializer = ObjectSerializer([\n    ['from', PublicKeySerializer],\n    ['to', PublicKeySerializer],\n    ['nonce', UInt64Serializer],\n    ['check', UInt32Serializer],\n    ['encrypted', BinarySerializer()]\n]);\nexport const Serializer = {\n    // Array: ArraySerializer,\n    Asset: AssetSerializer,\n    // Authority: AuthoritySerializer,\n    // Binary: BinarySerializer,\n    // Boolean: BooleanSerializer,\n    // Date: DateSerializer,\n    // FlatMap: FlatMapSerializer,\n    // Int16: Int16Serializer,\n    // Int32: Int32Serializer,\n    // Int64: Int64Serializer,\n    // Int8: Int8Serializer,\n    Memo: EncryptedMemoSerializer,\n    // Object: ObjectSerializer,\n    // Operation: OperationSerializer,\n    // Optional: OptionalSerializer,\n    Price: PriceSerializer,\n    PublicKey: PublicKeySerializer,\n    // StaticVariant: StaticVariantSerializer,\n    String: StringSerializer,\n    Transaction: TransactionSerializer,\n    UInt16: UInt16Serializer,\n    UInt32: UInt32Serializer\n    // UInt64: UInt64Serializer,\n    // UInt8: UInt8Serializer,\n    // Void: VoidSerializer\n};\n","export const sleep = (ms) => {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n};\n","import { config } from '../config';\nimport { sleep } from './sleep';\n// ── Error Types ─────────────────────────────────────────────────────────────\nexport class RPCError extends Error {\n    constructor(rpcError) {\n        super(rpcError.message);\n        this.name = 'RPCError';\n        this.stack = undefined;\n        this.code = rpcError.code;\n        if ('data' in rpcError) {\n            this.data = rpcError.data;\n        }\n    }\n}\n/**\n * Transport-level error thrown by jsonRPCCall for HTTP status errors (429, 503).\n * Carries node identity and rate-limit info so callers can record health\n * exactly once without double-counting.\n */\nclass NodeError extends Error {\n    constructor(node, message, rateLimitMs = 0) {\n        super(message);\n        this.node = node;\n        this.rateLimitMs = rateLimitMs;\n    }\n}\n/** Errors that indicate the request definitely never reached the server. */\nconst PRE_CONNECTION_ERRORS = ['ECONNREFUSED', 'ENOTFOUND', 'EHOSTUNREACH', 'EAI_AGAIN'];\n/**\n * Check if an error is a pre-connection error (request never reached server).\n *\n * Node.js fetch wraps connection failures as TypeError('fetch failed') with\n * the real error code nested in the cause chain: e.cause.code, e.cause.cause.code, etc.\n * We walk up to 5 levels deep to find the actual code.\n */\nfunction isPreConnectionError(e) {\n    if (!e)\n        return false;\n    const parts = [String(e.message || ''), String(e.code || '')];\n    let cause = e.cause;\n    for (let depth = 0; cause && depth < 5; depth++) {\n        parts.push(String(cause.code || ''), String(cause.message || ''));\n        cause = cause.cause;\n    }\n    const combined = parts.join(' ');\n    return PRE_CONNECTION_ERRORS.some((code) => combined.includes(code));\n}\nclass NodeHealthTracker {\n    constructor() {\n        this.health = new Map();\n    }\n    getOrCreate(node) {\n        let h = this.health.get(node);\n        if (!h) {\n            h = { consecutiveFailures: 0, lastFailureTime: 0, rateLimitedUntil: 0 };\n            this.health.set(node, h);\n        }\n        return h;\n    }\n    recordSuccess(node) {\n        const h = this.getOrCreate(node);\n        h.consecutiveFailures = 0;\n    }\n    recordFailure(node) {\n        const h = this.getOrCreate(node);\n        h.consecutiveFailures++;\n        h.lastFailureTime = Date.now();\n    }\n    recordRateLimit(node, retryAfterMs = 10000) {\n        const h = this.getOrCreate(node);\n        h.rateLimitedUntil = Date.now() + retryAfterMs;\n        h.consecutiveFailures++;\n        h.lastFailureTime = Date.now();\n    }\n    isNodeHealthy(node) {\n        const h = this.health.get(node);\n        if (!h)\n            return true; // unknown nodes assumed healthy\n        // Rate-limited and cooldown hasn't expired\n        if (h.rateLimitedUntil > Date.now())\n            return false;\n        // Too many consecutive failures within the last 30 seconds\n        if (h.consecutiveFailures >= 3 && Date.now() - h.lastFailureTime < 30000)\n            return false;\n        return true;\n    }\n    /** Return nodes sorted: healthy first (preserving order), unhealthy appended. */\n    getOrderedNodes(nodes) {\n        const healthy = [];\n        const unhealthy = [];\n        for (const node of nodes) {\n            if (this.isNodeHealthy(node)) {\n                healthy.push(node);\n            }\n            else {\n                unhealthy.push(node);\n            }\n        }\n        return [...healthy, ...unhealthy];\n    }\n}\nconst rpcHealthTracker = new NodeHealthTracker();\nconst restHealthTracker = new NodeHealthTracker();\n// ── Internal helpers ────────────────────────────────────────────────────────\n/** Record a caught error on the health tracker (handles NodeError to avoid double-counting). */\nfunction recordError(tracker, node, e) {\n    if (e instanceof NodeError) {\n        if (e.rateLimitMs > 0) {\n            tracker.recordRateLimit(node, e.rateLimitMs);\n        }\n        else {\n            tracker.recordFailure(node);\n        }\n    }\n    else {\n        tracker.recordFailure(node);\n    }\n}\n/**\n * Low-level JSON-RPC call to a single node. No failover.\n * Throws RPCError for blockchain rejections, NodeError for HTTP 429/503,\n * and generic Error for other transport failures.\n * @param shouldRetry - If true, retries once on the same node for transient errors.\n */\nconst jsonRPCCall = async (url, method, params, timeout = config.timeout, shouldRetry = false) => {\n    const id = Math.floor(Math.random() * 100000000);\n    const body = {\n        jsonrpc: '2.0',\n        method,\n        params,\n        id\n    };\n    try {\n        const res = await fetch(url, {\n            method: 'POST',\n            body: JSON.stringify(body),\n            headers: { 'Content-Type': 'application/json' },\n            signal: AbortSignal.timeout(timeout)\n        });\n        // Handle HTTP-level errors before parsing JSON.\n        // Throw NodeError so callers can record health exactly once.\n        if (res.status === 429) {\n            const retryAfter = res.headers.get('Retry-After');\n            const cooldownMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : 10000;\n            throw new NodeError(url, `HTTP 429 Rate Limited`, cooldownMs);\n        }\n        if (res.status === 503) {\n            throw new NodeError(url, `HTTP 503 Service Unavailable`);\n        }\n        const result = (await res.json());\n        if (!result ||\n            typeof result.id === 'undefined' ||\n            result.id !== id ||\n            result.jsonrpc !== '2.0') {\n            throw new Error('JSONRPC id mismatch');\n        }\n        if ('result' in result) {\n            return result.result;\n        }\n        if ('error' in result) {\n            const e = result.error;\n            if ('message' in e && 'code' in e) {\n                throw new RPCError(e);\n            }\n            throw result.error;\n        }\n        // No result and no error?\n        throw result;\n    }\n    catch (e) {\n        if (e instanceof RPCError) {\n            throw e;\n        }\n        // NodeError should not be retried on the same node - it's an HTTP status issue\n        if (e instanceof NodeError) {\n            throw e;\n        }\n        if (shouldRetry) {\n            return jsonRPCCall(url, method, params, timeout, false);\n        }\n        throw e;\n    }\n};\n/** Small jitter delay between failover attempts to prevent thundering herd. */\nfunction jitterDelay() {\n    return sleep(50 + Math.random() * 50);\n}\n// ── Public API: callRPC ─────────────────────────────────────────────────────\n/**\n * Makes API calls to Hive blockchain nodes with automatic retry and failover support.\n * Uses per-request retry counters, node health tracking, jitter between retries,\n * and HTTP status awareness (429 rate limiting, 503).\n *\n * If the current node fails, it will automatically try the next healthy node.\n * When all nodes have been tried, wraps around to give earlier nodes another chance\n * until the full retry budget (config.retry) is exhausted.\n * RPCErrors (valid blockchain rejections) are never retried.\n *\n * @param method - The API method name (e.g., 'condenser_api.get_accounts')\n * @param params - Parameters for the API method as array or object\n * @param timeout - Request timeout in milliseconds (default: config.timeout)\n * @param retry - Maximum number of retry attempts (default: config.retry)\n * @returns Promise resolving to the API response\n * @throws {RPCError} On blockchain-level errors (bad params, missing authority, etc.)\n * @throws {Error} If all retry attempts fail\n *\n * @example\n * ```typescript\n * import { callRPC } from 'hive-tx'\n *\n * // Get account information\n * const accounts = await callRPC('condenser_api.get_accounts', [['alice']])\n *\n * // Custom timeout and retry settings\n * const data = await callRPC('condenser_api.get_content', ['alice', 'test-post'], 10_000, 5)\n * ```\n */\nexport const callRPC = async (method, params = [], timeout = config.timeout, retry = config.retry) => {\n    if (!Array.isArray(config.nodes)) {\n        throw new Error('config.nodes is not an array');\n    }\n    if (config.nodes.length === 0) {\n        throw new Error('config.nodes is empty');\n    }\n    // Track nodes tried in the current round. When all nodes have been tried,\n    // clear the set to allow a second round (wrap-around) using the retry budget.\n    const triedInRound = new Set();\n    let lastError;\n    for (let attempt = 0; attempt <= retry; attempt++) {\n        // Re-evaluate node order each attempt so health changes are respected.\n        const orderedNodes = rpcHealthTracker.getOrderedNodes(config.nodes);\n        // Pick the healthiest untried node. If all tried, start a new round.\n        let node = orderedNodes.find((n) => !triedInRound.has(n));\n        if (!node) {\n            triedInRound.clear();\n            node = orderedNodes[0];\n        }\n        triedInRound.add(node);\n        try {\n            const res = await jsonRPCCall(node, method, params, timeout);\n            rpcHealthTracker.recordSuccess(node);\n            return res;\n        }\n        catch (e) {\n            // RPCErrors are valid blockchain rejections - never retry\n            if (e instanceof RPCError) {\n                throw e;\n            }\n            recordError(rpcHealthTracker, node, e);\n            lastError = e;\n            // Add jitter before trying next node\n            if (attempt < retry) {\n                await jitterDelay();\n            }\n        }\n    }\n    throw lastError;\n};\n// ── Public API: callRPC for broadcasts ──────────────────────────────────────\n/**\n * Broadcast-safe RPC call. Only retries on pre-connection errors where the\n * request definitively never reached the server (ECONNREFUSED, ENOTFOUND, etc.).\n * On timeouts, HTTP errors, or any ambiguous failure, throws immediately to\n * prevent double-broadcasting transactions.\n *\n * Tries each node once (no wrap-around) since broadcast retries are dangerous.\n *\n * @internal Used by Transaction.broadcast()\n */\nexport const callRPCBroadcast = async (method, params = [], timeout = config.timeout) => {\n    if (!Array.isArray(config.nodes)) {\n        throw new Error('config.nodes is not an array');\n    }\n    if (config.nodes.length === 0) {\n        throw new Error('config.nodes is empty');\n    }\n    // Track which nodes we've already tried - broadcasts must never retry the same node\n    const triedNodes = new Set();\n    let lastError;\n    for (let attempt = 0; attempt < config.nodes.length; attempt++) {\n        // Re-evaluate order each attempt so health changes are respected\n        const orderedNodes = rpcHealthTracker.getOrderedNodes(config.nodes);\n        const node = orderedNodes.find((n) => !triedNodes.has(n));\n        if (!node)\n            break;\n        triedNodes.add(node);\n        try {\n            const res = await jsonRPCCall(node, method, params, timeout);\n            rpcHealthTracker.recordSuccess(node);\n            return res;\n        }\n        catch (e) {\n            // RPCErrors are valid blockchain rejections - never retry\n            if (e instanceof RPCError) {\n                throw e;\n            }\n            recordError(rpcHealthTracker, node, e);\n            lastError = e;\n            // Only retry broadcasts on pre-connection errors where the request\n            // definitely never reached the server. On timeouts or HTTP errors,\n            // the server may have received and processed the transaction.\n            if (!isPreConnectionError(e)) {\n                throw e;\n            }\n        }\n    }\n    throw lastError;\n};\n// ── Public API: callREST ────────────────────────────────────────────────────\nconst apiMethods = {\n    balance: '/balance-api',\n    hafah: '/hafah-api',\n    hafbe: '/hafbe-api',\n    hivemind: '/hivemind-api',\n    hivesense: '/hivesense-api',\n    reputation: '/reputation-api',\n    'nft-tracker': '/nft-tracker-api',\n    hafsql: '/hafsql',\n    status: '/status-api'\n};\n/**\n * Makes REST API calls to Hive blockchain REST endpoints with automatic retry and failover support.\n * Uses per-request retry counters, node health tracking, and timeout support.\n * Wraps around the node list to honor the full retry budget.\n *\n * @template Api - The REST API method type (e.g., 'balance', 'hafah', 'hivemind', etc.)\n * @template P - The endpoint path type for the specified API\n *\n * @param api - The REST API method name to call\n * @param endpoint - The specific endpoint path within the API\n * @param params - Optional parameters for path and query string replacement\n * @param timeout - Request timeout in milliseconds (default: config.timeout)\n * @param retry - Number of retry attempts before throwing an error (default: config.retry)\n *\n * @returns Promise resolving to the API response data with proper typing\n * @throws Error if all retry attempts fail\n *\n * @example\n * ```typescript\n * import { callREST } from 'hive-tx'\n *\n * // Get account balance\n * const balance = await callREST('balance', '/accounts/{account-name}/balances', { \"account-name\": 'alice' })\n *\n * // Custom timeout and retry settings\n * const data = await callREST('status', '/status', undefined, 10_000, 3)\n * ```\n */\nexport async function callREST(api, endpoint, params, timeout = config.timeout, retry = config.retry) {\n    if (!Array.isArray(config.restNodes)) {\n        throw new Error('config.restNodes is not an array');\n    }\n    if (config.restNodes.length === 0) {\n        throw new Error('config.restNodes is empty');\n    }\n    const triedInRound = new Set();\n    let lastError;\n    // Track whether the error was already recorded by the HTTP status handler\n    let alreadyRecorded = false;\n    for (let attempt = 0; attempt <= retry; attempt++) {\n        // Re-evaluate node order each attempt so health changes are respected.\n        const orderedNodes = restHealthTracker.getOrderedNodes(config.restNodes);\n        let node = orderedNodes.find((n) => !triedInRound.has(n));\n        if (!node) {\n            triedInRound.clear();\n            node = orderedNodes[0];\n        }\n        triedInRound.add(node);\n        const baseUrl = node + apiMethods[api];\n        let path = endpoint;\n        const paramObj = params || {};\n        const processedPathParams = new Set();\n        // Replace path params ONLY\n        Object.entries(paramObj).forEach(([key, value]) => {\n            if (path.includes(`{${key}}`)) {\n                path = path.replace(`{${key}}`, encodeURIComponent(String(value)));\n                processedPathParams.add(key);\n            }\n        });\n        const url = new URL(baseUrl + path);\n        // Add ONLY remaining params as query (if any)\n        Object.entries(paramObj).forEach(([key, value]) => {\n            if (!processedPathParams.has(key)) {\n                if (Array.isArray(value)) {\n                    value.forEach((v) => url.searchParams.append(key, String(v)));\n                }\n                else {\n                    url.searchParams.set(key, String(value));\n                }\n            }\n        });\n        alreadyRecorded = false;\n        try {\n            const response = await fetch(url.toString(), {\n                signal: AbortSignal.timeout(timeout)\n            });\n            if (response.status === 404) {\n                throw new Error('HTTP 404 - Hint: can happen on wrong params');\n            }\n            if (response.status === 429) {\n                const retryAfter = response.headers.get('Retry-After');\n                const cooldownMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : 10000;\n                restHealthTracker.recordRateLimit(node, cooldownMs);\n                alreadyRecorded = true;\n                throw new Error(`HTTP 429 Rate Limited by ${node}`);\n            }\n            if (response.status === 503) {\n                restHealthTracker.recordFailure(node);\n                alreadyRecorded = true;\n                throw new Error(`HTTP 503 Service Unavailable from ${node}`);\n            }\n            restHealthTracker.recordSuccess(node);\n            return response.json();\n        }\n        catch (e) {\n            // 404 is not a node issue, don't failover\n            if (e?.message?.includes('HTTP 404')) {\n                throw e;\n            }\n            // Only record if not already recorded by 429/503 handler above\n            if (!alreadyRecorded) {\n                restHealthTracker.recordFailure(node);\n            }\n            lastError = e;\n            if (attempt < retry) {\n                await jitterDelay();\n            }\n        }\n    }\n    throw lastError;\n}\n// ── Public API: callWithQuorum ───────────────────────────────────────────────\n/**\n * Make a JSONRPC call with quorum. The method will cross-check the result\n * with `quorum` number of nodes before returning the result.\n * @param method - The API method name (e.g., 'condenser_api.get_accounts')\n * @param params - Parameters for the API method as array or object\n * @param quorum - Default: 2 (recommended)\n */\nexport const callWithQuorum = async (method, params = [], quorum = 2) => {\n    if (!Array.isArray(config.nodes)) {\n        throw new Error('config.nodes is not an Array');\n    }\n    if (quorum > config.nodes.length) {\n        throw new Error('quorum > config.nodes.length');\n    }\n    // We call random nodes for better security\n    const shuffleNodes = (arr) => [...arr].sort(() => Math.random() - 0.5);\n    let allNodes = shuffleNodes(config.nodes);\n    let currentBatchSize = Math.min(quorum, allNodes.length);\n    let allResults = [];\n    while (currentBatchSize > 0 && allNodes.length > 0) {\n        // Take next batch of nodes\n        const batchNodes = allNodes.splice(0, currentBatchSize);\n        const promises = [];\n        const batchResults = [];\n        // Launch batch calls in parallel\n        for (let i = 0; i < batchNodes.length; i++) {\n            promises.push(jsonRPCCall(batchNodes[i], method, params, undefined, true)\n                .then((data) => batchResults.push(data))\n                .catch(() => { }));\n        }\n        await Promise.all(promises);\n        allResults.push(...batchResults);\n        // Check for consensus in successful results\n        const consensusResult = findConsensus(allResults, quorum);\n        if (consensusResult) {\n            return consensusResult;\n        }\n        // Prepare next batch\n        currentBatchSize = Math.min(quorum, allNodes.length);\n        if (currentBatchSize === 0) {\n            throw new Error('No more nodes available.');\n        }\n    }\n    throw new Error(\"Couldn't reach quorum.\");\n};\nfunction findConsensus(results, quorum) {\n    const resultGroups = new Map();\n    for (const result of results) {\n        const key = JSON.stringify(result);\n        if (!resultGroups.has(key)) {\n            resultGroups.set(key, []);\n        }\n        resultGroups.get(key).push(result);\n    }\n    const consensusGroup = Array.from(resultGroups.values()).find((group) => group.length >= quorum);\n    return consensusGroup ? consensusGroup[0] : null;\n}\n","import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\nimport { ByteBuffer } from './helpers/ByteBuffer';\nimport { Serializer } from './helpers/serializer';\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { config } from './config';\nimport { callRPC, callRPCBroadcast, RPCError } from './helpers/call';\nimport { sleep } from './helpers/sleep';\nconst chainId = hexToBytes(config.chain_id);\nexport class Transaction {\n    constructor(options) {\n        this.expiration = 60000;\n        /**\n         * Creates the transaction structure and initializes it with blockchain data.\n         * Retrieves current head block information and sets up reference block data.\n         * @private\n         * @param expiration Transaction expiration in milliseconds\n         */\n        this.createTransaction = async (expiration) => {\n            const props = await callRPC('condenser_api.get_dynamic_global_properties', []);\n            const bytes = hexToBytes(props.head_block_id);\n            const refBlockPrefix = Number(new Uint32Array(bytes.buffer, bytes.byteOffset + 4, 1)[0]);\n            const expirationIso = new Date(Date.now() + expiration).toISOString().slice(0, -5);\n            this.transaction = {\n                expiration: expirationIso,\n                extensions: [],\n                operations: [],\n                ref_block_num: props.head_block_number & 0xffff,\n                ref_block_prefix: refBlockPrefix,\n                signatures: []\n            };\n        };\n        if (options?.transaction) {\n            if (options.transaction instanceof Transaction) {\n                this.transaction = options.transaction.transaction;\n                this.expiration = options.transaction.expiration;\n            }\n            else {\n                this.transaction = options.transaction;\n            }\n            this.txId = this.digest().txId;\n        }\n        if (options?.expiration) {\n            this.expiration = options.expiration;\n        }\n    }\n    /**\n     * Adds an operation to the transaction. If no transaction exists, creates one first.\n     * @template O Operation name type for type safety\n     * @param operationName The name/type of the operation to add (e.g., 'transfer', 'vote', 'comment')\n     * @param operationBody The operation data/body for the specified operation type\n     * @returns Promise that resolves when the operation is added\n     * @throws Error if transaction creation fails or global properties cannot be retrieved\n     */\n    async addOperation(operationName, operationBody) {\n        if (!this.transaction) {\n            await this.createTransaction(this.expiration);\n        }\n        this.transaction.operations.push([operationName, operationBody]);\n    }\n    /**\n     * Signs the transaction with the provided key(s), supporting both single and multi-signature transactions.\n     * For multi-signature, you can sign with all keys at once or sign individually by calling this method multiple times.\n     * @param keys Single PrivateKey or array of PrivateKeys to sign the transaction with\n     * @returns The signed transaction\n     * @throws Error if no transaction exists to sign\n     */\n    sign(keys) {\n        if (!this.transaction) {\n            throw new Error('First create a transaction by .addOperation()');\n        }\n        if (this.transaction) {\n            const { digest, txId } = this.digest();\n            if (!Array.isArray(keys)) {\n                keys = [keys];\n            }\n            for (const key of keys) {\n                const signature = key.sign(digest);\n                this.transaction.signatures.push(signature.customToString());\n            }\n            this.txId = txId;\n            return this.transaction;\n        }\n        else {\n            throw new Error('No transaction to sign');\n        }\n    }\n    /**\n     * Broadcasts the signed transaction to the Hive network.\n     * Automatically handles retries and duplicate transaction detection.\n     * @param checkStatus By default (false) the transaction is not guaranteed to be included in a block.\n     * For example the transaction can expire while waiting in mempool.\n     * If you pass true here, the function will wait for the transaction to be either included or dropped\n     * before returning a result.\n     * @returns Promise resolving to broadcast result\n     * @throws Error if no transaction exists or transaction is not signed or transaction got rejected\n     */\n    async broadcast(checkStatus = false) {\n        if (!this.transaction) {\n            throw new Error('Attempted to broadcast an empty transaction. Add operations by .addOperation()');\n        }\n        if (this.transaction.signatures.length === 0) {\n            throw new Error('Attempted to broadcast a transaction with no signatures. Sign using .sign(keys)');\n        }\n        try {\n            await callRPCBroadcast('condenser_api.broadcast_transaction', [this.transaction]);\n        }\n        catch (e) {\n            if (e instanceof RPCError && e.message.includes('Duplicate transaction check failed')) {\n                // ignore duplicate transaction error as this can happen when we retry the broadcast\n            }\n            else {\n                throw e;\n            }\n        }\n        if (!this.txId) {\n            this.txId = this.digest().txId;\n        }\n        if (!checkStatus) {\n            return { tx_id: this.txId, status: 'unknown' };\n        }\n        // Poll until the transaction reaches a final state or max attempts exceeded.\n        // With 60 attempts: delays grow from 1.3s to 19s, total wait ~10 minutes.\n        const maxPollAttempts = 60;\n        await sleep(1000);\n        let status = await this.checkStatus();\n        let i = 1;\n        while (status?.status !== 'within_irreversible_block' &&\n            status?.status !== 'expired_irreversible' &&\n            status?.status !== 'too_old' &&\n            i < maxPollAttempts) {\n            await sleep(1000 + i * 300);\n            status = await this.checkStatus();\n            i++;\n        }\n        return {\n            tx_id: this.txId,\n            status: (status?.status ?? 'unknown')\n        };\n    }\n    /**\n     * Returns the transaction digest containing the transaction ID and hash.\n     * The digest can be used to verify signatures and for transaction identification.\n     * @returns DigestData containing transaction ID and hash\n     * @throws Error if no transaction exists\n     */\n    digest() {\n        if (!this.transaction) {\n            throw new Error('First create a transaction by .addOperation()');\n        }\n        const buffer = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n        const temp = { ...this.transaction };\n        try {\n            Serializer.Transaction(buffer, temp);\n        }\n        catch (cause) {\n            throw new Error('Unable to serialize transaction: ' + cause);\n        }\n        buffer.flip();\n        const transactionData = new Uint8Array(buffer.toBuffer());\n        const txId = bytesToHex(sha256(transactionData)).slice(0, 40);\n        const digest = sha256(new Uint8Array([...chainId, ...transactionData]));\n        return { digest, txId };\n    }\n    /**\n     * Adds a signature to an already created transaction. Useful when signing with external tools.\n     * Multiple signatures can be added one at a time for multi-signature transactions.\n     * @param signature The signature string in hex format (must be exactly 130 characters)\n     * @returns The transaction with the added signature\n     * @throws Error if no transaction exists or signature format is invalid\n     */\n    addSignature(signature) {\n        if (!this.transaction) {\n            throw new Error('First create a transaction by .create(operations)');\n        }\n        if (typeof signature !== 'string') {\n            throw new Error('Signature must be string');\n        }\n        if (signature.length !== 130) {\n            throw new Error('Signature must be 130 characters long');\n        }\n        this.transaction.signatures.push(signature);\n        return this.transaction;\n    }\n    /** Get status of this transaction. Usually called internally after broadcasting. */\n    async checkStatus() {\n        if (!this.txId) {\n            this.txId = this.digest().txId;\n        }\n        return callRPC('transaction_status_api.find_transaction', {\n            transaction_id: this.txId,\n            expiration: this.transaction?.expiration\n        });\n    }\n}\n","import bs58 from 'bs58';\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport { sha256, sha512 } from '@noble/hashes/sha2.js';\nimport { PublicKey } from './PublicKey';\nimport { Signature } from './Signature';\nimport { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\nconst NETWORK_ID = new Uint8Array([0x80]);\n/**\n * ECDSA (secp256k1) private key for signing and encryption operations.\n * Handles key generation, derivation from seeds/passwords, and cryptographic operations.\n *\n * All private keys are stored internally as Uint8Array and can be converted to/from\n * Wallet Import Format (WIF) strings for storage and transmission.\n *\n * @example\n * ```typescript\n * // From WIF string\n * const key = PrivateKey.from('5JdeC9P7Pbd1uGdFVEsJ41EkEnADbbHGq6p1BwFxm6txNBsQnsw')\n *\n * // Generate random key\n * const randomKey = PrivateKey.randomKey()\n *\n * // From username and password\n * const loginKey = PrivateKey.fromLogin('username', 'password')\n *\n * // Sign a message\n * const signature = key.sign(someHash)\n *\n * // Get public key\n * const pubKey = key.createPublic()\n * ```\n */\nexport class PrivateKey {\n    constructor(key) {\n        this.key = key;\n        try {\n            secp256k1.getPublicKey(key);\n        }\n        catch (e) {\n            throw new Error('invalid private key');\n        }\n    }\n    /**\n     * Creates a PrivateKey instance from a WIF string or raw Uint8Array.\n     * Automatically detects the input type and uses the appropriate method.\n     *\n     * @param value - WIF formatted string or raw 32-byte key as Uint8Array\n     * @returns New PrivateKey instance\n     * @throws Error if the key format is invalid\n     */\n    static from(value) {\n        if (typeof value === 'string') {\n            return PrivateKey.fromString(value);\n        }\n        else {\n            return new PrivateKey(value);\n        }\n    }\n    /**\n     * Creates a PrivateKey from a Wallet Import Format (WIF) encoded string.\n     *\n     * @param wif - WIF encoded private key string\n     * @returns New PrivateKey instance\n     * @throws Error if WIF format is invalid or checksum fails\n     */\n    static fromString(wif) {\n        return new PrivateKey(decodePrivate(wif).subarray(1));\n    }\n    /**\n     * Creates a PrivateKey from a seed string or Uint8Array.\n     * The seed is hashed with SHA256 to produce the private key.\n     *\n     * @param seed - Seed string (converted to bytes) or raw byte array\n     * @returns New PrivateKey instance derived from seed\n     */\n    static fromSeed(seed) {\n        if (typeof seed === 'string') {\n            const isHex = /^[0-9a-fA-F]+$/.test(seed);\n            if (isHex) {\n                seed = hexToBytes(seed);\n            }\n            else {\n                // Convert non-hex string to Uint8Array using UTF-8 encoding\n                seed = new TextEncoder().encode(seed);\n            }\n        }\n        return new PrivateKey(sha256(seed));\n    }\n    /**\n     * Derives a PrivateKey from username, password, and role using Hive's key derivation scheme.\n     * This generates the same keys that the Hive wallet uses for login-based keys.\n     *\n     * @param username - Hive username\n     * @param password - Master password (or seed phrase)\n     * @param role - Key role ('owner', 'active', 'posting', 'memo')\n     * @returns New PrivateKey instance for the specified role\n     */\n    static fromLogin(username, password, role = 'active') {\n        const seed = username + role + password;\n        return PrivateKey.fromSeed(seed);\n    }\n    /**\n     * Signs a 32-byte message hash using ECDSA and returns a recoverable signature.\n     * The signature includes recovery information to allow public key recovery.\n     *\n     * @param message - 32-byte message hash to sign (Uint8Array)\n     * @returns Signature object containing the signature data\n     */\n    sign(message) {\n        const rv = secp256k1.sign(message, this.key, {\n            extraEntropy: true,\n            format: 'recovered',\n            prehash: false // prehash does sha256 on the message\n        });\n        const recovery = parseInt(bytesToHex(rv.subarray(0, 1)), 16);\n        return Signature.from((recovery + 31).toString(16) + bytesToHex(rv.subarray(1)));\n    }\n    /**\n     * Derives the corresponding public key for this private key.\n     *\n     * @param prefix - Optional address prefix (defaults to config.address_prefix)\n     * @returns PublicKey instance derived from this private key\n     */\n    createPublic(prefix) {\n        return new PublicKey(secp256k1.getPublicKey(this.key), prefix);\n    }\n    /**\n     * Returns the private key as a Wallet Import Format (WIF) encoded string.\n     * This includes network ID and checksum for safe storage/transmission.\n     *\n     * @returns WIF encoded private key string\n     */\n    toString() {\n        return encodePrivate(new Uint8Array([...NETWORK_ID, ...this.key]));\n    }\n    /**\n     * Returns a masked representation of the private key for debugging/logging.\n     * Shows only the first and last 6 characters to avoid accidental exposure.\n     * Use toString() to get the full key for export/serialization.\n     *\n     * @returns Masked key representation for safe logging\n     */\n    inspect() {\n        const key = this.toString();\n        return `PrivateKey: ${key.slice(0, 6)}...${key.slice(-6)}`;\n    }\n    /**\n     * Computes a shared secret using ECDH key exchange for memo encryption.\n     * The shared secret is used as a key for AES encryption/decryption.\n     *\n     * @param publicKey - Other party's public key\n     * @returns 64-byte shared secret as Uint8Array\n     */\n    getSharedSecret(publicKey) {\n        const s = secp256k1.getSharedSecret(this.key, publicKey.key);\n        // strip the parity byte\n        return sha512(s.subarray(1));\n    }\n    /**\n     * Generates a new cryptographically secure random private key.\n     * Uses the secp256k1 key generation algorithm for security.\n     * This method may take up to 250ms due to entropy collection.\n     *\n     * @returns New randomly generated PrivateKey instance\n     */\n    static randomKey() {\n        return new PrivateKey(secp256k1.keygen().secretKey);\n    }\n}\nconst doubleSha256 = (input) => {\n    const dbl = sha256(sha256(input));\n    return dbl;\n};\n/** Encode bs58+doubleSha256-checksum private key. */\nconst encodePrivate = (key) => {\n    // assert.equal(key.readUInt8(0), 0x80, 'private key network id mismatch')\n    const checksum = doubleSha256(key);\n    return bs58.encode(new Uint8Array([...key, ...checksum.slice(0, 4)]));\n};\n/** Decode bs58+doubleSha256-checksum encoded private key. */\nconst decodePrivate = (encodedKey) => {\n    const buffer = bs58.decode(encodedKey);\n    if (!isUint8ArrayEqual(buffer.slice(0, 1), NETWORK_ID)) {\n        throw new Error('Private key network id mismatch');\n    }\n    const checksum = buffer.slice(-4);\n    const key = buffer.slice(0, -4);\n    const checksumVerify = doubleSha256(key).slice(0, 4);\n    if (!isUint8ArrayEqual(checksum, checksumVerify)) {\n        throw new Error('Private key checksum mismatch');\n    }\n    return key;\n};\nconst isUint8ArrayEqual = (a, b) => {\n    if (a === b)\n        return true;\n    if (a.byteLength !== b.byteLength)\n        return false;\n    const len = a.byteLength;\n    let i = 0;\n    while (i < len && a[i] === b[i])\n        i++;\n    return i === len;\n};\n","/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */\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 boolean. */\nexport function abool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`boolean expected, not ${b}`);\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(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/** 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, undefined, 'output');\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/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\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// Used in micro\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    return BigInt(hex === '' ? '0' : '0x' + hex); // Big Endian\n}\n// Used in ff1\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\n// Used in micro, ff1\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(new Uint8Array([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes) {\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Checks if two U8A use same underlying buffer and overlaps.\n * This is invalid and can corrupt data.\n */\nexport function overlapBytes(a, b) {\n    return (a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy\n        a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end\n        b.byteOffset < a.byteOffset + a.byteLength // b starts before a end\n    );\n}\n/**\n * If input and output overlap and input starts before output, we will overwrite end of input before\n * we start processing it, so this is not supported for most ciphers (except chacha/salse, which designed with this)\n */\nexport function complexOverlapBytes(input, output) {\n    // This is very cursed. It works somehow, but I'm completely unsure,\n    // reasoning about overlapping aligned windows is very hard.\n    if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)\n        throw new Error('complex overlap of input and output is not supported');\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\nexport function checkOpts(defaults, opts) {\n    if (opts == null || typeof opts !== 'object')\n        throw new Error('options must be defined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/** Compares 2 uint8array-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 * Wraps a cipher: validates args, ensures encrypt() can only be called once.\n * @__NO_SIDE_EFFECTS__\n */\nexport const wrapCipher = (params, constructor) => {\n    function wrappedCipher(key, ...args) {\n        // Validate key\n        abytes(key, undefined, 'key');\n        // Big-Endian hardware is rare. Just in case someone still decides to run ciphers:\n        if (!isLE)\n            throw new Error('Non little-endian hardware is not yet supported');\n        // Validate nonce if nonceLength is present\n        if (params.nonceLength !== undefined) {\n            const nonce = args[0];\n            abytes(nonce, params.varSizeNonce ? undefined : params.nonceLength, 'nonce');\n        }\n        // Validate AAD if tagLength present\n        const tagl = params.tagLength;\n        if (tagl && args[1] !== undefined)\n            abytes(args[1], undefined, 'AAD');\n        const cipher = constructor(key, ...args);\n        const checkOutput = (fnLength, output) => {\n            if (output !== undefined) {\n                if (fnLength !== 2)\n                    throw new Error('cipher output not supported');\n                abytes(output, undefined, 'output');\n            }\n        };\n        // Create wrapped cipher with validation and single-use encryption\n        let called = false;\n        const wrCipher = {\n            encrypt(data, output) {\n                if (called)\n                    throw new Error('cannot encrypt() twice with same key + nonce');\n                called = true;\n                abytes(data);\n                checkOutput(cipher.encrypt.length, output);\n                return cipher.encrypt(data, output);\n            },\n            decrypt(data, output) {\n                abytes(data);\n                if (tagl && data.length < tagl)\n                    throw new Error('\"ciphertext\" expected length bigger than tagLength=' + tagl);\n                checkOutput(cipher.decrypt.length, output);\n                return cipher.decrypt(data, output);\n            },\n        };\n        return wrCipher;\n    }\n    Object.assign(wrappedCipher, params);\n    return wrappedCipher;\n};\n/**\n * By default, returns u8a of length.\n * When out is available, it checks it for validity and uses it.\n */\nexport function getOutput(expectedLength, out, onlyAligned = true) {\n    if (out === undefined)\n        return new Uint8Array(expectedLength);\n    if (out.length !== expectedLength)\n        throw new Error('\"output\" expected Uint8Array of length ' + expectedLength + ', got: ' + out.length);\n    if (onlyAligned && !isAligned32(out))\n        throw new Error('invalid output, must be aligned');\n    return out;\n}\nexport function u64Lengths(dataLength, aadLength, isLE) {\n    abool(isLE);\n    const num = new Uint8Array(16);\n    const view = createView(num);\n    view.setBigUint64(0, BigInt(aadLength), isLE);\n    view.setBigUint64(8, BigInt(dataLength), isLE);\n    return num;\n}\n// Is byte array aligned to 4 byte offset (u32)?\nexport function isAligned32(bytes) {\n    return bytes.byteOffset % 4 === 0;\n}\n// copy bytes to new u8a (aligned). Because Buffer.slice is broken.\nexport function copyBytes(bytes) {\n    return Uint8Array.from(bytes);\n}\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;\n    if (typeof cr?.getRandomValues !== 'function')\n        throw new Error('crypto.getRandomValues must be defined');\n    return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n/**\n * Uses CSPRG for nonce, nonce injected in ciphertext.\n * For `encrypt`, a `nonceBytes`-length buffer is fetched from CSPRNG and\n * prepended to encrypted ciphertext. For `decrypt`, first `nonceBytes` of ciphertext\n * are treated as nonce.\n *\n * NOTE: Under the same key, using random nonces (e.g. `managedNonce`) with AES-GCM and ChaCha\n * should be limited to `2**23` (8M) messages to get a collision chance of `2**-50`. Stretching to  * `2**32` (4B) messages, chance would become `2**-33` - still negligible, but creeping up.\n * @example\n * const gcm = managedNonce(aes.gcm);\n * const ciphr = gcm(key).encrypt(data);\n * const plain = gcm(key).decrypt(ciph);\n */\nexport function managedNonce(fn, randomBytes_ = randomBytes) {\n    const { nonceLength } = fn;\n    anumber(nonceLength);\n    const addNonce = (nonce, ciphertext) => {\n        const out = concatBytes(nonce, ciphertext);\n        ciphertext.fill(0);\n        return out;\n    };\n    // NOTE: we cannot support DST here, it would be mistake:\n    // - we don't know how much dst length cipher requires\n    // - nonce may unalign dst and break everything\n    // - we create new u8a anyway (concatBytes)\n    // - previously we passed all args to cipher, but that was mistake!\n    return ((key, ...args) => ({\n        encrypt(plaintext) {\n            abytes(plaintext);\n            const nonce = randomBytes_(nonceLength);\n            const encrypted = fn(key, nonce, ...args).encrypt(plaintext);\n            // @ts-ignore\n            if (encrypted instanceof Promise)\n                return encrypted.then((ct) => addNonce(nonce, ct));\n            return addNonce(nonce, encrypted);\n        },\n        decrypt(ciphertext) {\n            abytes(ciphertext);\n            const nonce = ciphertext.subarray(0, nonceLength);\n            const decrypted = ciphertext.subarray(nonceLength);\n            return fn(key, nonce, ...args).decrypt(decrypted);\n        },\n    }));\n}\n//# sourceMappingURL=utils.js.map","/**\n * GHash from AES-GCM and its little-endian \"mirror image\" Polyval from AES-SIV.\n *\n * Implemented in terms of GHash with conversion function for keys\n * GCM GHASH from\n * [NIST SP800-38d](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf),\n * SIV from\n * [RFC 8452](https://www.rfc-editor.org/rfc/rfc8452).\n *\n * GHASH   modulo: x^128 + x^7   + x^2   + x     + 1\n * POLYVAL modulo: x^128 + x^127 + x^126 + x^121 + 1\n *\n * @module\n */\nimport { abytes, aexists, aoutput, clean, copyBytes, createView, u32, } from \"./utils.js\";\nconst BLOCK_SIZE = 16;\n// TODO: rewrite\n// temporary padding buffer\nconst ZEROS16 = /* @__PURE__ */ new Uint8Array(16);\nconst ZEROS32 = u32(ZEROS16);\nconst POLY = 0xe1; // v = 2*v % POLY\n// v = 2*v % POLY\n// NOTE: because x + x = 0 (add/sub is same), mul2(x) != x+x\n// We can multiply any number using montgomery ladder and this function (works as double, add is simple xor)\nconst mul2 = (s0, s1, s2, s3) => {\n    const hiBit = s3 & 1;\n    return {\n        s3: (s2 << 31) | (s3 >>> 1),\n        s2: (s1 << 31) | (s2 >>> 1),\n        s1: (s0 << 31) | (s1 >>> 1),\n        s0: (s0 >>> 1) ^ ((POLY << 24) & -(hiBit & 1)), // reduce % poly\n    };\n};\nconst swapLE = (n) => (((n >>> 0) & 0xff) << 24) |\n    (((n >>> 8) & 0xff) << 16) |\n    (((n >>> 16) & 0xff) << 8) |\n    ((n >>> 24) & 0xff) |\n    0;\n/**\n * `mulX_POLYVAL(ByteReverse(H))` from spec\n * @param k mutated in place\n */\nexport function _toGHASHKey(k) {\n    k.reverse();\n    const hiBit = k[15] & 1;\n    // k >>= 1\n    let carry = 0;\n    for (let i = 0; i < k.length; i++) {\n        const t = k[i];\n        k[i] = (t >>> 1) | carry;\n        carry = (t & 1) << 7;\n    }\n    k[0] ^= -hiBit & 0xe1; // if (hiBit) n ^= 0xe1000000000000000000000000000000;\n    return k;\n}\nconst estimateWindow = (bytes) => {\n    if (bytes > 64 * 1024)\n        return 8;\n    if (bytes > 1024)\n        return 4;\n    return 2;\n};\nexport class GHASH {\n    blockLen = BLOCK_SIZE;\n    outputLen = BLOCK_SIZE;\n    s0 = 0;\n    s1 = 0;\n    s2 = 0;\n    s3 = 0;\n    finished = false;\n    t;\n    W;\n    windowSize;\n    // We select bits per window adaptively based on expectedLength\n    constructor(key, expectedLength) {\n        abytes(key, 16, 'key');\n        key = copyBytes(key);\n        const kView = createView(key);\n        let k0 = kView.getUint32(0, false);\n        let k1 = kView.getUint32(4, false);\n        let k2 = kView.getUint32(8, false);\n        let k3 = kView.getUint32(12, false);\n        // generate table of doubled keys (half of montgomery ladder)\n        const doubles = [];\n        for (let i = 0; i < 128; i++) {\n            doubles.push({ s0: swapLE(k0), s1: swapLE(k1), s2: swapLE(k2), s3: swapLE(k3) });\n            ({ s0: k0, s1: k1, s2: k2, s3: k3 } = mul2(k0, k1, k2, k3));\n        }\n        const W = estimateWindow(expectedLength || 1024);\n        if (![1, 2, 4, 8].includes(W))\n            throw new Error('ghash: invalid window size, expected 2, 4 or 8');\n        this.W = W;\n        const bits = 128; // always 128 bits;\n        const windows = bits / W;\n        const windowSize = (this.windowSize = 2 ** W);\n        const items = [];\n        // Create precompute table for window of W bits\n        for (let w = 0; w < windows; w++) {\n            // truth table: 00, 01, 10, 11\n            for (let byte = 0; byte < windowSize; byte++) {\n                // prettier-ignore\n                let s0 = 0, s1 = 0, s2 = 0, s3 = 0;\n                for (let j = 0; j < W; j++) {\n                    const bit = (byte >>> (W - j - 1)) & 1;\n                    if (!bit)\n                        continue;\n                    const { s0: d0, s1: d1, s2: d2, s3: d3 } = doubles[W * w + j];\n                    ((s0 ^= d0), (s1 ^= d1), (s2 ^= d2), (s3 ^= d3));\n                }\n                items.push({ s0, s1, s2, s3 });\n            }\n        }\n        this.t = items;\n    }\n    _updateBlock(s0, s1, s2, s3) {\n        ((s0 ^= this.s0), (s1 ^= this.s1), (s2 ^= this.s2), (s3 ^= this.s3));\n        const { W, t, windowSize } = this;\n        // prettier-ignore\n        let o0 = 0, o1 = 0, o2 = 0, o3 = 0;\n        const mask = (1 << W) - 1; // 2**W will kill performance.\n        let w = 0;\n        for (const num of [s0, s1, s2, s3]) {\n            for (let bytePos = 0; bytePos < 4; bytePos++) {\n                const byte = (num >>> (8 * bytePos)) & 0xff;\n                for (let bitPos = 8 / W - 1; bitPos >= 0; bitPos--) {\n                    const bit = (byte >>> (W * bitPos)) & mask;\n                    const { s0: e0, s1: e1, s2: e2, s3: e3 } = t[w * windowSize + bit];\n                    ((o0 ^= e0), (o1 ^= e1), (o2 ^= e2), (o3 ^= e3));\n                    w += 1;\n                }\n            }\n        }\n        this.s0 = o0;\n        this.s1 = o1;\n        this.s2 = o2;\n        this.s3 = o3;\n    }\n    update(data) {\n        aexists(this);\n        abytes(data);\n        data = copyBytes(data);\n        const b32 = u32(data);\n        const blocks = Math.floor(data.length / BLOCK_SIZE);\n        const left = data.length % BLOCK_SIZE;\n        for (let i = 0; i < blocks; i++) {\n            this._updateBlock(b32[i * 4 + 0], b32[i * 4 + 1], b32[i * 4 + 2], b32[i * 4 + 3]);\n        }\n        if (left) {\n            ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));\n            this._updateBlock(ZEROS32[0], ZEROS32[1], ZEROS32[2], ZEROS32[3]);\n            clean(ZEROS32); // clean tmp buffer\n        }\n        return this;\n    }\n    destroy() {\n        const { t } = this;\n        // clean precompute table\n        for (const elm of t) {\n            ((elm.s0 = 0), (elm.s1 = 0), (elm.s2 = 0), (elm.s3 = 0));\n        }\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        const { s0, s1, s2, s3 } = this;\n        const o32 = u32(out);\n        o32[0] = s0;\n        o32[1] = s1;\n        o32[2] = s2;\n        o32[3] = s3;\n        return out;\n    }\n    digest() {\n        const res = new Uint8Array(BLOCK_SIZE);\n        this.digestInto(res);\n        this.destroy();\n        return res;\n    }\n}\nexport class Polyval extends GHASH {\n    constructor(key, expectedLength) {\n        abytes(key);\n        const ghKey = _toGHASHKey(copyBytes(key));\n        super(ghKey, expectedLength);\n        clean(ghKey);\n    }\n    update(data) {\n        aexists(this);\n        abytes(data);\n        data = copyBytes(data);\n        const b32 = u32(data);\n        const left = data.length % BLOCK_SIZE;\n        const blocks = Math.floor(data.length / BLOCK_SIZE);\n        for (let i = 0; i < blocks; i++) {\n            this._updateBlock(swapLE(b32[i * 4 + 3]), swapLE(b32[i * 4 + 2]), swapLE(b32[i * 4 + 1]), swapLE(b32[i * 4 + 0]));\n        }\n        if (left) {\n            ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));\n            this._updateBlock(swapLE(ZEROS32[3]), swapLE(ZEROS32[2]), swapLE(ZEROS32[1]), swapLE(ZEROS32[0]));\n            clean(ZEROS32);\n        }\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        // tmp ugly hack\n        const { s0, s1, s2, s3 } = this;\n        const o32 = u32(out);\n        o32[0] = s0;\n        o32[1] = s1;\n        o32[2] = s2;\n        o32[3] = s3;\n        return out.reverse();\n    }\n}\nfunction wrapConstructorWithKey(hashCons) {\n    const hashC = (msg, key) => hashCons(key, msg.length).update(msg).digest();\n    const tmp = hashCons(new Uint8Array(16), 0);\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (key, expectedLength) => hashCons(key, expectedLength);\n    return hashC;\n}\n/** GHash MAC for AES-GCM. */\nexport const ghash = wrapConstructorWithKey((key, expectedLength) => new GHASH(key, expectedLength));\n/** Polyval MAC for AES-SIV. */\nexport const polyval = wrapConstructorWithKey((key, expectedLength) => new Polyval(key, expectedLength));\n//# sourceMappingURL=_polyval.js.map","/**\n * [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)\n * a.k.a. Advanced Encryption Standard\n * is a variant of Rijndael block cipher, standardized by NIST in 2001.\n * We provide the fastest available pure JS implementation.\n *\n * `cipher = encrypt(block, key)`\n *\n * Data is split into 128-bit blocks. Encrypted in 10/12/14 rounds (128/192/256 bits). In every round:\n * 1. **S-box**, table substitution\n * 2. **Shift rows**, cyclic shift left of all rows of data array\n * 3. **Mix columns**, multiplying every column by fixed polynomial\n * 4. **Add round key**, round_key xor i-th column of array\n *\n * Check out [FIPS-197](https://csrc.nist.gov/files/pubs/fips/197/final/docs/fips-197.pdf),\n * [NIST 800-38G](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38G.pdf)\n * and [original proposal](https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/aes-development/rijndael-ammended.pdf)\n * @module\n */\nimport { ghash, polyval } from \"./_polyval.js\";\n// prettier-ignore\nimport { abytes, anumber, clean, complexOverlapBytes, concatBytes, copyBytes, createView, equalBytes, getOutput, isAligned32, overlapBytes, u32, u64Lengths, u8, wrapCipher } from \"./utils.js\";\nconst BLOCK_SIZE = 16;\nconst BLOCK_SIZE32 = 4;\nconst EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE);\nconst ONE_BLOCK = /* @__PURE__ */ Uint8Array.from([\n    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,\n]);\nconst POLY = 0x11b; // 1 + x + x**3 + x**4 + x**8\nfunction validateKeyLength(key) {\n    if (![16, 24, 32].includes(key.length))\n        throw new Error('\"aes key\" expected Uint8Array of length 16/24/32, got length=' + key.length);\n}\n// TODO: remove multiplication, binary ops only\nfunction mul2(n) {\n    return (n << 1) ^ (POLY & -(n >> 7));\n}\nfunction mul(a, b) {\n    let res = 0;\n    for (; b > 0; b >>= 1) {\n        // Montgomery ladder\n        res ^= a & -(b & 1); // if (b&1) res ^=a (but const-time).\n        a = mul2(a); // a = 2*a\n    }\n    return res;\n}\n// Increments bigint with wrap around\n// NOTE: we cannot use u32 here since it may overflow on carry!\nconst incBytes = (data, isLE, carry = 1) => {\n    if (!Number.isSafeInteger(carry))\n        throw new Error('incBytes: wrong carry ' + carry);\n    abytes(data);\n    for (let i = 0; i < data.length; i++) {\n        const pos = !isLE ? data.length - 1 - i : i;\n        carry = (carry + (data[pos] & 0xff)) | 0;\n        data[pos] = carry & 0xff;\n        carry >>>= 8;\n    }\n};\n// AES S-box is generated using finite field inversion,\n// an affine transform, and xor of a constant 0x63.\nconst sbox = /* @__PURE__ */ (() => {\n    const t = new Uint8Array(256);\n    for (let i = 0, x = 1; i < 256; i++, x ^= mul2(x))\n        t[i] = x;\n    const box = new Uint8Array(256);\n    box[0] = 0x63; // first elm\n    for (let i = 0; i < 255; i++) {\n        let x = t[255 - i];\n        x |= x << 8;\n        box[t[i]] = (x ^ (x >> 4) ^ (x >> 5) ^ (x >> 6) ^ (x >> 7) ^ 0x63) & 0xff;\n    }\n    clean(t);\n    return box;\n})();\n// Inverted S-box\nconst invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));\n// Rotate u32 by 8\nconst rotr32_8 = (n) => (n << 24) | (n >>> 8);\nconst rotl32_8 = (n) => (n << 8) | (n >>> 24);\n// The byte swap operation for uint32 (LE<->BE)\nconst byteSwap = (word) => ((word << 24) & 0xff000000) |\n    ((word << 8) & 0xff0000) |\n    ((word >>> 8) & 0xff00) |\n    ((word >>> 24) & 0xff);\n// T-table is optimization suggested in 5.2 of original proposal (missed from FIPS-197). Changes:\n// - LE instead of BE\n// - bigger tables: T0 and T1 are merged into T01 table and T2 & T3 into T23;\n//   so index is u16, instead of u8. This speeds up things, unexpectedly\nfunction genTtable(sbox, fn) {\n    if (sbox.length !== 256)\n        throw new Error('Wrong sbox length');\n    const T0 = new Uint32Array(256).map((_, j) => fn(sbox[j]));\n    const T1 = T0.map(rotl32_8);\n    const T2 = T1.map(rotl32_8);\n    const T3 = T2.map(rotl32_8);\n    const T01 = new Uint32Array(256 * 256);\n    const T23 = new Uint32Array(256 * 256);\n    const sbox2 = new Uint16Array(256 * 256);\n    for (let i = 0; i < 256; i++) {\n        for (let j = 0; j < 256; j++) {\n            const idx = i * 256 + j;\n            T01[idx] = T0[i] ^ T1[j];\n            T23[idx] = T2[i] ^ T3[j];\n            sbox2[idx] = (sbox[i] << 8) | sbox[j];\n        }\n    }\n    return { sbox, sbox2, T0, T1, T2, T3, T01, T23 };\n}\nconst tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => (mul(s, 3) << 24) | (s << 16) | (s << 8) | mul(s, 2));\nconst tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => (mul(s, 11) << 24) | (mul(s, 13) << 16) | (mul(s, 9) << 8) | mul(s, 14));\nconst xPowers = /* @__PURE__ */ (() => {\n    const p = new Uint8Array(16);\n    for (let i = 0, x = 1; i < 16; i++, x = mul2(x))\n        p[i] = x;\n    return p;\n})();\n/** Key expansion used in CTR. */\nfunction expandKeyLE(key) {\n    abytes(key);\n    const len = key.length;\n    validateKeyLength(key);\n    const { sbox2 } = tableEncoding;\n    const toClean = [];\n    if (!isAligned32(key))\n        toClean.push((key = copyBytes(key)));\n    const k32 = u32(key);\n    const Nk = k32.length;\n    const subByte = (n) => applySbox(sbox2, n, n, n, n);\n    const xk = new Uint32Array(len + 28); // expanded key\n    xk.set(k32);\n    // 4.3.1 Key expansion\n    for (let i = Nk; i < xk.length; i++) {\n        let t = xk[i - 1];\n        if (i % Nk === 0)\n            t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];\n        else if (Nk > 6 && i % Nk === 4)\n            t = subByte(t);\n        xk[i] = xk[i - Nk] ^ t;\n    }\n    clean(...toClean);\n    return xk;\n}\nfunction expandKeyDecLE(key) {\n    const encKey = expandKeyLE(key);\n    const xk = encKey.slice();\n    const Nk = encKey.length;\n    const { sbox2 } = tableEncoding;\n    const { T0, T1, T2, T3 } = tableDecoding;\n    // Inverse key by chunks of 4 (rounds)\n    for (let i = 0; i < Nk; i += 4) {\n        for (let j = 0; j < 4; j++)\n            xk[i + j] = encKey[Nk - i - 4 + j];\n    }\n    clean(encKey);\n    // apply InvMixColumn except first & last round\n    for (let i = 4; i < Nk - 4; i++) {\n        const x = xk[i];\n        const w = applySbox(sbox2, x, x, x, x);\n        xk[i] = T0[w & 0xff] ^ T1[(w >>> 8) & 0xff] ^ T2[(w >>> 16) & 0xff] ^ T3[w >>> 24];\n    }\n    return xk;\n}\n// Apply tables\nfunction apply0123(T01, T23, s0, s1, s2, s3) {\n    return (T01[((s0 << 8) & 0xff00) | ((s1 >>> 8) & 0xff)] ^\n        T23[((s2 >>> 8) & 0xff00) | ((s3 >>> 24) & 0xff)]);\n}\nfunction applySbox(sbox2, s0, s1, s2, s3) {\n    return (sbox2[(s0 & 0xff) | (s1 & 0xff00)] |\n        (sbox2[((s2 >>> 16) & 0xff) | ((s3 >>> 16) & 0xff00)] << 16));\n}\nfunction encrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableEncoding;\n    let k = 0;\n    ((s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]));\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);\n        ((s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3));\n    }\n    // last round (without mixcolumns, so using SBOX2 table)\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\n// Can't be merged with encrypt: arg positions for apply0123 / applySbox are different\nfunction decrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableDecoding;\n    let k = 0;\n    ((s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]));\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);\n        ((s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3));\n    }\n    // Last round\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\n// TODO: investigate merging with ctr32\nfunction ctrCounter(xk, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE, 'nonce');\n    abytes(src);\n    const srcLen = src.length;\n    dst = getOutput(srcLen, dst);\n    complexOverlapBytes(src, dst);\n    const ctr = nonce;\n    const c32 = u32(ctr);\n    // Fill block (empty, ctr=0)\n    let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ s0;\n        dst32[i + 1] = src32[i + 1] ^ s1;\n        dst32[i + 2] = src32[i + 2] ^ s2;\n        dst32[i + 3] = src32[i + 3] ^ s3;\n        incBytes(ctr, false, 1); // Full 128 bit counter with wrap around\n        ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));\n    }\n    // leftovers (less than block)\n    // It's possible to handle > u32 fast, but is it worth it?\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n        clean(b32);\n    }\n    return dst;\n}\n// AES CTR with overflowing 32 bit counter\n// It's possible to do 32le significantly simpler (and probably faster) by using u32.\n// But, we need both, and perf bottleneck is in ghash anyway.\nfunction ctr32(xk, isLE, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE, 'nonce');\n    abytes(src);\n    dst = getOutput(src.length, dst);\n    const ctr = nonce; // write new value to nonce, so it can be re-used\n    const c32 = u32(ctr);\n    const view = createView(ctr);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    const ctrPos = isLE ? 0 : 12;\n    const srcLen = src.length;\n    // Fill block (empty, ctr=0)\n    let ctrNum = view.getUint32(ctrPos, isLE); // read current counter value\n    let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ s0;\n        dst32[i + 1] = src32[i + 1] ^ s1;\n        dst32[i + 2] = src32[i + 2] ^ s2;\n        dst32[i + 3] = src32[i + 3] ^ s3;\n        ctrNum = (ctrNum + 1) >>> 0; // u32 wrap\n        view.setUint32(ctrPos, ctrNum, isLE);\n        ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));\n    }\n    // leftovers (less than a block)\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n        clean(b32);\n    }\n    return dst;\n}\n/**\n * **CTR** (Counter Mode): Turns a block cipher into a stream cipher using a counter and IV (nonce).\n * Efficient and parallelizable. Requires a unique nonce per encryption. Unauthenticated: needs MAC.\n */\nexport const ctr = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aesctr(key, nonce) {\n    function processCtr(buf, dst) {\n        abytes(buf);\n        if (dst !== undefined) {\n            abytes(dst);\n            if (!isAligned32(dst))\n                throw new Error('unaligned destination');\n        }\n        const xk = expandKeyLE(key);\n        const n = copyBytes(nonce); // align + avoid changing\n        const toClean = [xk, n];\n        if (!isAligned32(buf))\n            toClean.push((buf = copyBytes(buf)));\n        const out = ctrCounter(xk, n, buf, dst);\n        clean(...toClean);\n        return out;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCtr(plaintext, dst),\n        decrypt: (ciphertext, dst) => processCtr(ciphertext, dst),\n    };\n});\nfunction validateBlockDecrypt(data) {\n    abytes(data);\n    if (data.length % BLOCK_SIZE !== 0) {\n        throw new Error('aes-(cbc/ecb).decrypt ciphertext should consist of blocks with size ' + BLOCK_SIZE);\n    }\n}\nfunction validateBlockEncrypt(plaintext, pcks5, dst) {\n    abytes(plaintext);\n    let outLen = plaintext.length;\n    const remaining = outLen % BLOCK_SIZE;\n    if (!pcks5 && remaining !== 0)\n        throw new Error('aec/(cbc-ecb): unpadded plaintext with disabled padding');\n    if (!isAligned32(plaintext))\n        plaintext = copyBytes(plaintext);\n    const b = u32(plaintext);\n    if (pcks5) {\n        let left = BLOCK_SIZE - remaining;\n        if (!left)\n            left = BLOCK_SIZE; // if no bytes left, create empty padding block\n        outLen = outLen + left;\n    }\n    dst = getOutput(outLen, dst);\n    complexOverlapBytes(plaintext, dst);\n    const o = u32(dst);\n    return { b, o, out: dst };\n}\nfunction validatePCKS(data, pcks5) {\n    if (!pcks5)\n        return data;\n    const len = data.length;\n    if (!len)\n        throw new Error('aes/pcks5: empty ciphertext not allowed');\n    const lastByte = data[len - 1];\n    if (lastByte <= 0 || lastByte > 16)\n        throw new Error('aes/pcks5: wrong padding');\n    const out = data.subarray(0, -lastByte);\n    for (let i = 0; i < lastByte; i++)\n        if (data[len - i - 1] !== lastByte)\n            throw new Error('aes/pcks5: wrong padding');\n    return out;\n}\nfunction padPCKS(left) {\n    const tmp = new Uint8Array(16);\n    const tmp32 = u32(tmp);\n    tmp.set(left);\n    const paddingByte = BLOCK_SIZE - left.length;\n    for (let i = BLOCK_SIZE - paddingByte; i < BLOCK_SIZE; i++)\n        tmp[i] = paddingByte;\n    return tmp32;\n}\n/**\n * **ECB** (Electronic Codebook): Deterministic encryption; identical plaintext blocks yield\n * identical ciphertexts. Not secure due to pattern leakage.\n * See [AES Penguin](https://words.filippo.io/the-ecb-penguin/).\n */\nexport const ecb = /* @__PURE__ */ wrapCipher({ blockSize: 16 }, function aesecb(key, opts = {}) {\n    const pcks5 = !opts.disablePadding;\n    return {\n        encrypt(plaintext, dst) {\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);\n            const xk = expandKeyLE(key);\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = encrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            if (pcks5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                const { s0, s1, s2, s3 } = encrypt(xk, tmp32[0], tmp32[1], tmp32[2], tmp32[3]);\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            clean(xk);\n            return _out;\n        },\n        decrypt(ciphertext, dst) {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            dst = getOutput(ciphertext.length, dst);\n            const toClean = [xk];\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            complexOverlapBytes(ciphertext, dst);\n            const b = u32(ciphertext);\n            const o = u32(dst);\n            for (let i = 0; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = decrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            clean(...toClean);\n            return validatePCKS(dst, pcks5);\n        },\n    };\n});\n/**\n * **CBC** (Cipher Block Chaining): Each plaintext block is XORed with the\n * previous block of ciphertext before encryption.\n * Hard to use: requires proper padding and an IV. Unauthenticated: needs MAC.\n */\nexport const cbc = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aescbc(key, iv, opts = {}) {\n    const pcks5 = !opts.disablePadding;\n    return {\n        encrypt(plaintext, dst) {\n            const xk = expandKeyLE(key);\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);\n            let _iv = iv;\n            const toClean = [xk];\n            if (!isAligned32(_iv))\n                toClean.push((_iv = copyBytes(_iv)));\n            const n32 = u32(_iv);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                ((s0 ^= b[i + 0]), (s1 ^= b[i + 1]), (s2 ^= b[i + 2]), (s3 ^= b[i + 3]));\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            if (pcks5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                ((s0 ^= tmp32[0]), (s1 ^= tmp32[1]), (s2 ^= tmp32[2]), (s3 ^= tmp32[3]));\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            clean(...toClean);\n            return _out;\n        },\n        decrypt(ciphertext, dst) {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            let _iv = iv;\n            const toClean = [xk];\n            if (!isAligned32(_iv))\n                toClean.push((_iv = copyBytes(_iv)));\n            const n32 = u32(_iv);\n            dst = getOutput(ciphertext.length, dst);\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            complexOverlapBytes(ciphertext, dst);\n            const b = u32(ciphertext);\n            const o = u32(dst);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            for (let i = 0; i + 4 <= b.length;) {\n                // prettier-ignore\n                const ps0 = s0, ps1 = s1, ps2 = s2, ps3 = s3;\n                ((s0 = b[i + 0]), (s1 = b[i + 1]), (s2 = b[i + 2]), (s3 = b[i + 3]));\n                const { s0: o0, s1: o1, s2: o2, s3: o3 } = decrypt(xk, s0, s1, s2, s3);\n                ((o[i++] = o0 ^ ps0), (o[i++] = o1 ^ ps1), (o[i++] = o2 ^ ps2), (o[i++] = o3 ^ ps3));\n            }\n            clean(...toClean);\n            return validatePCKS(dst, pcks5);\n        },\n    };\n});\n/**\n * CFB: Cipher Feedback Mode. The input for the block cipher is the previous cipher output.\n * Unauthenticated: needs MAC.\n */\nexport const cfb = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aescfb(key, iv) {\n    function processCfb(src, isEncrypt, dst) {\n        abytes(src);\n        const srcLen = src.length;\n        dst = getOutput(srcLen, dst);\n        if (overlapBytes(src, dst))\n            throw new Error('overlapping src and dst not supported.');\n        const xk = expandKeyLE(key);\n        let _iv = iv;\n        const toClean = [xk];\n        if (!isAligned32(_iv))\n            toClean.push((_iv = copyBytes(_iv)));\n        if (!isAligned32(src))\n            toClean.push((src = copyBytes(src)));\n        const src32 = u32(src);\n        const dst32 = u32(dst);\n        const next32 = isEncrypt ? dst32 : src32;\n        const n32 = u32(_iv);\n        // prettier-ignore\n        let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n        for (let i = 0; i + 4 <= src32.length;) {\n            const { s0: e0, s1: e1, s2: e2, s3: e3 } = encrypt(xk, s0, s1, s2, s3);\n            dst32[i + 0] = src32[i + 0] ^ e0;\n            dst32[i + 1] = src32[i + 1] ^ e1;\n            dst32[i + 2] = src32[i + 2] ^ e2;\n            dst32[i + 3] = src32[i + 3] ^ e3;\n            ((s0 = next32[i++]), (s1 = next32[i++]), (s2 = next32[i++]), (s3 = next32[i++]));\n        }\n        // leftovers (less than block)\n        const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n        if (start < srcLen) {\n            ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n            const buf = u8(new Uint32Array([s0, s1, s2, s3]));\n            for (let i = start, pos = 0; i < srcLen; i++, pos++)\n                dst[i] = src[i] ^ buf[pos];\n            clean(buf);\n        }\n        clean(...toClean);\n        return dst;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCfb(plaintext, true, dst),\n        decrypt: (ciphertext, dst) => processCfb(ciphertext, false, dst),\n    };\n});\n// TODO: merge with chacha, however gcm has bitLen while chacha has byteLen\nfunction computeTag(fn, isLE, key, data, AAD) {\n    const aadLength = AAD ? AAD.length : 0;\n    const h = fn.create(key, data.length + aadLength);\n    if (AAD)\n        h.update(AAD);\n    const num = u64Lengths(8 * data.length, 8 * aadLength, isLE);\n    h.update(data);\n    h.update(num);\n    const res = h.digest();\n    clean(num);\n    return res;\n}\n/**\n * **GCM** (Galois/Counter Mode): Combines CTR mode with polynomial MAC. Efficient and widely used.\n * Not perfect:\n * a) conservative key wear-out is `2**32` (4B) msgs.\n * b) key wear-out under random nonces is even smaller: `2**23` (8M) messages for `2**-50` chance.\n * c) MAC can be forged: see Poly1305 documentation.\n */\nexport const gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {\n    // NIST 800-38d doesn't enforce minimum nonce length.\n    // We enforce 8 bytes for compat with openssl.\n    // 12 bytes are recommended. More than 12 bytes would be converted into 12.\n    if (nonce.length < 8)\n        throw new Error('aes/gcm: invalid nonce length');\n    const tagLength = 16;\n    function _computeTag(authKey, tagMask, data) {\n        const tag = computeTag(ghash, false, authKey, data, AAD);\n        for (let i = 0; i < tagMask.length; i++)\n            tag[i] ^= tagMask[i];\n        return tag;\n    }\n    function deriveKeys() {\n        const xk = expandKeyLE(key);\n        const authKey = EMPTY_BLOCK.slice();\n        const counter = EMPTY_BLOCK.slice();\n        ctr32(xk, false, counter, counter, authKey);\n        // NIST 800-38d, page 15: different behavior for 96-bit and non-96-bit nonces\n        if (nonce.length === 12) {\n            counter.set(nonce);\n        }\n        else {\n            const nonceLen = EMPTY_BLOCK.slice();\n            const view = createView(nonceLen);\n            view.setBigUint64(8, BigInt(nonce.length * 8), false);\n            // ghash(nonce || u64be(0) || u64be(nonceLen*8))\n            const g = ghash.create(authKey).update(nonce).update(nonceLen);\n            g.digestInto(counter); // digestInto doesn't trigger '.destroy'\n            g.destroy();\n        }\n        const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);\n        return { xk, authKey, counter, tagMask };\n    }\n    return {\n        encrypt(plaintext) {\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const out = new Uint8Array(plaintext.length + tagLength);\n            const toClean = [xk, authKey, counter, tagMask];\n            if (!isAligned32(plaintext))\n                toClean.push((plaintext = copyBytes(plaintext)));\n            ctr32(xk, false, counter, plaintext, out.subarray(0, plaintext.length));\n            const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));\n            toClean.push(tag);\n            out.set(tag, plaintext.length);\n            clean(...toClean);\n            return out;\n        },\n        decrypt(ciphertext) {\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const toClean = [xk, authKey, tagMask, counter];\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            const data = ciphertext.subarray(0, -tagLength);\n            const passedTag = ciphertext.subarray(-tagLength);\n            const tag = _computeTag(authKey, tagMask, data);\n            toClean.push(tag);\n            if (!equalBytes(tag, passedTag))\n                throw new Error('aes/gcm: invalid ghash tag');\n            const out = ctr32(xk, false, counter, data);\n            clean(...toClean);\n            return out;\n        },\n    };\n});\nconst limit = (name, min, max) => (value) => {\n    if (!Number.isSafeInteger(value) || min > value || value > max) {\n        const minmax = '[' + min + '..' + max + ']';\n        throw new Error('' + name + ': expected value in range ' + minmax + ', got ' + value);\n    }\n};\n/**\n * **SIV** (Synthetic IV): GCM with nonce-misuse resistance.\n * Repeating nonces reveal only the fact plaintexts are identical.\n * Also suffers from GCM issues: key wear-out limits & MAC forging.\n * See [RFC 8452](https://www.rfc-editor.org/rfc/rfc8452).\n */\nexport const gcmsiv = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aessiv(key, nonce, AAD) {\n    const tagLength = 16;\n    // From RFC 8452: Section 6\n    const AAD_LIMIT = limit('AAD', 0, 2 ** 36);\n    const PLAIN_LIMIT = limit('plaintext', 0, 2 ** 36);\n    const NONCE_LIMIT = limit('nonce', 12, 12);\n    const CIPHER_LIMIT = limit('ciphertext', 16, 2 ** 36 + 16);\n    abytes(key);\n    validateKeyLength(key);\n    NONCE_LIMIT(nonce.length);\n    if (AAD !== undefined)\n        AAD_LIMIT(AAD.length);\n    function deriveKeys() {\n        const xk = expandKeyLE(key);\n        const encKey = new Uint8Array(key.length);\n        const authKey = new Uint8Array(16);\n        const toClean = [xk, encKey];\n        let _nonce = nonce;\n        if (!isAligned32(_nonce))\n            toClean.push((_nonce = copyBytes(_nonce)));\n        const n32 = u32(_nonce);\n        // prettier-ignore\n        let s0 = 0, s1 = n32[0], s2 = n32[1], s3 = n32[2];\n        let counter = 0;\n        for (const derivedKey of [authKey, encKey].map(u32)) {\n            const d32 = u32(derivedKey);\n            for (let i = 0; i < d32.length; i += 2) {\n                // aes(u32le(0) || nonce)[:8] || aes(u32le(1) || nonce)[:8] ...\n                const { s0: o0, s1: o1 } = encrypt(xk, s0, s1, s2, s3);\n                d32[i + 0] = o0;\n                d32[i + 1] = o1;\n                s0 = ++counter; // increment counter inside state\n            }\n        }\n        const res = { authKey, encKey: expandKeyLE(encKey) };\n        // Cleanup\n        clean(...toClean);\n        return res;\n    }\n    function _computeTag(encKey, authKey, data) {\n        const tag = computeTag(polyval, true, authKey, data, AAD);\n        // Compute the expected tag by XORing S_s and the nonce, clearing the\n        // most significant bit of the last byte and encrypting with the\n        // message-encryption key.\n        for (let i = 0; i < 12; i++)\n            tag[i] ^= nonce[i];\n        tag[15] &= 0x7f; // Clear the highest bit\n        // encrypt tag as block\n        const t32 = u32(tag);\n        // prettier-ignore\n        let s0 = t32[0], s1 = t32[1], s2 = t32[2], s3 = t32[3];\n        ({ s0, s1, s2, s3 } = encrypt(encKey, s0, s1, s2, s3));\n        ((t32[0] = s0), (t32[1] = s1), (t32[2] = s2), (t32[3] = s3));\n        return tag;\n    }\n    // actual decrypt/encrypt of message.\n    function processSiv(encKey, tag, input) {\n        let block = copyBytes(tag);\n        block[15] |= 0x80; // Force highest bit\n        const res = ctr32(encKey, true, block, input);\n        // Cleanup\n        clean(block);\n        return res;\n    }\n    return {\n        encrypt(plaintext) {\n            PLAIN_LIMIT(plaintext.length);\n            const { encKey, authKey } = deriveKeys();\n            const tag = _computeTag(encKey, authKey, plaintext);\n            const toClean = [encKey, authKey, tag];\n            if (!isAligned32(plaintext))\n                toClean.push((plaintext = copyBytes(plaintext)));\n            const out = new Uint8Array(plaintext.length + tagLength);\n            out.set(tag, plaintext.length);\n            out.set(processSiv(encKey, tag, plaintext));\n            // Cleanup\n            clean(...toClean);\n            return out;\n        },\n        decrypt(ciphertext) {\n            CIPHER_LIMIT(ciphertext.length);\n            const tag = ciphertext.subarray(-tagLength);\n            const { encKey, authKey } = deriveKeys();\n            const toClean = [encKey, authKey];\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            const plaintext = processSiv(encKey, tag, ciphertext.subarray(0, -tagLength));\n            const expectedTag = _computeTag(encKey, authKey, plaintext);\n            toClean.push(expectedTag);\n            if (!equalBytes(tag, expectedTag)) {\n                clean(...toClean);\n                throw new Error('invalid polyval tag');\n            }\n            // Cleanup\n            clean(...toClean);\n            return plaintext;\n        },\n    };\n});\nfunction isBytes32(a) {\n    return (a instanceof Uint32Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint32Array'));\n}\nfunction encryptBlock(xk, block) {\n    abytes(block, 16, 'block');\n    if (!isBytes32(xk))\n        throw new Error('_encryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    let { s0, s1, s2, s3 } = encrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    ((b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3));\n    return block;\n}\nfunction decryptBlock(xk, block) {\n    abytes(block, 16, 'block');\n    if (!isBytes32(xk))\n        throw new Error('_decryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    let { s0, s1, s2, s3 } = decrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    ((b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3));\n    return block;\n}\n/**\n * AES-W (base for AESKW/AESKWP).\n * Specs: [SP800-38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf),\n * [RFC 3394](https://www.rfc-editor.org/rfc/rfc3394),\n * [RFC 5649](https://www.rfc-editor.org/rfc/rfc5649).\n */\nconst AESW = {\n    /*\n    High-level pseudocode:\n    ```\n    A: u64 = IV\n    out = []\n    for (let i=0, ctr = 0; i<6; i++) {\n      for (const chunk of chunks(plaintext, 8)) {\n        A ^= swapEndianess(ctr++)\n        [A, res] = chunks(encrypt(A || chunk), 8);\n        out ||= res\n      }\n    }\n    out = A || out\n    ```\n    Decrypt is the same, but reversed.\n    */\n    encrypt(kek, out) {\n        // Size is limited to 4GB, otherwise ctr will overflow and we'll need to switch to bigints.\n        // If you need it larger, open an issue.\n        if (out.length >= 2 ** 32)\n            throw new Error('plaintext should be less than 4gb');\n        const xk = expandKeyLE(kek);\n        if (out.length === 16)\n            encryptBlock(xk, out);\n        else {\n            const o32 = u32(out);\n            // prettier-ignore\n            let a0 = o32[0], a1 = o32[1]; // A\n            for (let j = 0, ctr = 1; j < 6; j++) {\n                for (let pos = 2; pos < o32.length; pos += 2, ctr++) {\n                    const { s0, s1, s2, s3 } = encrypt(xk, a0, a1, o32[pos], o32[pos + 1]);\n                    // A = MSB(64, B) ^ t where t = (n*j)+i\n                    ((a0 = s0), (a1 = s1 ^ byteSwap(ctr)), (o32[pos] = s2), (o32[pos + 1] = s3));\n                }\n            }\n            ((o32[0] = a0), (o32[1] = a1)); // out = A || out\n        }\n        xk.fill(0);\n    },\n    decrypt(kek, out) {\n        if (out.length - 8 >= 2 ** 32)\n            throw new Error('ciphertext should be less than 4gb');\n        const xk = expandKeyDecLE(kek);\n        const chunks = out.length / 8 - 1; // first chunk is IV\n        if (chunks === 1)\n            decryptBlock(xk, out);\n        else {\n            const o32 = u32(out);\n            // prettier-ignore\n            let a0 = o32[0], a1 = o32[1]; // A\n            for (let j = 0, ctr = chunks * 6; j < 6; j++) {\n                for (let pos = chunks * 2; pos >= 1; pos -= 2, ctr--) {\n                    a1 ^= byteSwap(ctr);\n                    const { s0, s1, s2, s3 } = decrypt(xk, a0, a1, o32[pos], o32[pos + 1]);\n                    ((a0 = s0), (a1 = s1), (o32[pos] = s2), (o32[pos + 1] = s3));\n                }\n            }\n            ((o32[0] = a0), (o32[1] = a1));\n        }\n        xk.fill(0);\n    },\n};\nconst AESKW_IV = /* @__PURE__ */ new Uint8Array(8).fill(0xa6); // A6A6A6A6A6A6A6A6\n/**\n * AES-KW (key-wrap). Injects static IV into plaintext, adds counter, encrypts 6 times.\n * Reduces block size from 16 to 8 bytes.\n * For padded version, use aeskwp.\n * [RFC 3394](https://www.rfc-editor.org/rfc/rfc3394/),\n * [NIST.SP.800-38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf).\n */\nexport const aeskw = /* @__PURE__ */ wrapCipher({ blockSize: 8 }, (kek) => ({\n    encrypt(plaintext) {\n        if (!plaintext.length || plaintext.length % 8 !== 0)\n            throw new Error('invalid plaintext length');\n        if (plaintext.length === 8)\n            throw new Error('8-byte keys not allowed in AESKW, use AESKWP instead');\n        const out = concatBytes(AESKW_IV, plaintext);\n        AESW.encrypt(kek, out);\n        return out;\n    },\n    decrypt(ciphertext) {\n        // ciphertext must be at least 24 bytes and a multiple of 8 bytes\n        // 24 because should have at least two block (1 iv + 2).\n        // Replace with 16 to enable '8-byte keys'\n        if (ciphertext.length % 8 !== 0 || ciphertext.length < 3 * 8)\n            throw new Error('invalid ciphertext length');\n        const out = copyBytes(ciphertext);\n        AESW.decrypt(kek, out);\n        if (!equalBytes(out.subarray(0, 8), AESKW_IV))\n            throw new Error('integrity check failed');\n        out.subarray(0, 8).fill(0); // ciphertext.subarray(0, 8) === IV, but we clean it anyway\n        return out.subarray(8);\n    },\n}));\n/*\nWe don't support 8-byte keys. The rabbit hole:\n\n- Wycheproof says: \"NIST SP 800-38F does not define the wrapping of 8 byte keys.\n  RFC 3394 Section 2  on the other hand specifies that 8 byte keys are wrapped\n  by directly encrypting one block with AES.\"\n    - https://github.com/C2SP/wycheproof/blob/master/doc/key_wrap.md\n    - \"RFC 3394 specifies in Section 2, that the input for the key wrap\n      algorithm must be at least two blocks and otherwise the constant\n      field and key are simply encrypted with ECB as a single block\"\n- What RFC 3394 actually says (in Section 2):\n    - \"Before being wrapped, the key data is parsed into n blocks of 64 bits.\n      The only restriction the key wrap algorithm places on n is that n be\n      at least two\"\n    - \"For key data with length less than or equal to 64 bits, the constant\n      field used in this specification and the key data form a single\n      128-bit codebook input making this key wrap unnecessary.\"\n- Which means \"assert(n >= 2)\" and \"use something else for 8 byte keys\"\n- NIST SP800-38F actually prohibits 8-byte in \"5.3.1 Mandatory Limits\".\n  It states that plaintext for KW should be \"2 to 2^54 -1 semiblocks\".\n- So, where does \"directly encrypt single block with AES\" come from?\n    - Not RFC 3394. Pseudocode of key wrap in 2.2 explicitly uses\n      loop of 6 for any code path\n    - There is a weird W3C spec:\n      https://www.w3.org/TR/2002/REC-xmlenc-core-20021210/Overview.html#kw-aes128\n    - This spec is outdated, as admitted by Wycheproof authors\n    - There is RFC 5649 for padded key wrap, which is padding construction on\n      top of AESKW. In '4.1.2' it says: \"If the padded plaintext contains exactly\n      eight octets, then prepend the AIV as defined in Section 3 above to P[1] and\n      encrypt the resulting 128-bit block using AES in ECB mode [Modes] with key\n      K (the KEK).  In this case, the output is two 64-bit blocks C[0] and C[1]:\"\n    - Browser subtle crypto is actually crashes on wrapping keys less than 16 bytes:\n      `Error: error:1C8000E6:Provider routines::invalid input length] { opensslErrorStack: [ 'error:030000BD:digital envelope routines::update error' ]`\n\nIn the end, seems like a bug in Wycheproof.\nThe 8-byte check can be easily disabled inside of AES_W.\n*/\nconst AESKWP_IV = 0xa65959a6; // single u32le value\n/**\n * AES-KW, but with padding and allows random keys.\n * Second u32 of IV is used as counter for length.\n * [RFC 5649](https://www.rfc-editor.org/rfc/rfc5649)\n */\nexport const aeskwp = /* @__PURE__ */ wrapCipher({ blockSize: 8 }, (kek) => ({\n    encrypt(plaintext) {\n        if (!plaintext.length)\n            throw new Error('invalid plaintext length');\n        const padded = Math.ceil(plaintext.length / 8) * 8;\n        const out = new Uint8Array(8 + padded);\n        out.set(plaintext, 8);\n        const out32 = u32(out);\n        out32[0] = AESKWP_IV;\n        out32[1] = byteSwap(plaintext.length);\n        AESW.encrypt(kek, out);\n        return out;\n    },\n    decrypt(ciphertext) {\n        // 16 because should have at least one block\n        if (ciphertext.length < 16)\n            throw new Error('invalid ciphertext length');\n        const out = copyBytes(ciphertext);\n        const o32 = u32(out);\n        AESW.decrypt(kek, out);\n        const len = byteSwap(o32[1]) >>> 0;\n        const padded = Math.ceil(len / 8) * 8;\n        if (o32[0] !== AESKWP_IV || out.length - 8 !== padded)\n            throw new Error('integrity check failed');\n        for (let i = len; i < padded; i++)\n            if (out[8 + i] !== 0)\n                throw new Error('integrity check failed');\n        out.subarray(0, 8).fill(0); // ciphertext.subarray(0, 8) === IV, but we clean it anyway\n        return out.subarray(8, 8 + len);\n    },\n}));\nclass _AesCtrDRBG {\n    blockLen;\n    key;\n    nonce;\n    state;\n    reseedCnt;\n    constructor(keyLen, seed, personalization) {\n        this.blockLen = ctr.blockSize;\n        const keyLenBytes = keyLen / 8;\n        const nonceLen = 16;\n        this.state = new Uint8Array(keyLenBytes + nonceLen);\n        this.key = this.state.subarray(0, keyLenBytes);\n        this.nonce = this.state.subarray(keyLenBytes, keyLenBytes + nonceLen);\n        this.reseedCnt = 1;\n        incBytes(this.nonce, false, 1);\n        this.addEntropy(seed, personalization);\n    }\n    update(data) {\n        // cannot re-use state here, because we will wipe current key\n        ctr(this.key, this.nonce).encrypt(new Uint8Array(this.state.length), this.state);\n        if (data) {\n            abytes(data);\n            for (let i = 0; i < data.length; i++)\n                this.state[i] ^= data[i];\n        }\n        incBytes(this.nonce, false, 1);\n    }\n    addEntropy(seed, info) {\n        abytes(seed, this.state.length, 'seed');\n        const _seed = seed.slice();\n        if (info) {\n            abytes(info);\n            if (info.length > _seed.length)\n                throw new Error('info length is too big');\n            for (let i = 0; i < info.length; i++)\n                _seed[i] ^= info[i];\n        }\n        this.update(_seed);\n        _seed.fill(0);\n        this.reseedCnt = 1;\n    }\n    randomBytes(len, info) {\n        anumber(len);\n        if (this.reseedCnt++ >= 2 ** 48)\n            throw new Error('entropy exhausted');\n        if (info)\n            this.update(info);\n        const res = new Uint8Array(len);\n        ctr(this.key, this.nonce).encrypt(res, res);\n        incBytes(this.nonce, false, Math.ceil(len / this.blockLen));\n        this.update(info);\n        return res;\n    }\n    clean() {\n        this.state.fill(0);\n        this.reseedCnt = 0;\n    }\n}\nconst createAesDrbg = (keyLen) => {\n    return (seed, personalization = undefined) => new _AesCtrDRBG(keyLen, seed, personalization);\n};\n/**\n * AES-CTR DRBG 128-bit - CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n */\nexport const rngAesCtrDrbg128 = /* @__PURE__ */ createAesDrbg(128);\n/**\n * AES-CTR DRBG 256-bit - CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n */\nexport const rngAesCtrDrbg256 = /* @__PURE__ */ createAesDrbg(256);\n//#region CMAC\n/**\n * Left-shift by one bit and conditionally XOR with 0x87:\n * ```\n * if MSB(L) is equal to 0\n * then    K1 := L << 1;\n * else    K1 := (L << 1) XOR const_Rb;\n * ```\n *\n * Specs: [RFC 4493, Section 2.3](https://www.rfc-editor.org/rfc/rfc4493.html#section-2.3),\n *        [RFC 5297 Section 2.3](https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.3)\n *\n * @returns modified `block` (for chaining)\n */\nfunction dbl(block) {\n    let carry = 0;\n    // Left shift by 1 bit\n    for (let i = BLOCK_SIZE - 1; i >= 0; i--) {\n        const newCarry = (block[i] & 0x80) >>> 7;\n        block[i] = (block[i] << 1) | carry;\n        carry = newCarry;\n    }\n    // XOR with 0x87 if there was a carry from the most significant bit\n    if (carry) {\n        block[BLOCK_SIZE - 1] ^= 0x87;\n    }\n    return block;\n}\n/**\n * `a XOR b`, running in-site on `a`.\n * @param a left operand and output\n * @param b right operand\n * @returns `a` (for chaining)\n */\nfunction xorBlock(a, b) {\n    if (a.length !== b.length)\n        throw new Error('xorBlock: blocks must have same length');\n    for (let i = 0; i < a.length; i++) {\n        a[i] = a[i] ^ b[i];\n    }\n    return a;\n}\n/**\n * xorend as defined in [RFC 5297 Section 2.1](https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.1).\n *\n * ```\n * leftmost(A, len(A)-len(B)) || (rightmost(A, len(B)) xor B)\n * ```\n */\nfunction xorend(a, b) {\n    if (b.length > a.length) {\n        throw new Error('xorend: len(B) must be less than or equal to len(A)');\n    }\n    // keep leftmost part of `a` unchanged\n    // and xor only the rightmost part:\n    const offset = a.length - b.length;\n    for (let i = 0; i < b.length; i++) {\n        a[offset + i] = a[offset + i] ^ b[i];\n    }\n    return a;\n}\n/**\n * Internal CMAC class.\n */\nclass _CMAC {\n    buffer;\n    destroyed;\n    k1;\n    k2;\n    xk;\n    constructor(key) {\n        abytes(key);\n        validateKeyLength(key);\n        this.xk = expandKeyLE(key);\n        this.buffer = new Uint8Array(0);\n        this.destroyed = false;\n        // L = AES_encrypt(K, const_Zero)\n        const L = new Uint8Array(BLOCK_SIZE);\n        encryptBlock(this.xk, L);\n        // Generate subkeys K1 and K2 from the main key according to\n        // [RFC 4493, Section 2.3](https://www.rfc-editor.org/rfc/rfc4493.html#section-2.3)\n        // K1\n        this.k1 = dbl(L);\n        this.k2 = dbl(new Uint8Array(this.k1));\n    }\n    update(data) {\n        const { destroyed, buffer } = this;\n        if (destroyed)\n            throw new Error('CMAC instance was destroyed');\n        abytes(data);\n        const newBuffer = new Uint8Array(buffer.length + data.length);\n        newBuffer.set(buffer);\n        newBuffer.set(data, buffer.length);\n        this.buffer = newBuffer;\n        return this;\n    }\n    // see https://www.rfc-editor.org/rfc/rfc4493.html#section-2.4\n    digest() {\n        if (this.destroyed)\n            throw new Error('CMAC instance was destroyed');\n        const { buffer } = this;\n        const msgLen = buffer.length;\n        // Step 2:\n        let n = Math.ceil(msgLen / BLOCK_SIZE); // n := ceil(len/const_Bsize);\n        // Step 3:\n        let flag; // denoting if last block is complete or not\n        if (n === 0) {\n            n = 1;\n            flag = false;\n        }\n        else {\n            flag = msgLen % BLOCK_SIZE === 0; // if len mod const_Bsize is 0\n        }\n        // Step 4:\n        const lastBlockStart = (n - 1) * BLOCK_SIZE;\n        const lastBlockData = buffer.subarray(lastBlockStart);\n        let m_last;\n        if (flag) {\n            // M_last := M_n XOR K1;\n            m_last = xorBlock(new Uint8Array(lastBlockData), this.k1);\n        }\n        else {\n            // M_last := padding(M_n) XOR K2;\n            //\n            // [...] padding(x) is the concatenation of x and a single '1',\n            // followed by the minimum number of '0's, so that the total length is\n            // equal to 128 bits.\n            const padded = new Uint8Array(BLOCK_SIZE);\n            padded.set(lastBlockData);\n            padded[lastBlockData.length] = 0x80; // single '1' bit\n            m_last = xorBlock(padded, this.k2);\n        }\n        // Step 5:\n        let x = new Uint8Array(BLOCK_SIZE); // X := const_Zero;\n        // Step 6:\n        for (let i = 0; i < n - 1; i++) {\n            const m_i = buffer.subarray(i * BLOCK_SIZE, (i + 1) * BLOCK_SIZE); // M_i\n            xorBlock(x, m_i); // Y := X XOR M_i;\n            encryptBlock(this.xk, x); // X := AES-128(K,Y);\n        }\n        // Step 7:\n        xorBlock(x, m_last); // Y := M_last XOR X;\n        encryptBlock(this.xk, x); // T := AES-128(K,Y);\n        // cleanup:\n        clean(m_last);\n        return x; // T\n    }\n    destroy() {\n        const { buffer, destroyed, xk, k1, k2 } = this;\n        if (destroyed)\n            return;\n        this.destroyed = true;\n        clean(buffer, xk, k1, k2);\n    }\n}\n/**\n * AES-CMAC (Cipher-based Message Authentication Code).\n * Specs: [RFC 4493](https://www.rfc-editor.org/rfc/rfc4493.html).\n */\nexport const cmac = (key, message) => new _CMAC(key).update(message).digest();\ncmac.create = (key) => new _CMAC(key);\n/**\n * S2V (Synthetic Initialization Vector) function as described in [RFC 5297 Section 2.4](https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.4).\n *\n * ```\n * S2V(K, S1, ..., Sn) {\n *   if n = 0 then\n *     return V = AES-CMAC(K, <one>)\n *   fi\n *   D = AES-CMAC(K, <zero>)\n *   for i = 1 to n-1 do\n *     D = dbl(D) xor AES-CMAC(K, Si)\n *   done\n *   if len(Sn) >= 128 then\n *     T = Sn xorend D\n *   else\n *     T = dbl(D) xor pad(Sn)\n *   fi\n *   return V = AES-CMAC(K, T)\n * }\n * ```\n *\n * S2V takes a key and a vector of strings S1, S2, ..., Sn and returns a 128-bit string.\n * The S2V function is used to generate a synthetic IV for AES-SIV.\n *\n * @param key - AES key (128, 192, or 256 bits)\n * @param strings - Array of byte arrays to process\n * @returns 128-bit synthetic IV\n */\nfunction s2v(key, strings) {\n    validateKeyLength(key);\n    const len = strings.length;\n    if (len > 127) {\n        // see https://datatracker.ietf.org/doc/html/rfc5297.html#section-7\n        throw new Error('s2v: number of input strings must be less than or equal to 127');\n    }\n    if (len === 0)\n        return cmac(key, ONE_BLOCK);\n    // D = AES-CMAC(K, <zero>)\n    let d = cmac(key, EMPTY_BLOCK);\n    // for i = 1 to n-1 do\n    //   D = dbl(D) xor AES-CMAC(K, Si)\n    for (let i = 0; i < len - 1; i++) {\n        dbl(d);\n        const cmacResult = cmac(key, strings[i]);\n        xorBlock(d, cmacResult);\n        clean(cmacResult);\n    }\n    const s_n = strings[len - 1];\n    let t;\n    // if len(Sn) >= 128 then\n    if (s_n.byteLength >= BLOCK_SIZE) {\n        // T = Sn xorend D\n        t = xorend(Uint8Array.from(s_n), d);\n    }\n    else {\n        // pad(Sn):\n        const paddedSn = new Uint8Array(BLOCK_SIZE);\n        paddedSn.set(s_n);\n        paddedSn[s_n.length] = 0x80; // padding: 0x80 followed by zeros\n        // T = dbl(D) xor pad(Sn)\n        t = xorBlock(dbl(d), paddedSn);\n        clean(paddedSn);\n    }\n    // V = AES-CMAC(K, T)\n    const result = cmac(key, t);\n    clean(d, t);\n    return result;\n}\n/** Use `gcmsiv` or `aessiv`. */\nexport const siv = () => {\n    throw new Error('\"siv\" from v1 is now \"gcmsiv\"');\n};\n/**\n * **SIV**: Synthetic Initialization Vector (SIV) Authenticated Encryption\n * Nonce is derived from the plaintext and AAD using the S2V function.\n * See [RFC 5297](https://datatracker.ietf.org/doc/html/rfc5297.html).\n */\nexport const aessiv = /* @__PURE__ */ wrapCipher({ blockSize: 16, tagLength: 16 }, function aessiv(key, ...AAD) {\n    // From RFC 5297: Section 6.1, 6.2, 6.3:\n    const PLAIN_LIMIT = limit('plaintext', 0, 2 ** 132);\n    const CIPHER_LIMIT = limit('ciphertext', 16, 2 ** 132 + 16);\n    if (AAD.length > 126) {\n        // see https://datatracker.ietf.org/doc/html/rfc5297.html#section-7\n        throw new Error('\"AAD\" number of elements must be less than or equal to 126');\n    }\n    AAD.forEach((aad) => abytes(aad));\n    abytes(key);\n    if (![32, 48, 64].includes(key.length))\n        throw new Error('\"aes key\" expected Uint8Array of length 32/48/64, got length=' + key.length);\n    // The key is split into equal halves, K1 = leftmost(K, len(K)/2) and\n    // K2 = rightmost(K, len(K)/2).  K1 is used for S2V and K2 is used for CTR.\n    const k1 = key.subarray(0, key.length / 2);\n    const k2 = key.subarray(key.length / 2);\n    return {\n        // https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.6\n        encrypt(plaintext) {\n            PLAIN_LIMIT(plaintext.length);\n            const v = s2v(k1, [...AAD, plaintext]);\n            // clear out the 31st and 63rd (rightmost) bit:\n            const q = Uint8Array.from(v);\n            q[8] &= 0x7f;\n            q[12] &= 0x7f;\n            // encrypt:\n            const c = ctr(k2, q).encrypt(plaintext);\n            return concatBytes(v, c);\n        },\n        // https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.7\n        decrypt(ciphertext) {\n            CIPHER_LIMIT(ciphertext.length);\n            const v = ciphertext.subarray(0, BLOCK_SIZE);\n            const c = ciphertext.subarray(BLOCK_SIZE);\n            // clear out the 31st and 63rd (rightmost) bit:\n            const q = Uint8Array.from(v);\n            q[8] &= 0x7f;\n            q[12] &= 0x7f;\n            // decrypt:\n            const p = ctr(k2, q).decrypt(c);\n            // verify tag:\n            const t = s2v(k1, [...AAD, p]);\n            if (equalBytes(t, v)) {\n                return p;\n            }\n            else {\n                throw new Error('invalid siv tag');\n            }\n        },\n    };\n});\n//#endregion\n/** Unsafe low-level internal methods. May change at any time. */\nexport const unsafe = {\n    expandKeyLE,\n    expandKeyDecLE,\n    encrypt,\n    decrypt,\n    encryptBlock,\n    decryptBlock,\n    ctrCounter,\n    ctr32,\n    dbl,\n    xorBlock,\n    xorend,\n    s2v,\n};\n//# sourceMappingURL=aes.js.map","import { ByteBuffer } from './ByteBuffer';\nimport { cbc as AESCBC } from '@noble/ciphers/aes.js';\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport { sha256, sha512 } from '@noble/hashes/sha2.js';\nexport const encrypt = (privateKey, publicKey, message, nonce = uniqueNonce()) => crypt(privateKey, publicKey, nonce, message);\nexport const decrypt = (privateKey, publicKey, nonce, message, checksum) => {\n    const d = crypt(privateKey, publicKey, nonce, message, checksum);\n    return d.message;\n};\n/**\n * @arg message - Encrypted or plain text message (see checksum)\n * @arg checksum - shared secret checksum (null to encrypt, non-null to decrypt)\n */\nconst crypt = (privateKey, publicKey, nonce, message, checksum) => {\n    const nonceL = typeof nonce === 'bigint' ? nonce : BigInt(nonce);\n    const S = privateKey.getSharedSecret(publicKey);\n    let ebuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    ebuf.writeUint64(nonceL);\n    ebuf.append(S);\n    ebuf.flip();\n    const encryptionKey = sha512(new Uint8Array(ebuf.toBuffer()));\n    const iv = encryptionKey.subarray(32, 48);\n    const tag = encryptionKey.subarray(0, 32);\n    // check if first 64 bit of sha256 hash treated as uint64_t truncated to 32 bits.\n    const check = sha256(encryptionKey).subarray(0, 4);\n    const cbuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    cbuf.append(check);\n    cbuf.flip();\n    const check32 = cbuf.readUint32();\n    if (checksum) {\n        if (check32 !== checksum) {\n            throw new Error('Invalid key');\n        }\n        message = cryptoJsDecrypt(message, tag, iv);\n    }\n    else {\n        message = cryptoJsEncrypt(message, tag, iv);\n    }\n    return { nonce: nonceL, message, checksum: check32 };\n};\n/**\n * This method does not use a checksum, the returned data must be validated some other way.\n * @arg {string|Uint8Array} ciphertext - binary format\n * @return {Uint8Array} the decrypted message\n */\nconst cryptoJsDecrypt = (message, tag, iv) => {\n    let messageBuffer = message;\n    const decipher = AESCBC(tag, iv);\n    messageBuffer = decipher.decrypt(messageBuffer);\n    // return Uint8Array.from(messageBuffer)\n    return messageBuffer;\n};\n/**\n * This method does not use a checksum, the returned data must be validated some other way.\n * @arg {string|Uint8Array} plaintext - binary format\n * @return {Uint8Array} binary\n */\nexport const cryptoJsEncrypt = (message, tag, iv) => {\n    let messageBuffer = message;\n    const cipher = AESCBC(tag, iv);\n    messageBuffer = cipher.encrypt(messageBuffer);\n    // return Uint8Array.from(messageBuffer)\n    return messageBuffer;\n};\n/** @return {string} unique 64 bit unsigned number string.  Being time based,\n * this is careful to never choose the same nonce twice.  This value could\n * clsbe recorded in the blockchain for a long time.\n */\nlet uniqueNonceEntropy = null;\nconst uniqueNonce = () => {\n    if (uniqueNonceEntropy === null) {\n        const randomPrivateKey = secp256k1.utils.randomSecretKey();\n        uniqueNonceEntropy = Math.round((randomPrivateKey[0] << 8) | randomPrivateKey[1]);\n    }\n    let long = BigInt(Date.now());\n    const entropy = ++uniqueNonceEntropy % 0xffff;\n    long = (long << BigInt(16)) | BigInt(entropy);\n    return long;\n};\n// const toLongObj = (o) => (o ? (Long.isLong(o) ? o : Long.fromString(o)) : o)\n","import { ByteBuffer } from './ByteBuffer';\nimport { PublicKey } from './PublicKey';\nconst PublicKeyDeserializer = (buf) => {\n    const c = fixedBuf(buf, 33);\n    return new PublicKey(c);\n};\nconst UInt64Deserializer = (b) => {\n    return b.readUint64();\n};\nconst UInt32Deserializer = (b) => {\n    return b.readUint32();\n};\nconst BinaryDeserializer = (b) => {\n    const len = b.readVarint32();\n    const bCopy = b.copy(b.offset, b.offset + len);\n    b.skip(len);\n    return new Uint8Array(bCopy.toBuffer());\n};\nconst BufferDeserializer = (keyDeserializers) => (buf) => {\n    const obj = {};\n    const buffer = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    buffer.append(buf);\n    buffer.flip();\n    for (const [key, deserializer] of keyDeserializers) {\n        try {\n            obj[key] = deserializer(buffer);\n        }\n        catch (error) {\n            error.message = `${key}: ${error.message}`;\n            throw error;\n        }\n    }\n    return obj;\n};\nfunction fixedBuf(b, len) {\n    if (!b) {\n        throw Error('No buffer found on first parameter');\n    }\n    else {\n        const bCopy = b.copy(b.offset, b.offset + len);\n        b.skip(len);\n        return new Uint8Array(bCopy.toBuffer());\n    }\n}\nconst EncryptedMemoDeserializer = BufferDeserializer([\n    ['from', PublicKeyDeserializer],\n    ['to', PublicKeyDeserializer],\n    ['nonce', UInt64Deserializer],\n    ['check', UInt32Deserializer],\n    ['encrypted', BinaryDeserializer]\n]);\nexport const Deserializer = {\n    Memo: EncryptedMemoDeserializer\n};\n","import bs58 from 'bs58';\nimport { ByteBuffer } from './ByteBuffer';\nimport { Serializer } from './serializer';\nimport { PrivateKey } from './PrivateKey';\nimport * as Aes from './aes';\nimport { PublicKey } from './PublicKey';\nimport { Deserializer } from './deserializer';\n/**\n * Encodes a memo using AES encryption for secure private messaging on Hive.\n * Messages must start with '#' to be encrypted. Plain text messages are returned unchanged.\n *\n * @param privateKey - Sender's private memo key (string WIF format or PrivateKey instance)\n * @param publicKey - Recipient's public memo key (string or PublicKey instance)\n * @param memo - Message to encrypt (must start with '#' for encryption)\n * @param testNonce - Optional nonce for testing (advanced usage)\n * @returns Encrypted memo string prefixed with '#'\n * @throws Error if encryption is not supported in current environment\n */\nconst encode = (privateKey, publicKey, memo, testNonce) => {\n    if (!memo.startsWith('#')) {\n        return memo;\n    }\n    memo = memo.substring(1);\n    checkEncryption();\n    privateKey = toPrivateObj(privateKey);\n    publicKey = toPublicObj(publicKey);\n    const mbuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    mbuf.writeVString(memo);\n    const memoBuffer = new Uint8Array(mbuf.copy(0, mbuf.offset).toBuffer());\n    const { nonce, message, checksum } = Aes.encrypt(privateKey, publicKey, memoBuffer, testNonce);\n    const mbuf2 = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    Serializer.Memo(mbuf2, {\n        check: checksum,\n        encrypted: message,\n        from: privateKey.createPublic(),\n        nonce,\n        to: publicKey\n    });\n    mbuf2.flip();\n    const data = new Uint8Array(mbuf2.toBuffer());\n    return '#' + bs58.encode(data);\n};\n/**\n * Decrypts an encrypted memo using AES decryption.\n * Messages must start with '#' to be decrypted. Plain text messages are returned unchanged.\n *\n * @param privateKey - Recipient's private memo key (string WIF format or PrivateKey instance)\n * @param memo - Encrypted memo string (must start with '#' for decryption)\n * @returns Decrypted memo content with '#' prefix\n * @throws Error if decryption fails or encryption not supported in current environment\n */\nconst decode = (privateKey, memo) => {\n    if (!memo.startsWith('#')) {\n        return memo;\n    }\n    memo = memo.substring(1);\n    checkEncryption();\n    privateKey = toPrivateObj(privateKey);\n    // memo = bs58.decode(memo)\n    let memoBuffer = Deserializer.Memo(bs58.decode(memo));\n    const { from, to, nonce, check, encrypted } = memoBuffer;\n    const pubkey = privateKey.createPublic().toString();\n    const otherpub = pubkey === new PublicKey(from.key).toString() ? new PublicKey(to.key) : new PublicKey(from.key);\n    memoBuffer = Aes.decrypt(privateKey, otherpub, nonce, encrypted, check);\n    const mbuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    mbuf.append(memoBuffer);\n    mbuf.flip();\n    return '#' + mbuf.readVString();\n};\nlet encodeTest;\nconst checkEncryption = () => {\n    if (encodeTest === undefined) {\n        let plaintext;\n        encodeTest = true; // prevent infinate looping\n        try {\n            const wif = '5JdeC9P7Pbd1uGdFVEsJ41EkEnADbbHGq6p1BwFxm6txNBsQnsw';\n            const pubkey = 'STM8m5UgaFAAYQRuaNejYdS8FVLVp9Ss3K1qAVk5de6F8s3HnVbvA';\n            const cyphertext = encode(wif, pubkey, '#memo爱');\n            plaintext = decode(wif, cyphertext);\n        }\n        finally {\n            encodeTest = plaintext === '#memo爱';\n        }\n    }\n    if (encodeTest === false) {\n        throw new Error('This environment does not support encryption.');\n    }\n};\nconst toPrivateObj = (o) => {\n    if (typeof o === 'string') {\n        return PrivateKey.fromString(o);\n    }\n    else {\n        return o;\n    }\n};\nconst toPublicObj = (o) => {\n    if (typeof o === 'string') {\n        return PublicKey.fromString(o);\n    }\n    else {\n        return o;\n    }\n};\n/**\n * Memo utilities for encrypting and decrypting private messages between Hive users.\n * Uses AES encryption with ECDH key exchange for secure communication.\n *\n * Messages must start with '#' to be encrypted/decrypted.\n * Plain text messages (without '#') are returned unchanged.\n *\n * @example\n * ```typescript\n * import { Memo, PrivateKey, PublicKey } from 'hive-tx'\n *\n * // Encrypt a message\n * const encrypted = Memo.encode(senderPrivateKey, recipientPublicKey, '#Hello World')\n *\n * // Decrypt a message\n * const decrypted = Memo.decode(recipientPrivateKey, encrypted)\n * console.log(decrypted) // '#Hello World'\n * ```\n */\nexport const Memo = {\n    decode,\n    encode\n};\n","import { Serializer } from './serializer';\nimport { ByteBuffer } from './ByteBuffer';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n/** Return null for a valid username */\nexport const validateUsername = (username) => {\n    let suffix = 'Account name should ';\n    if (!username) {\n        return suffix + 'not be empty.';\n    }\n    const length = username.length;\n    if (length < 3) {\n        return suffix + 'be longer.';\n    }\n    if (length > 16) {\n        return suffix + 'be shorter.';\n    }\n    if (/\\./.test(username)) {\n        suffix = 'Each account segment should ';\n    }\n    const ref = username.split('.');\n    const len = ref.length;\n    for (let i = 0; i < len; i++) {\n        const label = ref[i];\n        if (!/^[a-z]/.test(label)) {\n            return suffix + 'start with a lowercase letter.';\n        }\n        if (!/^[a-z0-9-]*$/.test(label)) {\n            return suffix + 'have only lowercase letters, digits, or dashes.';\n        }\n        if (!/[a-z0-9]$/.test(label)) {\n            return suffix + 'end with a lowercase letter or digit.';\n        }\n        if (!(label.length >= 3)) {\n            return suffix + 'be longer';\n        }\n    }\n    return null;\n};\nexport const operations = {\n    vote: 0,\n    comment: 1,\n    transfer: 2,\n    transfer_to_vesting: 3,\n    withdraw_vesting: 4,\n    limit_order_create: 5,\n    limit_order_cancel: 6,\n    feed_publish: 7,\n    convert: 8,\n    account_create: 9,\n    account_update: 10,\n    witness_update: 11,\n    account_witness_vote: 12,\n    account_witness_proxy: 13,\n    pow: 14,\n    custom: 15,\n    report_over_production: 16,\n    delete_comment: 17,\n    custom_json: 18,\n    comment_options: 19,\n    set_withdraw_vesting_route: 20,\n    limit_order_create2: 21,\n    claim_account: 22,\n    create_claimed_account: 23,\n    request_account_recovery: 24,\n    recover_account: 25,\n    change_recovery_account: 26,\n    escrow_transfer: 27,\n    escrow_dispute: 28,\n    escrow_release: 29,\n    pow2: 30,\n    escrow_approve: 31,\n    transfer_to_savings: 32,\n    transfer_from_savings: 33,\n    cancel_transfer_from_savings: 34,\n    custom_binary: 35,\n    decline_voting_rights: 36,\n    reset_account: 37,\n    set_reset_account: 38,\n    claim_reward_balance: 39,\n    delegate_vesting_shares: 40,\n    account_create_with_delegation: 41,\n    witness_set_properties: 42,\n    account_update2: 43,\n    create_proposal: 44,\n    update_proposal_votes: 45,\n    remove_proposal: 46,\n    update_proposal: 47,\n    collateralized_convert: 48,\n    recurrent_transfer: 49,\n    // virtual ops\n    fill_convert_request: 50,\n    author_reward: 51,\n    curation_reward: 52,\n    comment_reward: 53,\n    liquidity_reward: 54,\n    interest: 55,\n    fill_vesting_withdraw: 56,\n    fill_order: 57,\n    shutdown_witness: 58,\n    fill_transfer_from_savings: 59,\n    hardfork: 60,\n    comment_payout_update: 61,\n    return_vesting_delegation: 62,\n    comment_benefactor_reward: 63,\n    producer_reward: 64,\n    clear_null_account_balance: 65,\n    proposal_pay: 66,\n    sps_fund: 67,\n    hardfork_hive: 68,\n    hardfork_hive_restore: 69,\n    delayed_voting: 70,\n    consolidate_treasury_balance: 71,\n    effective_comment_vote: 72,\n    ineffective_delete_comment: 73,\n    sps_convert: 74,\n    expired_account_notification: 75,\n    changed_recovery_account: 76,\n    transfer_to_vesting_completed: 77,\n    pow_reward: 78,\n    vesting_shares_split: 79,\n    account_created: 80,\n    fill_collateralized_convert_request: 81,\n    system_warning: 82,\n    fill_recurrent_transfer: 83,\n    failed_recurrent_transfer: 84,\n    limit_order_cancelled: 85,\n    producer_missed: 86,\n    proposal_fee: 87,\n    collateralized_convert_immediate_conversion: 88,\n    escrow_approved: 89,\n    escrow_rejected: 90,\n    proxy_cleared: 91,\n    declined_voting_rights: 92\n};\n/**\n * Make bitmask filter to be used with get_account_history call\n */\nexport const makeBitMaskFilter = (allowedOperations) => {\n    return allowedOperations\n        .reduce(reduceFunction, [BigInt(0), BigInt(0)])\n        .map((value) => (value !== BigInt(0) ? value.toString() : null));\n};\nconst reduceFunction = ([low, high], allowedOperation) => {\n    if (allowedOperation < 64) {\n        return [low | (BigInt(1) << BigInt(allowedOperation)), high];\n    }\n    else {\n        return [low, high | (BigInt(1) << BigInt(allowedOperation - 64))];\n    }\n};\nexport const buildWitnessSetProperties = (owner, props) => {\n    const data = {\n        extensions: [],\n        owner,\n        props: []\n    };\n    for (const key of Object.keys(props)) {\n        let type;\n        switch (key) {\n            case 'key':\n            case 'new_signing_key':\n                type = Serializer.PublicKey;\n                break;\n            case 'account_subsidy_budget':\n            case 'account_subsidy_decay':\n            case 'maximum_block_size':\n                type = Serializer.UInt32;\n                break;\n            case 'hbd_interest_rate':\n                type = Serializer.UInt16;\n                break;\n            case 'url':\n                type = Serializer.String;\n                break;\n            case 'hbd_exchange_rate':\n                type = Serializer.Price;\n                break;\n            case 'account_creation_fee':\n                type = Serializer.Asset;\n                break;\n            default:\n                throw new Error(`Unknown witness prop: ${key}`);\n        }\n        data.props.push([key, serialize(type, props[key])]);\n    }\n    data.props.sort((a, b) => a[0].localeCompare(b[0]));\n    return ['witness_set_properties', data];\n};\nconst serialize = (serializer, data) => {\n    const buffer = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    serializer(buffer, data);\n    buffer.flip();\n    // `props` values must be hex\n    return bytesToHex(new Uint8Array(buffer.toBuffer()));\n};\n"],"names":["root","factory","exports","module","define","amd","self","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","isBytes","a","Uint8Array","ArrayBuffer","isView","constructor","name","anumber","n","title","Number","isSafeInteger","Error","abytes","length","bytes","len","needsLen","undefined","ahash","h","create","outputLen","blockLen","aexists","instance","checkFinished","destroyed","finished","clean","arrays","i","fill","createView","arr","DataView","buffer","byteOffset","byteLength","rotr","word","shift","rotl","hasHexBuiltin","from","toHex","fromHex","hexes","Array","_","toString","padStart","bytesToHex","hex","asciiToBase16","ch","hexToBytes","hl","al","array","ai","hi","n1","charCodeAt","n2","concatBytes","sum","res","pad","set","createHasher","hashCons","info","hashC","msg","opts","update","digest","tmp","assign","freeze","bytesLength","cr","globalThis","crypto","getRandomValues","oidNist","suffix","oid","EMPTY_BUFFER","textEncoder","TextEncoder","textDecoder","TextDecoder","ByteBuffer","capacity","DEFAULT_CAPACITY","littleEndian","DEFAULT_ENDIAN","this","readUInt32","readUint32","view","offset","markedOffset","limit","allocate","concat","buffers","buf","isArray","TypeError","bb","wrap","clone","writeBytes","source","append","writeInt8","relative","resize","setInt8","writeByte","writeUint8","setUint8","writeUInt8","readUint8","getUint8","readUInt8","writeInt16","setInt16","writeShort","writeUint16","setUint16","writeUInt16","writeInt32","setInt32","writeInt","writeUint32","setUint32","writeUInt32","getUint32","src","copy","begin","end","subarray","copyTo","target","targetOffset","sourceOffset","sourceLimit","targetRelative","ensureCapacity","current","flip","skip","writeInt64","BigInt","setBigInt64","writeLong","readInt64","getBigInt64","readLong","writeUint64","setBigUint64","writeUInt64","readUint64","getBigUint64","readUInt64","toBuffer","forceCopy","slice","toArrayBuffer","writeVarint32","size","calculateVarint32","readVarint32","b","c","writeVString","str","currentOffset","encoded","encode","lenVarintSize","readVString","start","lenResult","lenValue","decode","string","readUTF8String","Chi","Maj","LITTLE_ENDIAN","BIG_ENDIAN","HashMD","padOffset","isLE","pos","data","take","Math","min","dataView","process","roundClean","digestInto","out","aoutput","oview","outLen","state","destroy","_cloneInto","to","SHA256_IV","Uint32Array","SHA512_IV","Rho160","Id160","map","Pi160","idxLR","j","push","k","idxL","idxR","shifts160","shiftsL160","idx","shiftsR160","Kl160","Kr160","ripemd_f","group","x","y","z","BUF_160","_RIPEMD160","h0","h1","h2","h3","h4","super","ar","bl","br","cl","dl","dr","el","er","rGroup","hbl","hbr","rl","rr","sl","sr","tl","tr","ripemd160","ALPHABET","BASE_MAP","charAt","xc","decodeUnsafe","psz","zeroes","b256","charCode","carry","it3","it4","vch","pbegin","pend","b58","it1","it2","repeat","config","nodes","restNodes","chain_id","address_prefix","timeout","retry","U32_MASK64","_32n","fromBig","le","l","shrSH","_l","s","shrSL","rotrSH","rotrSL","rotrBH","rotrBL","add","Ah","Al","Bh","Bl","add3L","Cl","add3H","low","Ch","add4L","Dl","add4H","Dh","add5L","El","add5H","Eh","SHA256_K","SHA256_W","SHA2_32B","A","B","C","D","E","F","G","H","W15","W2","s0","s1","T1","T2","_SHA256","K512","lst","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA2_64B","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","s0l","W2h","W2l","s1h","s1l","SUMl","SUMh","sigma1h","sigma1l","CHIh","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","All","_SHA512","sha256","sha512","_0n","_1n","abool","abignumber","isPosBig","numberToHexUnpadded","num","hexToNumber","bytesToNumberBE","bytesToNumberLE","copyBytes","reverse","numberToBytesBE","numberToBytesLE","bitMask","validateObject","object","fields","optFields","iter","f","isOpt","entries","forEach","v","fieldName","expectedType","val","checkField","memoized","fn","WeakMap","arg","args","computed","_2n","_3n","_4n","_5n","_7n","_8n","_9n","_16n","mod","result","pow2","power","modulo","invert","number","u","q","r","m","assertIsSquare","Fp","eql","sqr","sqrt3mod4","pow","ORDER","sqrt5mod8","p5div8","mul","nv","sub","ONE","tonelliShanks","P","Q","S","Z","_Fp","Field","FpLegendre","cc","Q1div2","is0","M","t","R","ZERO","t_tmp","exponent","FIELD_FIELDS","FpInvertBatch","nums","passZero","inverted","multipliedAcc","reduce","acc","invertedAcc","inv","reduceRight","powered","yes","zero","no","neg","_Field","BITS","BYTES","_lengths","_sqrt","_mod","_nbitLength","sqrt","allowedLengths","modFromBytes","nBitLength","nByteLength","_nBitLength","ceil","nLength","preventExtensions","isValid","isValidNot0","isOdd","lhs","rhs","p","d","FpPow","div","sqrN","addN","subN","mulN","Fp_","tn","c1","c2","c3","c4","tv1","tv2","tv3","tv4","e1","e2","cmov","e3","sqrt9mod16","toBytes","fromBytes","skipValidation","includes","padded","scalar","invertBatch","condition","getFieldBytesLength","fieldOrder","getMinHashLength","negateCt","item","negate","normalizeZ","points","invertedZs","fromAffine","toAffine","validateW","W","bits","calcWOpts","scalarBits","maxNumber","windows","windowSize","mask","shiftBy","calcOffsets","window","wOpts","wbits","nextN","offsetStart","abs","isZero","isNeg","isNegF","offsetF","pointPrecomputes","pointWindowSizes","getW","assert0","wNAF","BASE","Fn","Point","_unsafeLadder","elm","double","precomputeWindow","point","base","precomputes","wo","wNAFUnsafe","getPrecomputes","transform","comp","cached","unsafe","prev","createCache","delete","hasCache","createField","order","field","validateField","ascii","_HMAC","oHash","iHash","hash","getPrototypeOf","message","divNearest","den","validateSigFormat","format","validateSigOpts","def","optsn","optName","keys","lowS","prehash","DER","Err","_tlv","tag","dataLen","lenLen","first","lengthBytes","_int","parseInt","toSig","int","tlv","seqBytes","seqLeftBytes","rBytes","rLeftBytes","sBytes","sLeftBytes","hexFromSig","sig","rs","ss","weierstrass","params","extraOpts","validated","type","CURVE","curveOpts","FpFnLE","createCurveFields","cofactor","CURVE_ORDER","allowInfinityPoint","clearCofactor","isTorsionFree","endo","beta","basises","lengths","getWLengths","assertCompressionIsSupported","encodePoint","_c","isCompressed","bx","pprefix","of","decodePoint","publicKey","publicKeyUncompressed","uncomp","head","tail","L","isValidXY","y2","weierstrassEquation","sqrtError","x2","x3","left","right","Gx","Gy","_4a3","_27b2","acoord","banZero","aprjpoint","other","splitEndoScalarN","basis","a1","b1","a2","b2","k1","k2","k1neg","k2neg","MAX_NUM","bitLen","_splitEndoScalar","toAffineMemo","iz","X","Y","zz","assertValidMemo","finishEndo","endoBeta","k1p","k2p","static","assertValidity","precompute","isLazy","wnaf","multiply","hasEvenY","equals","X1","Y1","Z1","X2","Y2","Z2","U1","U2","b3","X3","Y3","Z3","t0","t1","t2","t3","t4","t5","subtract","fake","k1f","k2f","multiplyUnsafe","sc","p1","p2","mulEndoUnsafe","invertedZ","isSmallOrder","secretKey","publicKeyHasPrefix","signature","ecdsa","ecdsaOpts","hmac","randomBytes","bits2int","bits2int_modN","fnBits","keygen","getPublicKey","getSharedSecret","utils","ecdhOpts","randomBytes_","seed","randomSecretKey","fieldLen","minLen","reduced","mapHashToField","isProbPub","isValidSecretKey","error","isValidPublicKey","createKeygen","secretKeyA","publicKeyB","ecdh","defaultSigOpts","extraEntropy","hasLargeCofactor","isBiggerThanHalfOrder","validateRS","assertSmallCofactor","validateSigLength","Signature","recovery","recid","assertRecovery","addRecoveryBit","recoverPublicKey","messageHash","radj","ir","u1","u2","hasHighS","rb","sb","delta","ORDER_MASK","int2octets","max","inRange","aInRange","validateMsgAndHash","sign","k2sig","h1int","seedArgs","e","kBytes","ik","normS","prepSig","hashLen","qByteLen","hmacFn","u8n","NULL","byte0","byte1","reset","msgs","reseed","gen","pred","createHmacDrbg","drbg","verify","is","secp256k1_CURVE","secp256k1_ENDO","Fpk1","sqrtMod","_6n","_11n","_22n","_23n","_44n","_88n","b6","b9","b11","b22","b44","b88","b176","b220","b223","secp256k1","compressed","temp","customToString","PublicKey","DEFAULT_ADDRESS_PREFIX","prefix","fromString","wif","decodePublic","encodePublic","toJSON","inspect","checksum","encodedKey","Asset","amount","symbol","expectedSymbol","amountString","split","indexOf","parseFloat","isFinite","String","getPrecision","toFixed","HexBuffer","VoidSerializer","StringSerializer","Int64Serializer","UInt8Serializer","UInt16Serializer","UInt32Serializer","UInt64Serializer","BooleanSerializer","StaticVariantSerializer","itemSerializers","id","AssetSerializer","asset","precision","round","DateSerializer","floor","Date","getTime","PublicKeySerializer","BinarySerializer","VariableBinarySerializer","FlatMapSerializer","keySerializer","valueSerializer","ArraySerializer","itemSerializer","ObjectSerializer","keySerializers","serializer","OptionalSerializer","AuthoritySerializer","BeneficiarySerializer","PriceSerializer","ChainPropertiesSerializer","OperationDataSerializer","operationId","definitions","objectSerializer","OperationSerializers","account_create","account_create_with_delegation","account_update","account_witness_proxy","account_witness_vote","cancel_transfer_from_savings","change_recovery_account","claim_account","claim_reward_balance","comment","comment_options","convert","create_claimed_account","custom","custom_json","decline_voting_rights","delegate_vesting_shares","delete_comment","escrow_approve","escrow_dispute","escrow_release","escrow_transfer","feed_publish","limit_order_cancel","limit_order_create","limit_order_create2","recover_account","request_account_recovery","reset_account","set_reset_account","set_withdraw_vesting_route","transfer","transfer_from_savings","transfer_to_savings","transfer_to_vesting","vote","withdraw_vesting","witness_update","witness_set_properties","account_update2","create_proposal","update_proposal_votes","remove_proposal","ProposalUpdateSerializer","update_proposal","collateralized_convert","recurrent_transfer","TransactionSerializer","operation","Serializer","Memo","Price","Transaction","UInt16","UInt32","sleep","ms","Promise","resolve","setTimeout","RPCError","rpcError","stack","code","NodeError","node","rateLimitMs","PRE_CONNECTION_ERRORS","isPreConnectionError","parts","cause","depth","combined","join","some","NodeHealthTracker","health","Map","getOrCreate","consecutiveFailures","lastFailureTime","rateLimitedUntil","recordSuccess","recordFailure","now","recordRateLimit","retryAfterMs","isNodeHealthy","getOrderedNodes","healthy","unhealthy","rpcHealthTracker","restHealthTracker","recordError","tracker","jsonRPCCall","async","url","method","shouldRetry","random","body","jsonrpc","fetch","JSON","stringify","headers","signal","AbortSignal","status","retryAfter","json","jitterDelay","callRPC","triedInRound","Set","lastError","attempt","orderedNodes","find","has","clear","callRPCBroadcast","triedNodes","apiMethods","balance","hafah","hafbe","hivemind","hivesense","reputation","hafsql","callREST","api","endpoint","alreadyRecorded","baseUrl","path","paramObj","processedPathParams","replace","encodeURIComponent","URL","searchParams","response","callWithQuorum","quorum","allNodes","sort","currentBatchSize","allResults","batchNodes","splice","promises","batchResults","then","catch","all","consensusResult","findConsensus","results","resultGroups","consensusGroup","values","chainId","options","expiration","createTransaction","props","head_block_id","refBlockPrefix","expirationIso","toISOString","transaction","extensions","operations","ref_block_num","head_block_number","ref_block_prefix","signatures","txId","addOperation","operationName","operationBody","broadcast","checkStatus","tx_id","transactionData","addSignature","transaction_id","NETWORK_ID","PrivateKey","decodePrivate","fromSeed","test","fromLogin","username","password","role","rv","createPublic","encodePrivate","randomKey","doubleSha256","input","isUint8ArrayEqual","checksumVerify","complexOverlapBytes","output","wrapCipher","wrappedCipher","nonceLength","varSizeNonce","tagl","tagLength","cipher","checkOutput","fnLength","called","encrypt","decrypt","getOutput","expectedLength","onlyAligned","isAligned32","BLOCK_SIZE","ZEROS16","ZEROS32","mul2","s2","s3","swapLE","GHASH","kView","k0","k3","doubles","items","w","byte","d0","d1","d2","d3","_updateBlock","o0","o1","o2","o3","bytePos","bitPos","bit","e0","b32","blocks","o32","Polyval","ghKey","hiBit","_toGHASHKey","wrapConstructorWithKey","sbox","box","invSbox","rotr32_8","rotl32_8","genTtable","T0","T3","T01","T23","sbox2","Uint16Array","tableEncoding","tableDecoding","xPowers","expandKeyLE","validateKeyLength","toClean","k32","Nk","subByte","applySbox","xk","apply0123","rounds","cbc","blockSize","iv","pcks5","disablePadding","plaintext","dst","_out","remaining","validateBlockEncrypt","_iv","n32","tmp32","paddingByte","padPCKS","ciphertext","validateBlockDecrypt","encKey","expandKeyDecLE","ps0","ps1","ps2","ps3","lastByte","validatePCKS","crypt","privateKey","nonce","nonceL","ebuf","encryptionKey","check","cbuf","check32","cryptoJsDecrypt","cryptoJsEncrypt","messageBuffer","uniqueNonceEntropy","PublicKeyDeserializer","bCopy","fixedBuf","keyDeserializers","Deserializer","deserializer","memo","testNonce","startsWith","substring","checkEncryption","toPrivateObj","toPublicObj","mbuf","memoBuffer","randomPrivateKey","long","entropy","uniqueNonce","mbuf2","encrypted","pubkey","encodeTest","cyphertext","validateUsername","ref","label","report_over_production","custom_binary","fill_convert_request","author_reward","curation_reward","comment_reward","liquidity_reward","interest","fill_vesting_withdraw","fill_order","shutdown_witness","fill_transfer_from_savings","hardfork","comment_payout_update","return_vesting_delegation","comment_benefactor_reward","producer_reward","clear_null_account_balance","proposal_pay","sps_fund","hardfork_hive","hardfork_hive_restore","delayed_voting","consolidate_treasury_balance","effective_comment_vote","ineffective_delete_comment","sps_convert","expired_account_notification","changed_recovery_account","transfer_to_vesting_completed","pow_reward","vesting_shares_split","account_created","fill_collateralized_convert_request","system_warning","fill_recurrent_transfer","failed_recurrent_transfer","limit_order_cancelled","producer_missed","proposal_fee","collateralized_convert_immediate_conversion","escrow_approved","escrow_rejected","proxy_cleared","declined_voting_rights","makeBitMaskFilter","allowedOperations","reduceFunction","high","allowedOperation","buildWitnessSetProperties","owner","serialize","localeCompare"],"sourceRoot":""}