@stacks/encryption 7.4.0 → 7.4.1-pr.1863.1

package/dist/umd/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","mappings":"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","sources":["webpack://StacksEncryption/webpack/universalModuleDefinition","webpack://StacksEncryption/webpack/runtime/create fake namespace object","webpack://StacksEncryption/../../node_modules/@noble/hashes/utils.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/_u64.js","webpack://StacksEncryption/../../node_modules/@scure/bip39/index.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/pbkdf2.js","webpack://StacksEncryption/../../node_modules/bs58/index.js","webpack://StacksEncryption/../../node_modules/base-x/src/index.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/cryptoBrowser.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/_assert.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/hmac.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/_sha2.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/sha256.js","webpack://StacksEncryption/../../node_modules/@scure/base/lib/index.js","webpack://StacksEncryption/../../node_modules/@scure/bip39/wordlists/english.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/sha512.js","webpack://StacksEncryption/../../node_modules/base64-js/index.js","webpack://StacksEncryption/webpack/bootstrap","webpack://StacksEncryption/webpack/runtime/compat get default export","webpack://StacksEncryption/webpack/runtime/define property getters","webpack://StacksEncryption/webpack/runtime/global","webpack://StacksEncryption/webpack/runtime/hasOwnProperty shorthand","webpack://StacksEncryption/webpack/runtime/make namespace object","webpack://StacksEncryption/../../node_modules/@noble/hashes/esm/_assert.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/esm/utils.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/esm/cryptoBrowser.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/esm/hmac.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/esm/_sha2.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/esm/sha256.js","webpack://StacksEncryption/../../node_modules/@noble/secp256k1/lib/esm/index.js","webpack://StacksEncryption/../common/dist/esm/utils.js","webpack://StacksEncryption/../common/dist/esm/errors.js","webpack://StacksEncryption/../common/dist/esm/signatures.js","webpack://StacksEncryption/./src/cryptoUtils.ts","webpack://StacksEncryption/./src/aesCipher.ts","webpack://StacksEncryption/../common/dist/esm/buffer.js","webpack://StacksEncryption/../common/dist/esm/keys.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/esm/ripemd160.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/esm/_u64.js","webpack://StacksEncryption/../../node_modules/@noble/hashes/esm/sha512.js","webpack://StacksEncryption/./src/sha2Hash.ts","webpack://StacksEncryption/./src/keys.ts","webpack://StacksEncryption/./src/hashRipemd160.ts","webpack://StacksEncryption/./src/varuint.ts","webpack://StacksEncryption/./src/messageSignature.ts","webpack://StacksEncryption/./src/utils.ts","webpack://StacksEncryption/./src/ec.ts","webpack://StacksEncryption/./src/cryptoRandom.ts","webpack://StacksEncryption/./src/encryption.ts","webpack://StacksEncryption/./src/pbkdf2.ts","webpack://StacksEncryption/./src/wallet.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[\"StacksEncryption\"] = factory();\n\telse\n\t\troot[\"StacksEncryption\"] = factory();\n})(this, () => {\nreturn ","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","\"use strict\";\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.randomBytes = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.checkOpts = exports.Hash = exports.concatBytes = exports.toBytes = exports.utf8ToBytes = exports.asyncLoop = exports.nextTick = exports.hexToBytes = exports.bytesToHex = exports.isLE = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0;\n// The import here is via the package name. This is to ensure\n// that exports mapping/resolution does fall into place.\nconst crypto_1 = require(\"@noble/hashes/crypto\");\n// Cast array to different type\nconst u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexports.u8 = u8;\nconst u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\nexports.u32 = u32;\n// Cast array to view\nconst createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\nexports.createView = createView;\n// The rotate right (circular right shift) operation for uint32\nconst rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\nexports.rotr = rotr;\nexports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\n// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.\n// So, just to be sure not to corrupt anything.\nif (!exports.isLE)\n    throw new Error('Non little-endian hardware is not supported');\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))\n */\nfunction bytesToHex(uint8a) {\n    // pre-caching improves the speed 6x\n    if (!(uint8a instanceof Uint8Array))\n        throw new Error('Uint8Array expected');\n    let hex = '';\n    for (let i = 0; i < uint8a.length; i++) {\n        hex += hexes[uint8a[i]];\n    }\n    return hex;\n}\nexports.bytesToHex = bytesToHex;\n/**\n * @example hexToBytes('deadbeef')\n */\nfunction hexToBytes(hex) {\n    if (typeof hex !== 'string') {\n        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\n    }\n    if (hex.length % 2)\n        throw new Error('hexToBytes: received invalid unpadded hex');\n    const array = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\nexports.hexToBytes = hexToBytes;\n// There is no setImmediate in browser and setTimeout is slow. However, call to async function will return Promise\n// which will be fullfiled only on next scheduler queue processing step and this is exactly what we need.\nconst nextTick = async () => { };\nexports.nextTick = nextTick;\n// Returns control to thread each 'tick' ms to avoid blocking\nasync 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 (0, exports.nextTick)();\n        ts += diff;\n    }\n}\nexports.asyncLoop = asyncLoop;\nfunction utf8ToBytes(str) {\n    if (typeof str !== 'string') {\n        throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);\n    }\n    return new TextEncoder().encode(str);\n}\nexports.utf8ToBytes = utf8ToBytes;\nfunction toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    if (!(data instanceof Uint8Array))\n        throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);\n    return data;\n}\nexports.toBytes = toBytes;\n/**\n * Concats Uint8Array-s into one; like `Buffer.concat([buf1, buf2])`\n * @example concatBytes(buf1, buf2)\n */\nfunction concatBytes(...arrays) {\n    if (!arrays.every((a) => a instanceof Uint8Array))\n        throw new Error('Uint8Array list expected');\n    if (arrays.length === 1)\n        return arrays[0];\n    const length = arrays.reduce((a, arr) => a + arr.length, 0);\n    const result = new Uint8Array(length);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const arr = arrays[i];\n        result.set(arr, pad);\n        pad += arr.length;\n    }\n    return result;\n}\nexports.concatBytes = concatBytes;\n// For runtime check if class implements interface\nclass Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\nexports.Hash = Hash;\n// Check if object doens't have custom constructor (like Uint8Array/Array)\nconst isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;\nfunction checkOpts(defaults, opts) {\n    if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))\n        throw new TypeError('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexports.checkOpts = checkOpts;\nfunction wrapConstructor(hashConstructor) {\n    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();\n    const tmp = hashConstructor();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashConstructor();\n    return hashC;\n}\nexports.wrapConstructor = wrapConstructor;\nfunction wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexports.wrapConstructorWithOpts = wrapConstructorWithOpts;\n/**\n * Secure PRNG\n */\nfunction randomBytes(bytesLength = 32) {\n    if (crypto_1.crypto.web) {\n        return crypto_1.crypto.web.getRandomValues(new Uint8Array(bytesLength));\n    }\n    else if (crypto_1.crypto.node) {\n        return new Uint8Array(crypto_1.crypto.node.randomBytes(bytesLength).buffer);\n    }\n    else {\n        throw new Error(\"The environment doesn't have randomBytes function\");\n    }\n}\nexports.randomBytes = randomBytes;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.add = exports.toBig = exports.split = exports.fromBig = void 0;\nconst U32_MASK64 = BigInt(2 ** 32 - 1);\nconst _32n = BigInt(32);\n// We are not using BigUint64Array, because they are extremely slow as per 2022\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}\nexports.fromBig = fromBig;\nfunction split(lst, le = false) {\n    let Ah = new Uint32Array(lst.length);\n    let Al = new Uint32Array(lst.length);\n    for (let i = 0; i < lst.length; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\nexports.split = split;\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\nexports.toBig = toBig;\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.\n// Removing \"export\" has 5% perf penalty -_-\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}\nexports.add = add;\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\nconst u64 = {\n    fromBig, split, toBig: exports.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};\nexports.default = u64;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.mnemonicToSeedSync = exports.mnemonicToSeed = exports.validateMnemonic = exports.entropyToMnemonic = exports.mnemonicToEntropy = exports.generateMnemonic = void 0;\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nconst _assert_1 = require(\"@noble/hashes/_assert\");\nconst pbkdf2_1 = require(\"@noble/hashes/pbkdf2\");\nconst sha256_1 = require(\"@noble/hashes/sha256\");\nconst sha512_1 = require(\"@noble/hashes/sha512\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nconst base_1 = require(\"@scure/base\");\n// Japanese wordlist\nconst isJapanese = (wordlist) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304f\\u3057\\u3093';\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str) {\n    if (typeof str !== 'string')\n        throw new TypeError(`Invalid mnemonic type: ${typeof str}`);\n    return str.normalize('NFKD');\n}\nfunction normalize(str) {\n    const norm = nfkd(str);\n    const words = norm.split(' ');\n    if (![12, 15, 18, 21, 24].includes(words.length))\n        throw new Error('Invalid mnemonic');\n    return { nfkd: norm, words };\n}\nfunction assertEntropy(entropy) {\n    _assert_1.default.bytes(entropy, 16, 20, 24, 28, 32);\n}\n/**\n * Generate x random words. Uses Cryptographically-Secure Random Number Generator.\n * @param wordlist imported wordlist for specific language\n * @param strength mnemonic strength 128-256 bits\n * @example\n * generateMnemonic(wordlist, 128)\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\nfunction generateMnemonic(wordlist, strength = 128) {\n    _assert_1.default.number(strength);\n    if (strength % 32 !== 0 || strength > 256)\n        throw new TypeError('Invalid entropy');\n    return entropyToMnemonic((0, utils_1.randomBytes)(strength / 8), wordlist);\n}\nexports.generateMnemonic = generateMnemonic;\nconst calcChecksum = (entropy) => {\n    // Checksum is ent.length/4 bits long\n    const bitsLeft = 8 - entropy.length / 4;\n    // Zero rightmost \"bitsLeft\" bits in byte\n    // For example: bitsLeft=4 val=10111101 -> 10110000\n    return new Uint8Array([((0, sha256_1.sha256)(entropy)[0] >> bitsLeft) << bitsLeft]);\n};\nfunction getCoder(wordlist) {\n    if (!Array.isArray(wordlist) || wordlist.length !== 2 ** 11 || typeof wordlist[0] !== 'string')\n        throw new Error('Worlist: expected array of 2048 strings');\n    wordlist.forEach((i) => {\n        if (typeof i !== 'string')\n            throw new Error(`Wordlist: non-string element: ${i}`);\n    });\n    return base_1.utils.chain(base_1.utils.checksum(1, calcChecksum), base_1.utils.radix2(11, true), base_1.utils.alphabet(wordlist));\n}\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\nfunction mnemonicToEntropy(mnemonic, wordlist) {\n    const { words } = normalize(mnemonic);\n    const entropy = getCoder(wordlist).decode(words);\n    assertEntropy(entropy);\n    return entropy;\n}\nexports.mnemonicToEntropy = mnemonicToEntropy;\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\nfunction entropyToMnemonic(entropy, wordlist) {\n    assertEntropy(entropy);\n    const words = getCoder(wordlist).encode(entropy);\n    return words.join(isJapanese(wordlist) ? '\\u3000' : ' ');\n}\nexports.entropyToMnemonic = entropyToMnemonic;\n/**\n * Validates mnemonic for being 12-24 words contained in `wordlist`.\n */\nfunction validateMnemonic(mnemonic, wordlist) {\n    try {\n        mnemonicToEntropy(mnemonic, wordlist);\n    }\n    catch (e) {\n        return false;\n    }\n    return true;\n}\nexports.validateMnemonic = validateMnemonic;\nconst salt = (passphrase) => nfkd(`mnemonic${passphrase}`);\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\nfunction mnemonicToSeed(mnemonic, passphrase = '') {\n    return (0, pbkdf2_1.pbkdf2Async)(sha512_1.sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });\n}\nexports.mnemonicToSeed = mnemonicToSeed;\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\nfunction mnemonicToSeedSync(mnemonic, passphrase = '') {\n    return (0, pbkdf2_1.pbkdf2)(sha512_1.sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });\n}\nexports.mnemonicToSeedSync = mnemonicToSeedSync;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.pbkdf2Async = exports.pbkdf2 = void 0;\nconst _assert_js_1 = require(\"./_assert.js\");\nconst hmac_js_1 = require(\"./hmac.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// Common prologue and epilogue for sync/async functions\nfunction pbkdf2Init(hash, _password, _salt, _opts) {\n    _assert_js_1.default.hash(hash);\n    const opts = (0, utils_js_1.checkOpts)({ dkLen: 32, asyncTick: 10 }, _opts);\n    const { c, dkLen, asyncTick } = opts;\n    _assert_js_1.default.number(c);\n    _assert_js_1.default.number(dkLen);\n    _assert_js_1.default.number(asyncTick);\n    if (c < 1)\n        throw new Error('PBKDF2: iterations (c) should be >= 1');\n    const password = (0, utils_js_1.toBytes)(_password);\n    const salt = (0, utils_js_1.toBytes)(_salt);\n    // DK = PBKDF2(PRF, Password, Salt, c, dkLen);\n    const DK = new Uint8Array(dkLen);\n    // U1 = PRF(Password, Salt + INT_32_BE(i))\n    const PRF = hmac_js_1.hmac.create(hash, password);\n    const PRFSalt = PRF._cloneInto().update(salt);\n    return { c, dkLen, asyncTick, DK, PRF, PRFSalt };\n}\nfunction pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {\n    PRF.destroy();\n    PRFSalt.destroy();\n    if (prfW)\n        prfW.destroy();\n    u.fill(0);\n    return DK;\n}\n/**\n * PBKDF2-HMAC: RFC 2898 key derivation function\n * @param hash - hash function that would be used e.g. sha256\n * @param password - password from which a derived key is generated\n * @param salt - cryptographic salt\n * @param opts - {c, dkLen} where c is work factor and dkLen is output message size\n */\nfunction pbkdf2(hash, password, salt, opts) {\n    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);\n    let prfW; // Working copy\n    const arr = new Uint8Array(4);\n    const view = (0, utils_js_1.createView)(arr);\n    const u = new Uint8Array(PRF.outputLen);\n    // DK = T1 + T2 + ⋯ + Tdklen/hlen\n    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {\n        // Ti = F(Password, Salt, c, i)\n        const Ti = DK.subarray(pos, pos + PRF.outputLen);\n        view.setInt32(0, ti, false);\n        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc\n        // U1 = PRF(Password, Salt + INT_32_BE(i))\n        (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);\n        Ti.set(u.subarray(0, Ti.length));\n        for (let ui = 1; ui < c; ui++) {\n            // Uc = PRF(Password, Uc−1)\n            PRF._cloneInto(prfW).update(u).digestInto(u);\n            for (let i = 0; i < Ti.length; i++)\n                Ti[i] ^= u[i];\n        }\n    }\n    return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);\n}\nexports.pbkdf2 = pbkdf2;\nasync function pbkdf2Async(hash, password, salt, opts) {\n    const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);\n    let prfW; // Working copy\n    const arr = new Uint8Array(4);\n    const view = (0, utils_js_1.createView)(arr);\n    const u = new Uint8Array(PRF.outputLen);\n    // DK = T1 + T2 + ⋯ + Tdklen/hlen\n    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {\n        // Ti = F(Password, Salt, c, i)\n        const Ti = DK.subarray(pos, pos + PRF.outputLen);\n        view.setInt32(0, ti, false);\n        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc\n        // U1 = PRF(Password, Salt + INT_32_BE(i))\n        (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);\n        Ti.set(u.subarray(0, Ti.length));\n        await (0, utils_js_1.asyncLoop)(c - 1, asyncTick, (i) => {\n            // Uc = PRF(Password, Uc−1)\n            PRF._cloneInto(prfW).update(u).digestInto(u);\n            for (let i = 0; i < Ti.length; i++)\n                Ti[i] ^= u[i];\n        });\n    }\n    return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);\n}\nexports.pbkdf2Async = pbkdf2Async;\n","const basex = require('base-x')\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nmodule.exports = basex(ALPHABET)\n","'use strict'\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  var BASE_MAP = new Uint8Array(256)\n  for (var j = 0; j < BASE_MAP.length; j++) {\n    BASE_MAP[j] = 255\n  }\n  for (var i = 0; i < ALPHABET.length; i++) {\n    var x = ALPHABET.charAt(i)\n    var xc = x.charCodeAt(0)\n    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\n    BASE_MAP[xc] = i\n  }\n  var BASE = ALPHABET.length\n  var LEADER = ALPHABET.charAt(0)\n  var FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up\n  var iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up\n  function encode (source) {\n    if (source instanceof Uint8Array) {\n    } 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    var zeroes = 0\n    var length = 0\n    var pbegin = 0\n    var 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    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0\n    var b58 = new Uint8Array(size)\n        // Process the bytes.\n    while (pbegin !== pend) {\n      var carry = source[pbegin]\n            // Apply \"b58 = b58 * 256 + ch\".\n      var i = 0\n      for (var 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    var it2 = size - length\n    while (it2 !== size && b58[it2] === 0) {\n      it2++\n    }\n        // Translate the result into a string.\n    var 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    var psz = 0\n        // Skip and count leading '1's.\n    var zeroes = 0\n    var length = 0\n    while (source[psz] === LEADER) {\n      zeroes++\n      psz++\n    }\n        // Allocate enough space in big-endian base256 representation.\n    var size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.\n    var b256 = new Uint8Array(size)\n        // Process the characters.\n    while (source[psz]) {\n            // Find code of next character\n      var charCode = source.charCodeAt(psz)\n            // Base map can not be indexed using char code\n      if (charCode > 255) { return }\n            // Decode character\n      var carry = BASE_MAP[charCode]\n            // Invalid character\n      if (carry === 255) { return }\n      var i = 0\n      for (var 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    var it4 = size - length\n    while (it4 !== size && b256[it4] === 0) {\n      it4++\n    }\n    var vch = new Uint8Array(zeroes + (size - it4))\n    var j = zeroes\n    while (it4 !== size) {\n      vch[j++] = b256[it4++]\n    }\n    return vch\n  }\n  function decode (string) {\n    var buffer = decodeUnsafe(string)\n    if (buffer) { return buffer }\n    throw new Error('Non-base' + BASE + ' character')\n  }\n  return {\n    encode: encode,\n    decodeUnsafe: decodeUnsafe,\n    decode: decode\n  }\n}\nmodule.exports = base\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.crypto = void 0;\nexports.crypto = {\n    node: undefined,\n    web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = void 0;\nfunction number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`Wrong positive integer: ${n}`);\n}\nexports.number = number;\nfunction bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`Expected boolean, not ${b}`);\n}\nexports.bool = bool;\nfunction bytes(b, ...lengths) {\n    if (!(b instanceof Uint8Array))\n        throw new TypeError('Expected Uint8Array');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nexports.bytes = bytes;\nfunction hash(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(hash.outputLen);\n    number(hash.blockLen);\n}\nexports.hash = hash;\nfunction exists(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}\nexports.exists = exists;\nfunction output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nexports.output = output;\nconst assert = {\n    number,\n    bool,\n    bytes,\n    hash,\n    exists,\n    output,\n};\nexports.default = assert;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hmac = void 0;\nconst _assert_js_1 = require(\"./_assert.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// HMAC (RFC 2104)\nclass HMAC extends utils_js_1.Hash {\n    constructor(hash, _key) {\n        super();\n        this.finished = false;\n        this.destroyed = false;\n        _assert_js_1.default.hash(hash);\n        const key = (0, utils_js_1.toBytes)(_key);\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new TypeError('Expected instance of class which extends utils.Hash');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        pad.fill(0);\n    }\n    update(buf) {\n        _assert_js_1.default.exists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        _assert_js_1.default.exists(this);\n        _assert_js_1.default.bytes(out, this.outputLen);\n        this.finished = true;\n        this.iHash.digestInto(out);\n        this.oHash.update(out);\n        this.oHash.digestInto(out);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since key already in state and we don't know it.\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n */\nconst hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nexports.hmac = hmac;\nexports.hmac.create = (hash, key) => new HMAC(hash, key);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SHA2 = void 0;\nconst _assert_js_1 = require(\"./_assert.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// Polyfill for Safari 14\nfunction setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\n// Base SHA2 class (RFC 6234)\nclass SHA2 extends utils_js_1.Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = (0, utils_js_1.createView)(this.buffer);\n    }\n    update(data) {\n        _assert_js_1.default.exists(this);\n        const { view, buffer, blockLen } = this;\n        data = (0, utils_js_1.toBytes)(data);\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 = (0, utils_js_1.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        _assert_js_1.default.exists(this);\n        _assert_js_1.default.output(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        this.buffer.subarray(pos).fill(0);\n        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = (0, utils_js_1.createView)(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to || (to = new this.constructor());\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.length = length;\n        to.pos = pos;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n}\nexports.SHA2 = SHA2;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sha224 = exports.sha256 = void 0;\nconst _sha2_js_1 = require(\"./_sha2.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = new Uint32Array([\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// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = new Uint32Array([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = new Uint32Array(64);\nclass SHA256 extends _sha2_js_1.SHA2 {\n    constructor() {\n        super(64, 32, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = IV[0] | 0;\n        this.B = IV[1] | 0;\n        this.C = IV[2] | 0;\n        this.D = IV[3] | 0;\n        this.E = IV[4] | 0;\n        this.F = IV[5] | 0;\n        this.G = IV[6] | 0;\n        this.H = IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = (0, utils_js_1.rotr)(W15, 7) ^ (0, utils_js_1.rotr)(W15, 18) ^ (W15 >>> 3);\n            const s1 = (0, utils_js_1.rotr)(W2, 17) ^ (0, utils_js_1.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 = (0, utils_js_1.rotr)(E, 6) ^ (0, utils_js_1.rotr)(E, 11) ^ (0, utils_js_1.rotr)(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = (0, utils_js_1.rotr)(A, 2) ^ (0, utils_js_1.rotr)(A, 13) ^ (0, utils_js_1.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        SHA256_W.fill(0);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        this.buffer.fill(0);\n    }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n    constructor() {\n        super();\n        this.A = 0xc1059ed8 | 0;\n        this.B = 0x367cd507 | 0;\n        this.C = 0x3070dd17 | 0;\n        this.D = 0xf70e5939 | 0;\n        this.E = 0xffc00b31 | 0;\n        this.F = 0x68581511 | 0;\n        this.G = 0x64f98fa7 | 0;\n        this.H = 0xbefa4fa4 | 0;\n        this.outputLen = 28;\n    }\n}\n/**\n * SHA2-256 hash function\n * @param message - data that would be hashed\n */\nexports.sha256 = (0, utils_js_1.wrapConstructor)(() => new SHA256());\nexports.sha224 = (0, utils_js_1.wrapConstructor)(() => new SHA224());\n","\"use strict\";\n/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.bytes = exports.stringToBytes = exports.str = exports.bytesToString = exports.hex = exports.utf8 = exports.bech32m = exports.bech32 = exports.base58check = exports.base58xmr = exports.base58xrp = exports.base58flickr = exports.base58 = exports.base64url = exports.base64 = exports.base32crockford = exports.base32hex = exports.base32 = exports.base16 = exports.utils = exports.assertNumber = void 0;\nfunction assertNumber(n) {\n    if (!Number.isSafeInteger(n))\n        throw new Error(`Wrong integer: ${n}`);\n}\nexports.assertNumber = assertNumber;\nfunction chain(...args) {\n    const wrap = (a, b) => (c) => a(b(c));\n    const encode = Array.from(args)\n        .reverse()\n        .reduce((acc, i) => (acc ? wrap(acc, i.encode) : i.encode), undefined);\n    const decode = args.reduce((acc, i) => (acc ? wrap(acc, i.decode) : i.decode), undefined);\n    return { encode, decode };\n}\nfunction alphabet(alphabet) {\n    return {\n        encode: (digits) => {\n            if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number'))\n                throw new Error('alphabet.encode input should be an array of numbers');\n            return digits.map((i) => {\n                assertNumber(i);\n                if (i < 0 || i >= alphabet.length)\n                    throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet.length})`);\n                return alphabet[i];\n            });\n        },\n        decode: (input) => {\n            if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string'))\n                throw new Error('alphabet.decode input should be array of strings');\n            return input.map((letter) => {\n                if (typeof letter !== 'string')\n                    throw new Error(`alphabet.decode: not string element=${letter}`);\n                const index = alphabet.indexOf(letter);\n                if (index === -1)\n                    throw new Error(`Unknown letter: \"${letter}\". Allowed: ${alphabet}`);\n                return index;\n            });\n        },\n    };\n}\nfunction join(separator = '') {\n    if (typeof separator !== 'string')\n        throw new Error('join separator should be string');\n    return {\n        encode: (from) => {\n            if (!Array.isArray(from) || (from.length && typeof from[0] !== 'string'))\n                throw new Error('join.encode input should be array of strings');\n            for (let i of from)\n                if (typeof i !== 'string')\n                    throw new Error(`join.encode: non-string input=${i}`);\n            return from.join(separator);\n        },\n        decode: (to) => {\n            if (typeof to !== 'string')\n                throw new Error('join.decode input should be string');\n            return to.split(separator);\n        },\n    };\n}\nfunction padding(bits, chr = '=') {\n    assertNumber(bits);\n    if (typeof chr !== 'string')\n        throw new Error('padding chr should be string');\n    return {\n        encode(data) {\n            if (!Array.isArray(data) || (data.length && typeof data[0] !== 'string'))\n                throw new Error('padding.encode input should be array of strings');\n            for (let i of data)\n                if (typeof i !== 'string')\n                    throw new Error(`padding.encode: non-string input=${i}`);\n            while ((data.length * bits) % 8)\n                data.push(chr);\n            return data;\n        },\n        decode(input) {\n            if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string'))\n                throw new Error('padding.encode input should be array of strings');\n            for (let i of input)\n                if (typeof i !== 'string')\n                    throw new Error(`padding.decode: non-string input=${i}`);\n            let end = input.length;\n            if ((end * bits) % 8)\n                throw new Error('Invalid padding: string should have whole number of bytes');\n            for (; end > 0 && input[end - 1] === chr; end--) {\n                if (!(((end - 1) * bits) % 8))\n                    throw new Error('Invalid padding: string has too much padding');\n            }\n            return input.slice(0, end);\n        },\n    };\n}\nfunction normalize(fn) {\n    if (typeof fn !== 'function')\n        throw new Error('normalize fn should be function');\n    return { encode: (from) => from, decode: (to) => fn(to) };\n}\nfunction convertRadix(data, from, to) {\n    if (from < 2)\n        throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`);\n    if (to < 2)\n        throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`);\n    if (!Array.isArray(data))\n        throw new Error('convertRadix: data should be array');\n    if (!data.length)\n        return [];\n    let pos = 0;\n    const res = [];\n    const digits = Array.from(data);\n    digits.forEach((d) => {\n        assertNumber(d);\n        if (d < 0 || d >= from)\n            throw new Error(`Wrong integer: ${d}`);\n    });\n    while (true) {\n        let carry = 0;\n        let done = true;\n        for (let i = pos; i < digits.length; i++) {\n            const digit = digits[i];\n            const digitBase = from * carry + digit;\n            if (!Number.isSafeInteger(digitBase) ||\n                (from * carry) / from !== carry ||\n                digitBase - digit !== from * carry) {\n                throw new Error('convertRadix: carry overflow');\n            }\n            carry = digitBase % to;\n            digits[i] = Math.floor(digitBase / to);\n            if (!Number.isSafeInteger(digits[i]) || digits[i] * to + carry !== digitBase)\n                throw new Error('convertRadix: carry overflow');\n            if (!done)\n                continue;\n            else if (!digits[i])\n                pos = i;\n            else\n                done = false;\n        }\n        res.push(carry);\n        if (done)\n            break;\n    }\n    for (let i = 0; i < data.length - 1 && data[i] === 0; i++)\n        res.push(0);\n    return res.reverse();\n}\nconst gcd = (a, b) => (!b ? a : gcd(b, a % b));\nconst radix2carry = (from, to) => from + (to - gcd(from, to));\nfunction convertRadix2(data, from, to, padding) {\n    if (!Array.isArray(data))\n        throw new Error('convertRadix2: data should be array');\n    if (from <= 0 || from > 32)\n        throw new Error(`convertRadix2: wrong from=${from}`);\n    if (to <= 0 || to > 32)\n        throw new Error(`convertRadix2: wrong to=${to}`);\n    if (radix2carry(from, to) > 32) {\n        throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);\n    }\n    let carry = 0;\n    let pos = 0;\n    const mask = 2 ** to - 1;\n    const res = [];\n    for (const n of data) {\n        assertNumber(n);\n        if (n >= 2 ** from)\n            throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);\n        carry = (carry << from) | n;\n        if (pos + from > 32)\n            throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);\n        pos += from;\n        for (; pos >= to; pos -= to)\n            res.push(((carry >> (pos - to)) & mask) >>> 0);\n        carry &= 2 ** pos - 1;\n    }\n    carry = (carry << (to - pos)) & mask;\n    if (!padding && pos >= from)\n        throw new Error('Excess padding');\n    if (!padding && carry)\n        throw new Error(`Non-zero padding: ${carry}`);\n    if (padding && pos > 0)\n        res.push(carry >>> 0);\n    return res;\n}\nfunction radix(num) {\n    assertNumber(num);\n    return {\n        encode: (bytes) => {\n            if (!(bytes instanceof Uint8Array))\n                throw new Error('radix.encode input should be Uint8Array');\n            return convertRadix(Array.from(bytes), 2 ** 8, num);\n        },\n        decode: (digits) => {\n            if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number'))\n                throw new Error('radix.decode input should be array of strings');\n            return Uint8Array.from(convertRadix(digits, num, 2 ** 8));\n        },\n    };\n}\nfunction radix2(bits, revPadding = false) {\n    assertNumber(bits);\n    if (bits <= 0 || bits > 32)\n        throw new Error('radix2: bits should be in (0..32]');\n    if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)\n        throw new Error('radix2: carry overflow');\n    return {\n        encode: (bytes) => {\n            if (!(bytes instanceof Uint8Array))\n                throw new Error('radix2.encode input should be Uint8Array');\n            return convertRadix2(Array.from(bytes), 8, bits, !revPadding);\n        },\n        decode: (digits) => {\n            if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number'))\n                throw new Error('radix2.decode input should be array of strings');\n            return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));\n        },\n    };\n}\nfunction unsafeWrapper(fn) {\n    if (typeof fn !== 'function')\n        throw new Error('unsafeWrapper fn should be function');\n    return function (...args) {\n        try {\n            return fn.apply(null, args);\n        }\n        catch (e) { }\n    };\n}\nfunction checksum(len, fn) {\n    assertNumber(len);\n    if (typeof fn !== 'function')\n        throw new Error('checksum fn should be function');\n    return {\n        encode(data) {\n            if (!(data instanceof Uint8Array))\n                throw new Error('checksum.encode: input should be Uint8Array');\n            const checksum = fn(data).slice(0, len);\n            const res = new Uint8Array(data.length + len);\n            res.set(data);\n            res.set(checksum, data.length);\n            return res;\n        },\n        decode(data) {\n            if (!(data instanceof Uint8Array))\n                throw new Error('checksum.decode: input should be Uint8Array');\n            const payload = data.slice(0, -len);\n            const newChecksum = fn(payload).slice(0, len);\n            const oldChecksum = data.slice(-len);\n            for (let i = 0; i < len; i++)\n                if (newChecksum[i] !== oldChecksum[i])\n                    throw new Error('Invalid checksum');\n            return payload;\n        },\n    };\n}\nexports.utils = { alphabet, chain, checksum, radix, radix2, join, padding };\nexports.base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));\nexports.base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));\nexports.base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));\nexports.base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));\nexports.base64 = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));\nexports.base64url = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));\nconst genBase58 = (abc) => chain(radix(58), alphabet(abc), join(''));\nexports.base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');\nexports.base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');\nexports.base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz');\nconst XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11];\nexports.base58xmr = {\n    encode(data) {\n        let res = '';\n        for (let i = 0; i < data.length; i += 8) {\n            const block = data.subarray(i, i + 8);\n            res += exports.base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], '1');\n        }\n        return res;\n    },\n    decode(str) {\n        let res = [];\n        for (let i = 0; i < str.length; i += 11) {\n            const slice = str.slice(i, i + 11);\n            const blockLen = XMR_BLOCK_LEN.indexOf(slice.length);\n            const block = exports.base58.decode(slice);\n            for (let j = 0; j < block.length - blockLen; j++) {\n                if (block[j] !== 0)\n                    throw new Error('base58xmr: wrong padding');\n            }\n            res = res.concat(Array.from(block.slice(block.length - blockLen)));\n        }\n        return Uint8Array.from(res);\n    },\n};\nconst base58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), exports.base58);\nexports.base58check = base58check;\nconst BECH_ALPHABET = chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join(''));\nconst POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];\nfunction bech32Polymod(pre) {\n    const b = pre >> 25;\n    let chk = (pre & 0x1ffffff) << 5;\n    for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {\n        if (((b >> i) & 1) === 1)\n            chk ^= POLYMOD_GENERATORS[i];\n    }\n    return chk;\n}\nfunction bechChecksum(prefix, words, encodingConst = 1) {\n    const len = prefix.length;\n    let chk = 1;\n    for (let i = 0; i < len; i++) {\n        const c = prefix.charCodeAt(i);\n        if (c < 33 || c > 126)\n            throw new Error(`Invalid prefix (${prefix})`);\n        chk = bech32Polymod(chk) ^ (c >> 5);\n    }\n    chk = bech32Polymod(chk);\n    for (let i = 0; i < len; i++)\n        chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f);\n    for (let v of words)\n        chk = bech32Polymod(chk) ^ v;\n    for (let i = 0; i < 6; i++)\n        chk = bech32Polymod(chk);\n    chk ^= encodingConst;\n    return BECH_ALPHABET.encode(convertRadix2([chk % 2 ** 30], 30, 5, false));\n}\nfunction genBech32(encoding) {\n    const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3;\n    const _words = radix2(5);\n    const fromWords = _words.decode;\n    const toWords = _words.encode;\n    const fromWordsUnsafe = unsafeWrapper(fromWords);\n    function encode(prefix, words, limit = 90) {\n        if (typeof prefix !== 'string')\n            throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`);\n        if (!Array.isArray(words) || (words.length && typeof words[0] !== 'number'))\n            throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`);\n        const actualLength = prefix.length + 7 + words.length;\n        if (limit !== false && actualLength > limit)\n            throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);\n        prefix = prefix.toLowerCase();\n        return `${prefix}1${BECH_ALPHABET.encode(words)}${bechChecksum(prefix, words, ENCODING_CONST)}`;\n    }\n    function decode(str, limit = 90) {\n        if (typeof str !== 'string')\n            throw new Error(`bech32.decode input should be string, not ${typeof str}`);\n        if (str.length < 8 || (limit !== false && str.length > limit))\n            throw new TypeError(`Wrong string length: ${str.length} (${str}). Expected (8..${limit})`);\n        const lowered = str.toLowerCase();\n        if (str !== lowered && str !== str.toUpperCase())\n            throw new Error(`String must be lowercase or uppercase`);\n        str = lowered;\n        const sepIndex = str.lastIndexOf('1');\n        if (sepIndex === 0 || sepIndex === -1)\n            throw new Error(`Letter \"1\" must be present between prefix and data only`);\n        const prefix = str.slice(0, sepIndex);\n        const _words = str.slice(sepIndex + 1);\n        if (_words.length < 6)\n            throw new Error('Data must be at least 6 characters long');\n        const words = BECH_ALPHABET.decode(_words).slice(0, -6);\n        const sum = bechChecksum(prefix, words, ENCODING_CONST);\n        if (!_words.endsWith(sum))\n            throw new Error(`Invalid checksum in ${str}: expected \"${sum}\"`);\n        return { prefix, words };\n    }\n    const decodeUnsafe = unsafeWrapper(decode);\n    function decodeToBytes(str) {\n        const { prefix, words } = decode(str, false);\n        return { prefix, words, bytes: fromWords(words) };\n    }\n    return { encode, decode, decodeToBytes, decodeUnsafe, fromWords, fromWordsUnsafe, toWords };\n}\nexports.bech32 = genBech32('bech32');\nexports.bech32m = genBech32('bech32m');\nexports.utf8 = {\n    encode: (data) => new TextDecoder().decode(data),\n    decode: (str) => new TextEncoder().encode(str),\n};\nexports.hex = chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize((s) => {\n    if (typeof s !== 'string' || s.length % 2)\n        throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);\n    return s.toLowerCase();\n}));\nconst CODERS = {\n    utf8: exports.utf8, hex: exports.hex, base16: exports.base16, base32: exports.base32, base64: exports.base64, base64url: exports.base64url, base58: exports.base58, base58xmr: exports.base58xmr\n};\nconst coderTypeError = `Invalid encoding type. Available types: ${Object.keys(CODERS).join(', ')}`;\nconst bytesToString = (type, bytes) => {\n    if (typeof type !== 'string' || !CODERS.hasOwnProperty(type))\n        throw new TypeError(coderTypeError);\n    if (!(bytes instanceof Uint8Array))\n        throw new TypeError('bytesToString() expects Uint8Array');\n    return CODERS[type].encode(bytes);\n};\nexports.bytesToString = bytesToString;\nexports.str = exports.bytesToString;\nconst stringToBytes = (type, str) => {\n    if (!CODERS.hasOwnProperty(type))\n        throw new TypeError(coderTypeError);\n    if (typeof str !== 'string')\n        throw new TypeError('stringToBytes() expects string');\n    return CODERS[type].decode(str);\n};\nexports.stringToBytes = stringToBytes;\nexports.bytes = exports.stringToBytes;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.wordlist = void 0;\nexports.wordlist = `abandon\nability\nable\nabout\nabove\nabsent\nabsorb\nabstract\nabsurd\nabuse\naccess\naccident\naccount\naccuse\nachieve\nacid\nacoustic\nacquire\nacross\nact\naction\nactor\nactress\nactual\nadapt\nadd\naddict\naddress\nadjust\nadmit\nadult\nadvance\nadvice\naerobic\naffair\nafford\nafraid\nagain\nage\nagent\nagree\nahead\naim\nair\nairport\naisle\nalarm\nalbum\nalcohol\nalert\nalien\nall\nalley\nallow\nalmost\nalone\nalpha\nalready\nalso\nalter\nalways\namateur\namazing\namong\namount\namused\nanalyst\nanchor\nancient\nanger\nangle\nangry\nanimal\nankle\nannounce\nannual\nanother\nanswer\nantenna\nantique\nanxiety\nany\napart\napology\nappear\napple\napprove\napril\narch\narctic\narea\narena\nargue\narm\narmed\narmor\narmy\naround\narrange\narrest\narrive\narrow\nart\nartefact\nartist\nartwork\nask\naspect\nassault\nasset\nassist\nassume\nasthma\nathlete\natom\nattack\nattend\nattitude\nattract\nauction\naudit\naugust\naunt\nauthor\nauto\nautumn\naverage\navocado\navoid\nawake\naware\naway\nawesome\nawful\nawkward\naxis\nbaby\nbachelor\nbacon\nbadge\nbag\nbalance\nbalcony\nball\nbamboo\nbanana\nbanner\nbar\nbarely\nbargain\nbarrel\nbase\nbasic\nbasket\nbattle\nbeach\nbean\nbeauty\nbecause\nbecome\nbeef\nbefore\nbegin\nbehave\nbehind\nbelieve\nbelow\nbelt\nbench\nbenefit\nbest\nbetray\nbetter\nbetween\nbeyond\nbicycle\nbid\nbike\nbind\nbiology\nbird\nbirth\nbitter\nblack\nblade\nblame\nblanket\nblast\nbleak\nbless\nblind\nblood\nblossom\nblouse\nblue\nblur\nblush\nboard\nboat\nbody\nboil\nbomb\nbone\nbonus\nbook\nboost\nborder\nboring\nborrow\nboss\nbottom\nbounce\nbox\nboy\nbracket\nbrain\nbrand\nbrass\nbrave\nbread\nbreeze\nbrick\nbridge\nbrief\nbright\nbring\nbrisk\nbroccoli\nbroken\nbronze\nbroom\nbrother\nbrown\nbrush\nbubble\nbuddy\nbudget\nbuffalo\nbuild\nbulb\nbulk\nbullet\nbundle\nbunker\nburden\nburger\nburst\nbus\nbusiness\nbusy\nbutter\nbuyer\nbuzz\ncabbage\ncabin\ncable\ncactus\ncage\ncake\ncall\ncalm\ncamera\ncamp\ncan\ncanal\ncancel\ncandy\ncannon\ncanoe\ncanvas\ncanyon\ncapable\ncapital\ncaptain\ncar\ncarbon\ncard\ncargo\ncarpet\ncarry\ncart\ncase\ncash\ncasino\ncastle\ncasual\ncat\ncatalog\ncatch\ncategory\ncattle\ncaught\ncause\ncaution\ncave\nceiling\ncelery\ncement\ncensus\ncentury\ncereal\ncertain\nchair\nchalk\nchampion\nchange\nchaos\nchapter\ncharge\nchase\nchat\ncheap\ncheck\ncheese\nchef\ncherry\nchest\nchicken\nchief\nchild\nchimney\nchoice\nchoose\nchronic\nchuckle\nchunk\nchurn\ncigar\ncinnamon\ncircle\ncitizen\ncity\ncivil\nclaim\nclap\nclarify\nclaw\nclay\nclean\nclerk\nclever\nclick\nclient\ncliff\nclimb\nclinic\nclip\nclock\nclog\nclose\ncloth\ncloud\nclown\nclub\nclump\ncluster\nclutch\ncoach\ncoast\ncoconut\ncode\ncoffee\ncoil\ncoin\ncollect\ncolor\ncolumn\ncombine\ncome\ncomfort\ncomic\ncommon\ncompany\nconcert\nconduct\nconfirm\ncongress\nconnect\nconsider\ncontrol\nconvince\ncook\ncool\ncopper\ncopy\ncoral\ncore\ncorn\ncorrect\ncost\ncotton\ncouch\ncountry\ncouple\ncourse\ncousin\ncover\ncoyote\ncrack\ncradle\ncraft\ncram\ncrane\ncrash\ncrater\ncrawl\ncrazy\ncream\ncredit\ncreek\ncrew\ncricket\ncrime\ncrisp\ncritic\ncrop\ncross\ncrouch\ncrowd\ncrucial\ncruel\ncruise\ncrumble\ncrunch\ncrush\ncry\ncrystal\ncube\nculture\ncup\ncupboard\ncurious\ncurrent\ncurtain\ncurve\ncushion\ncustom\ncute\ncycle\ndad\ndamage\ndamp\ndance\ndanger\ndaring\ndash\ndaughter\ndawn\nday\ndeal\ndebate\ndebris\ndecade\ndecember\ndecide\ndecline\ndecorate\ndecrease\ndeer\ndefense\ndefine\ndefy\ndegree\ndelay\ndeliver\ndemand\ndemise\ndenial\ndentist\ndeny\ndepart\ndepend\ndeposit\ndepth\ndeputy\nderive\ndescribe\ndesert\ndesign\ndesk\ndespair\ndestroy\ndetail\ndetect\ndevelop\ndevice\ndevote\ndiagram\ndial\ndiamond\ndiary\ndice\ndiesel\ndiet\ndiffer\ndigital\ndignity\ndilemma\ndinner\ndinosaur\ndirect\ndirt\ndisagree\ndiscover\ndisease\ndish\ndismiss\ndisorder\ndisplay\ndistance\ndivert\ndivide\ndivorce\ndizzy\ndoctor\ndocument\ndog\ndoll\ndolphin\ndomain\ndonate\ndonkey\ndonor\ndoor\ndose\ndouble\ndove\ndraft\ndragon\ndrama\ndrastic\ndraw\ndream\ndress\ndrift\ndrill\ndrink\ndrip\ndrive\ndrop\ndrum\ndry\nduck\ndumb\ndune\nduring\ndust\ndutch\nduty\ndwarf\ndynamic\neager\neagle\nearly\nearn\nearth\neasily\neast\neasy\necho\necology\neconomy\nedge\nedit\neducate\neffort\negg\neight\neither\nelbow\nelder\nelectric\nelegant\nelement\nelephant\nelevator\nelite\nelse\nembark\nembody\nembrace\nemerge\nemotion\nemploy\nempower\nempty\nenable\nenact\nend\nendless\nendorse\nenemy\nenergy\nenforce\nengage\nengine\nenhance\nenjoy\nenlist\nenough\nenrich\nenroll\nensure\nenter\nentire\nentry\nenvelope\nepisode\nequal\nequip\nera\nerase\nerode\nerosion\nerror\nerupt\nescape\nessay\nessence\nestate\neternal\nethics\nevidence\nevil\nevoke\nevolve\nexact\nexample\nexcess\nexchange\nexcite\nexclude\nexcuse\nexecute\nexercise\nexhaust\nexhibit\nexile\nexist\nexit\nexotic\nexpand\nexpect\nexpire\nexplain\nexpose\nexpress\nextend\nextra\neye\neyebrow\nfabric\nface\nfaculty\nfade\nfaint\nfaith\nfall\nfalse\nfame\nfamily\nfamous\nfan\nfancy\nfantasy\nfarm\nfashion\nfat\nfatal\nfather\nfatigue\nfault\nfavorite\nfeature\nfebruary\nfederal\nfee\nfeed\nfeel\nfemale\nfence\nfestival\nfetch\nfever\nfew\nfiber\nfiction\nfield\nfigure\nfile\nfilm\nfilter\nfinal\nfind\nfine\nfinger\nfinish\nfire\nfirm\nfirst\nfiscal\nfish\nfit\nfitness\nfix\nflag\nflame\nflash\nflat\nflavor\nflee\nflight\nflip\nfloat\nflock\nfloor\nflower\nfluid\nflush\nfly\nfoam\nfocus\nfog\nfoil\nfold\nfollow\nfood\nfoot\nforce\nforest\nforget\nfork\nfortune\nforum\nforward\nfossil\nfoster\nfound\nfox\nfragile\nframe\nfrequent\nfresh\nfriend\nfringe\nfrog\nfront\nfrost\nfrown\nfrozen\nfruit\nfuel\nfun\nfunny\nfurnace\nfury\nfuture\ngadget\ngain\ngalaxy\ngallery\ngame\ngap\ngarage\ngarbage\ngarden\ngarlic\ngarment\ngas\ngasp\ngate\ngather\ngauge\ngaze\ngeneral\ngenius\ngenre\ngentle\ngenuine\ngesture\nghost\ngiant\ngift\ngiggle\nginger\ngiraffe\ngirl\ngive\nglad\nglance\nglare\nglass\nglide\nglimpse\nglobe\ngloom\nglory\nglove\nglow\nglue\ngoat\ngoddess\ngold\ngood\ngoose\ngorilla\ngospel\ngossip\ngovern\ngown\ngrab\ngrace\ngrain\ngrant\ngrape\ngrass\ngravity\ngreat\ngreen\ngrid\ngrief\ngrit\ngrocery\ngroup\ngrow\ngrunt\nguard\nguess\nguide\nguilt\nguitar\ngun\ngym\nhabit\nhair\nhalf\nhammer\nhamster\nhand\nhappy\nharbor\nhard\nharsh\nharvest\nhat\nhave\nhawk\nhazard\nhead\nhealth\nheart\nheavy\nhedgehog\nheight\nhello\nhelmet\nhelp\nhen\nhero\nhidden\nhigh\nhill\nhint\nhip\nhire\nhistory\nhobby\nhockey\nhold\nhole\nholiday\nhollow\nhome\nhoney\nhood\nhope\nhorn\nhorror\nhorse\nhospital\nhost\nhotel\nhour\nhover\nhub\nhuge\nhuman\nhumble\nhumor\nhundred\nhungry\nhunt\nhurdle\nhurry\nhurt\nhusband\nhybrid\nice\nicon\nidea\nidentify\nidle\nignore\nill\nillegal\nillness\nimage\nimitate\nimmense\nimmune\nimpact\nimpose\nimprove\nimpulse\ninch\ninclude\nincome\nincrease\nindex\nindicate\nindoor\nindustry\ninfant\ninflict\ninform\ninhale\ninherit\ninitial\ninject\ninjury\ninmate\ninner\ninnocent\ninput\ninquiry\ninsane\ninsect\ninside\ninspire\ninstall\nintact\ninterest\ninto\ninvest\ninvite\ninvolve\niron\nisland\nisolate\nissue\nitem\nivory\njacket\njaguar\njar\njazz\njealous\njeans\njelly\njewel\njob\njoin\njoke\njourney\njoy\njudge\njuice\njump\njungle\njunior\njunk\njust\nkangaroo\nkeen\nkeep\nketchup\nkey\nkick\nkid\nkidney\nkind\nkingdom\nkiss\nkit\nkitchen\nkite\nkitten\nkiwi\nknee\nknife\nknock\nknow\nlab\nlabel\nlabor\nladder\nlady\nlake\nlamp\nlanguage\nlaptop\nlarge\nlater\nlatin\nlaugh\nlaundry\nlava\nlaw\nlawn\nlawsuit\nlayer\nlazy\nleader\nleaf\nlearn\nleave\nlecture\nleft\nleg\nlegal\nlegend\nleisure\nlemon\nlend\nlength\nlens\nleopard\nlesson\nletter\nlevel\nliar\nliberty\nlibrary\nlicense\nlife\nlift\nlight\nlike\nlimb\nlimit\nlink\nlion\nliquid\nlist\nlittle\nlive\nlizard\nload\nloan\nlobster\nlocal\nlock\nlogic\nlonely\nlong\nloop\nlottery\nloud\nlounge\nlove\nloyal\nlucky\nluggage\nlumber\nlunar\nlunch\nluxury\nlyrics\nmachine\nmad\nmagic\nmagnet\nmaid\nmail\nmain\nmajor\nmake\nmammal\nman\nmanage\nmandate\nmango\nmansion\nmanual\nmaple\nmarble\nmarch\nmargin\nmarine\nmarket\nmarriage\nmask\nmass\nmaster\nmatch\nmaterial\nmath\nmatrix\nmatter\nmaximum\nmaze\nmeadow\nmean\nmeasure\nmeat\nmechanic\nmedal\nmedia\nmelody\nmelt\nmember\nmemory\nmention\nmenu\nmercy\nmerge\nmerit\nmerry\nmesh\nmessage\nmetal\nmethod\nmiddle\nmidnight\nmilk\nmillion\nmimic\nmind\nminimum\nminor\nminute\nmiracle\nmirror\nmisery\nmiss\nmistake\nmix\nmixed\nmixture\nmobile\nmodel\nmodify\nmom\nmoment\nmonitor\nmonkey\nmonster\nmonth\nmoon\nmoral\nmore\nmorning\nmosquito\nmother\nmotion\nmotor\nmountain\nmouse\nmove\nmovie\nmuch\nmuffin\nmule\nmultiply\nmuscle\nmuseum\nmushroom\nmusic\nmust\nmutual\nmyself\nmystery\nmyth\nnaive\nname\nnapkin\nnarrow\nnasty\nnation\nnature\nnear\nneck\nneed\nnegative\nneglect\nneither\nnephew\nnerve\nnest\nnet\nnetwork\nneutral\nnever\nnews\nnext\nnice\nnight\nnoble\nnoise\nnominee\nnoodle\nnormal\nnorth\nnose\nnotable\nnote\nnothing\nnotice\nnovel\nnow\nnuclear\nnumber\nnurse\nnut\noak\nobey\nobject\noblige\nobscure\nobserve\nobtain\nobvious\noccur\nocean\noctober\nodor\noff\noffer\noffice\noften\noil\nokay\nold\nolive\nolympic\nomit\nonce\none\nonion\nonline\nonly\nopen\nopera\nopinion\noppose\noption\norange\norbit\norchard\norder\nordinary\norgan\norient\noriginal\norphan\nostrich\nother\noutdoor\nouter\noutput\noutside\noval\noven\nover\nown\nowner\noxygen\noyster\nozone\npact\npaddle\npage\npair\npalace\npalm\npanda\npanel\npanic\npanther\npaper\nparade\nparent\npark\nparrot\nparty\npass\npatch\npath\npatient\npatrol\npattern\npause\npave\npayment\npeace\npeanut\npear\npeasant\npelican\npen\npenalty\npencil\npeople\npepper\nperfect\npermit\nperson\npet\nphone\nphoto\nphrase\nphysical\npiano\npicnic\npicture\npiece\npig\npigeon\npill\npilot\npink\npioneer\npipe\npistol\npitch\npizza\nplace\nplanet\nplastic\nplate\nplay\nplease\npledge\npluck\nplug\nplunge\npoem\npoet\npoint\npolar\npole\npolice\npond\npony\npool\npopular\nportion\nposition\npossible\npost\npotato\npottery\npoverty\npowder\npower\npractice\npraise\npredict\nprefer\nprepare\npresent\npretty\nprevent\nprice\npride\nprimary\nprint\npriority\nprison\nprivate\nprize\nproblem\nprocess\nproduce\nprofit\nprogram\nproject\npromote\nproof\nproperty\nprosper\nprotect\nproud\nprovide\npublic\npudding\npull\npulp\npulse\npumpkin\npunch\npupil\npuppy\npurchase\npurity\npurpose\npurse\npush\nput\npuzzle\npyramid\nquality\nquantum\nquarter\nquestion\nquick\nquit\nquiz\nquote\nrabbit\nraccoon\nrace\nrack\nradar\nradio\nrail\nrain\nraise\nrally\nramp\nranch\nrandom\nrange\nrapid\nrare\nrate\nrather\nraven\nraw\nrazor\nready\nreal\nreason\nrebel\nrebuild\nrecall\nreceive\nrecipe\nrecord\nrecycle\nreduce\nreflect\nreform\nrefuse\nregion\nregret\nregular\nreject\nrelax\nrelease\nrelief\nrely\nremain\nremember\nremind\nremove\nrender\nrenew\nrent\nreopen\nrepair\nrepeat\nreplace\nreport\nrequire\nrescue\nresemble\nresist\nresource\nresponse\nresult\nretire\nretreat\nreturn\nreunion\nreveal\nreview\nreward\nrhythm\nrib\nribbon\nrice\nrich\nride\nridge\nrifle\nright\nrigid\nring\nriot\nripple\nrisk\nritual\nrival\nriver\nroad\nroast\nrobot\nrobust\nrocket\nromance\nroof\nrookie\nroom\nrose\nrotate\nrough\nround\nroute\nroyal\nrubber\nrude\nrug\nrule\nrun\nrunway\nrural\nsad\nsaddle\nsadness\nsafe\nsail\nsalad\nsalmon\nsalon\nsalt\nsalute\nsame\nsample\nsand\nsatisfy\nsatoshi\nsauce\nsausage\nsave\nsay\nscale\nscan\nscare\nscatter\nscene\nscheme\nschool\nscience\nscissors\nscorpion\nscout\nscrap\nscreen\nscript\nscrub\nsea\nsearch\nseason\nseat\nsecond\nsecret\nsection\nsecurity\nseed\nseek\nsegment\nselect\nsell\nseminar\nsenior\nsense\nsentence\nseries\nservice\nsession\nsettle\nsetup\nseven\nshadow\nshaft\nshallow\nshare\nshed\nshell\nsheriff\nshield\nshift\nshine\nship\nshiver\nshock\nshoe\nshoot\nshop\nshort\nshoulder\nshove\nshrimp\nshrug\nshuffle\nshy\nsibling\nsick\nside\nsiege\nsight\nsign\nsilent\nsilk\nsilly\nsilver\nsimilar\nsimple\nsince\nsing\nsiren\nsister\nsituate\nsix\nsize\nskate\nsketch\nski\nskill\nskin\nskirt\nskull\nslab\nslam\nsleep\nslender\nslice\nslide\nslight\nslim\nslogan\nslot\nslow\nslush\nsmall\nsmart\nsmile\nsmoke\nsmooth\nsnack\nsnake\nsnap\nsniff\nsnow\nsoap\nsoccer\nsocial\nsock\nsoda\nsoft\nsolar\nsoldier\nsolid\nsolution\nsolve\nsomeone\nsong\nsoon\nsorry\nsort\nsoul\nsound\nsoup\nsource\nsouth\nspace\nspare\nspatial\nspawn\nspeak\nspecial\nspeed\nspell\nspend\nsphere\nspice\nspider\nspike\nspin\nspirit\nsplit\nspoil\nsponsor\nspoon\nsport\nspot\nspray\nspread\nspring\nspy\nsquare\nsqueeze\nsquirrel\nstable\nstadium\nstaff\nstage\nstairs\nstamp\nstand\nstart\nstate\nstay\nsteak\nsteel\nstem\nstep\nstereo\nstick\nstill\nsting\nstock\nstomach\nstone\nstool\nstory\nstove\nstrategy\nstreet\nstrike\nstrong\nstruggle\nstudent\nstuff\nstumble\nstyle\nsubject\nsubmit\nsubway\nsuccess\nsuch\nsudden\nsuffer\nsugar\nsuggest\nsuit\nsummer\nsun\nsunny\nsunset\nsuper\nsupply\nsupreme\nsure\nsurface\nsurge\nsurprise\nsurround\nsurvey\nsuspect\nsustain\nswallow\nswamp\nswap\nswarm\nswear\nsweet\nswift\nswim\nswing\nswitch\nsword\nsymbol\nsymptom\nsyrup\nsystem\ntable\ntackle\ntag\ntail\ntalent\ntalk\ntank\ntape\ntarget\ntask\ntaste\ntattoo\ntaxi\nteach\nteam\ntell\nten\ntenant\ntennis\ntent\nterm\ntest\ntext\nthank\nthat\ntheme\nthen\ntheory\nthere\nthey\nthing\nthis\nthought\nthree\nthrive\nthrow\nthumb\nthunder\nticket\ntide\ntiger\ntilt\ntimber\ntime\ntiny\ntip\ntired\ntissue\ntitle\ntoast\ntobacco\ntoday\ntoddler\ntoe\ntogether\ntoilet\ntoken\ntomato\ntomorrow\ntone\ntongue\ntonight\ntool\ntooth\ntop\ntopic\ntopple\ntorch\ntornado\ntortoise\ntoss\ntotal\ntourist\ntoward\ntower\ntown\ntoy\ntrack\ntrade\ntraffic\ntragic\ntrain\ntransfer\ntrap\ntrash\ntravel\ntray\ntreat\ntree\ntrend\ntrial\ntribe\ntrick\ntrigger\ntrim\ntrip\ntrophy\ntrouble\ntruck\ntrue\ntruly\ntrumpet\ntrust\ntruth\ntry\ntube\ntuition\ntumble\ntuna\ntunnel\nturkey\nturn\nturtle\ntwelve\ntwenty\ntwice\ntwin\ntwist\ntwo\ntype\ntypical\nugly\numbrella\nunable\nunaware\nuncle\nuncover\nunder\nundo\nunfair\nunfold\nunhappy\nuniform\nunique\nunit\nuniverse\nunknown\nunlock\nuntil\nunusual\nunveil\nupdate\nupgrade\nuphold\nupon\nupper\nupset\nurban\nurge\nusage\nuse\nused\nuseful\nuseless\nusual\nutility\nvacant\nvacuum\nvague\nvalid\nvalley\nvalve\nvan\nvanish\nvapor\nvarious\nvast\nvault\nvehicle\nvelvet\nvendor\nventure\nvenue\nverb\nverify\nversion\nvery\nvessel\nveteran\nviable\nvibrant\nvicious\nvictory\nvideo\nview\nvillage\nvintage\nviolin\nvirtual\nvirus\nvisa\nvisit\nvisual\nvital\nvivid\nvocal\nvoice\nvoid\nvolcano\nvolume\nvote\nvoyage\nwage\nwagon\nwait\nwalk\nwall\nwalnut\nwant\nwarfare\nwarm\nwarrior\nwash\nwasp\nwaste\nwater\nwave\nway\nwealth\nweapon\nwear\nweasel\nweather\nweb\nwedding\nweekend\nweird\nwelcome\nwest\nwet\nwhale\nwhat\nwheat\nwheel\nwhen\nwhere\nwhip\nwhisper\nwide\nwidth\nwife\nwild\nwill\nwin\nwindow\nwine\nwing\nwink\nwinner\nwinter\nwire\nwisdom\nwise\nwish\nwitness\nwolf\nwoman\nwonder\nwood\nwool\nword\nwork\nworld\nworry\nworth\nwrap\nwreck\nwrestle\nwrist\nwrite\nwrong\nyard\nyear\nyellow\nyou\nyoung\nyouth\nzebra\nzero\nzone\nzoo`.split('\\n');\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sha384 = exports.sha512_256 = exports.sha512_224 = exports.sha512 = exports.SHA512 = void 0;\nconst _sha2_js_1 = require(\"./_sha2.js\");\nconst _u64_js_1 = require(\"./_u64.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):\n// prettier-ignore\nconst [SHA512_Kh, SHA512_Kl] = _u64_js_1.default.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)));\n// Temporary buffer, not used to store anything between runs\nconst SHA512_W_H = new Uint32Array(80);\nconst SHA512_W_L = new Uint32Array(80);\nclass SHA512 extends _sha2_js_1.SHA2 {\n    constructor() {\n        super(128, 64, 16, false);\n        // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.\n        // Also looks cleaner and easier to verify with spec.\n        // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0x6a09e667 | 0;\n        this.Al = 0xf3bcc908 | 0;\n        this.Bh = 0xbb67ae85 | 0;\n        this.Bl = 0x84caa73b | 0;\n        this.Ch = 0x3c6ef372 | 0;\n        this.Cl = 0xfe94f82b | 0;\n        this.Dh = 0xa54ff53a | 0;\n        this.Dl = 0x5f1d36f1 | 0;\n        this.Eh = 0x510e527f | 0;\n        this.El = 0xade682d1 | 0;\n        this.Fh = 0x9b05688c | 0;\n        this.Fl = 0x2b3e6c1f | 0;\n        this.Gh = 0x1f83d9ab | 0;\n        this.Gl = 0xfb41bd6b | 0;\n        this.Hh = 0x5be0cd19 | 0;\n        this.Hl = 0x137e2179 | 0;\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = _u64_js_1.default.rotrSH(W15h, W15l, 1) ^ _u64_js_1.default.rotrSH(W15h, W15l, 8) ^ _u64_js_1.default.shrSH(W15h, W15l, 7);\n            const s0l = _u64_js_1.default.rotrSL(W15h, W15l, 1) ^ _u64_js_1.default.rotrSL(W15h, W15l, 8) ^ _u64_js_1.default.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_js_1.default.rotrSH(W2h, W2l, 19) ^ _u64_js_1.default.rotrBH(W2h, W2l, 61) ^ _u64_js_1.default.shrSH(W2h, W2l, 6);\n            const s1l = _u64_js_1.default.rotrSL(W2h, W2l, 19) ^ _u64_js_1.default.rotrBL(W2h, W2l, 61) ^ _u64_js_1.default.shrSL(W2h, W2l, 6);\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n            const SUMl = _u64_js_1.default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = _u64_js_1.default.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_js_1.default.rotrSH(Eh, El, 14) ^ _u64_js_1.default.rotrSH(Eh, El, 18) ^ _u64_js_1.default.rotrBH(Eh, El, 41);\n            const sigma1l = _u64_js_1.default.rotrSL(Eh, El, 14) ^ _u64_js_1.default.rotrSL(Eh, El, 18) ^ _u64_js_1.default.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_js_1.default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = _u64_js_1.default.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_js_1.default.rotrSH(Ah, Al, 28) ^ _u64_js_1.default.rotrBH(Ah, Al, 34) ^ _u64_js_1.default.rotrBH(Ah, Al, 39);\n            const sigma0l = _u64_js_1.default.rotrSL(Ah, Al, 28) ^ _u64_js_1.default.rotrBL(Ah, Al, 34) ^ _u64_js_1.default.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_js_1.default.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_js_1.default.add3L(T1l, sigma0l, MAJl);\n            Ah = _u64_js_1.default.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_js_1.default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = _u64_js_1.default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = _u64_js_1.default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = _u64_js_1.default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = _u64_js_1.default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = _u64_js_1.default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = _u64_js_1.default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = _u64_js_1.default.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        SHA512_W_H.fill(0);\n        SHA512_W_L.fill(0);\n    }\n    destroy() {\n        this.buffer.fill(0);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\nexports.SHA512 = SHA512;\nclass SHA512_224 extends SHA512 {\n    constructor() {\n        super();\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0x8c3d37c8 | 0;\n        this.Al = 0x19544da2 | 0;\n        this.Bh = 0x73e19966 | 0;\n        this.Bl = 0x89dcd4d6 | 0;\n        this.Ch = 0x1dfab7ae | 0;\n        this.Cl = 0x32ff9c82 | 0;\n        this.Dh = 0x679dd514 | 0;\n        this.Dl = 0x582f9fcf | 0;\n        this.Eh = 0x0f6d2b69 | 0;\n        this.El = 0x7bd44da8 | 0;\n        this.Fh = 0x77e36f73 | 0;\n        this.Fl = 0x04c48942 | 0;\n        this.Gh = 0x3f9d85a8 | 0;\n        this.Gl = 0x6a1d36c8 | 0;\n        this.Hh = 0x1112e6ad | 0;\n        this.Hl = 0x91d692a1 | 0;\n        this.outputLen = 28;\n    }\n}\nclass SHA512_256 extends SHA512 {\n    constructor() {\n        super();\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0x22312194 | 0;\n        this.Al = 0xfc2bf72c | 0;\n        this.Bh = 0x9f555fa3 | 0;\n        this.Bl = 0xc84c64c2 | 0;\n        this.Ch = 0x2393b86b | 0;\n        this.Cl = 0x6f53b151 | 0;\n        this.Dh = 0x96387719 | 0;\n        this.Dl = 0x5940eabd | 0;\n        this.Eh = 0x96283ee2 | 0;\n        this.El = 0xa88effe3 | 0;\n        this.Fh = 0xbe5e1e25 | 0;\n        this.Fl = 0x53863992 | 0;\n        this.Gh = 0x2b0199fc | 0;\n        this.Gl = 0x2c85b8aa | 0;\n        this.Hh = 0x0eb72ddc | 0;\n        this.Hl = 0x81c52ca2 | 0;\n        this.outputLen = 32;\n    }\n}\nclass SHA384 extends SHA512 {\n    constructor() {\n        super();\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0xcbbb9d5d | 0;\n        this.Al = 0xc1059ed8 | 0;\n        this.Bh = 0x629a292a | 0;\n        this.Bl = 0x367cd507 | 0;\n        this.Ch = 0x9159015a | 0;\n        this.Cl = 0x3070dd17 | 0;\n        this.Dh = 0x152fecd8 | 0;\n        this.Dl = 0xf70e5939 | 0;\n        this.Eh = 0x67332667 | 0;\n        this.El = 0xffc00b31 | 0;\n        this.Fh = 0x8eb44a87 | 0;\n        this.Fl = 0x68581511 | 0;\n        this.Gh = 0xdb0c2e0d | 0;\n        this.Gl = 0x64f98fa7 | 0;\n        this.Hh = 0x47b5481d | 0;\n        this.Hl = 0xbefa4fa4 | 0;\n        this.outputLen = 48;\n    }\n}\nexports.sha512 = (0, utils_js_1.wrapConstructor)(() => new SHA512());\nexports.sha512_224 = (0, utils_js_1.wrapConstructor)(() => new SHA512_224());\nexports.sha512_256 = (0, utils_js_1.wrapConstructor)(() => new SHA512_256());\nexports.sha384 = (0, utils_js_1.wrapConstructor)(() => new SHA384());\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\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__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\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};","export function number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`Wrong positive integer: ${n}`);\n}\nexport function bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`Expected boolean, not ${b}`);\n}\nexport function bytes(b, ...lengths) {\n    if (!(b instanceof Uint8Array))\n        throw new TypeError('Expected Uint8Array');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nexport function hash(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(hash.outputLen);\n    number(hash.blockLen);\n}\nexport function exists(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}\nexport function output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nconst assert = {\n    number,\n    bool,\n    bytes,\n    hash,\n    exists,\n    output,\n};\nexport default assert;\n","/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// The import here is via the package name. This is to ensure\n// that exports mapping/resolution does fall into place.\nimport { crypto } from '@noble/hashes/crypto';\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\n// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.\n// So, just to be sure not to corrupt anything.\nif (!isLE)\n    throw new Error('Non little-endian hardware is not supported');\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))\n */\nexport function bytesToHex(uint8a) {\n    // pre-caching improves the speed 6x\n    if (!(uint8a instanceof Uint8Array))\n        throw new Error('Uint8Array expected');\n    let hex = '';\n    for (let i = 0; i < uint8a.length; i++) {\n        hex += hexes[uint8a[i]];\n    }\n    return hex;\n}\n/**\n * @example hexToBytes('deadbeef')\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string') {\n        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\n    }\n    if (hex.length % 2)\n        throw new Error('hexToBytes: received invalid unpadded hex');\n    const array = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// There is no setImmediate in browser and setTimeout is slow. However, call to async function will return Promise\n// which will be fullfiled only on next scheduler queue processing step and this is exactly what we need.\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}\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string') {\n        throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);\n    }\n    return new TextEncoder().encode(str);\n}\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    if (!(data instanceof Uint8Array))\n        throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);\n    return data;\n}\n/**\n * Concats Uint8Array-s into one; like `Buffer.concat([buf1, buf2])`\n * @example concatBytes(buf1, buf2)\n */\nexport function concatBytes(...arrays) {\n    if (!arrays.every((a) => a instanceof Uint8Array))\n        throw new Error('Uint8Array list expected');\n    if (arrays.length === 1)\n        return arrays[0];\n    const length = arrays.reduce((a, arr) => a + arr.length, 0);\n    const result = new Uint8Array(length);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const arr = arrays[i];\n        result.set(arr, pad);\n        pad += arr.length;\n    }\n    return result;\n}\n// For runtime check if class implements interface\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\n// Check if object doens't have custom constructor (like Uint8Array/Array)\nconst isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))\n        throw new TypeError('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexport function wrapConstructor(hashConstructor) {\n    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();\n    const tmp = hashConstructor();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashConstructor();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/**\n * Secure PRNG\n */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto.web) {\n        return crypto.web.getRandomValues(new Uint8Array(bytesLength));\n    }\n    else if (crypto.node) {\n        return new Uint8Array(crypto.node.randomBytes(bytesLength).buffer);\n    }\n    else {\n        throw new Error(\"The environment doesn't have randomBytes function\");\n    }\n}\n","export const crypto = {\n    node: undefined,\n    web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\n};\n","import assert from './_assert.js';\nimport { Hash, toBytes } from './utils.js';\n// HMAC (RFC 2104)\nclass HMAC extends Hash {\n    constructor(hash, _key) {\n        super();\n        this.finished = false;\n        this.destroyed = false;\n        assert.hash(hash);\n        const key = toBytes(_key);\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new TypeError('Expected instance of class which extends utils.Hash');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        pad.fill(0);\n    }\n    update(buf) {\n        assert.exists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        assert.exists(this);\n        assert.bytes(out, this.outputLen);\n        this.finished = true;\n        this.iHash.digestInto(out);\n        this.oHash.update(out);\n        this.oHash.digestInto(out);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since key already in state and we don't know it.\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n */\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n","import assert from './_assert.js';\nimport { Hash, createView, toBytes } from './utils.js';\n// Polyfill for Safari 14\nfunction setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\n// Base SHA2 class (RFC 6234)\nexport class SHA2 extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        assert.exists(this);\n        const { view, buffer, blockLen } = this;\n        data = toBytes(data);\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        assert.exists(this);\n        assert.output(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        this.buffer.subarray(pos).fill(0);\n        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to || (to = new this.constructor());\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.length = length;\n        to.pos = pos;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n}\n","import { SHA2 } from './_sha2.js';\nimport { rotr, wrapConstructor } from './utils.js';\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = new Uint32Array([\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// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = new Uint32Array([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = new Uint32Array(64);\nclass SHA256 extends SHA2 {\n    constructor() {\n        super(64, 32, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = IV[0] | 0;\n        this.B = IV[1] | 0;\n        this.C = IV[2] | 0;\n        this.D = IV[3] | 0;\n        this.E = IV[4] | 0;\n        this.F = IV[5] | 0;\n        this.G = IV[6] | 0;\n        this.H = IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        SHA256_W.fill(0);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        this.buffer.fill(0);\n    }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n    constructor() {\n        super();\n        this.A = 0xc1059ed8 | 0;\n        this.B = 0x367cd507 | 0;\n        this.C = 0x3070dd17 | 0;\n        this.D = 0xf70e5939 | 0;\n        this.E = 0xffc00b31 | 0;\n        this.F = 0x68581511 | 0;\n        this.G = 0x64f98fa7 | 0;\n        this.H = 0xbefa4fa4 | 0;\n        this.outputLen = 28;\n    }\n}\n/**\n * SHA2-256 hash function\n * @param message - data that would be hashed\n */\nexport const sha256 = wrapConstructor(() => new SHA256());\nexport const sha224 = wrapConstructor(() => new SHA224());\n","/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */\nimport * as nodeCrypto from 'crypto';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst _3n = BigInt(3);\nconst _8n = BigInt(8);\nconst CURVE = Object.freeze({\n    a: _0n,\n    b: BigInt(7),\n    P: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),\n    n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),\n    h: _1n,\n    Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),\n    Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),\n    beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n});\nconst divNearest = (a, b) => (a + b / _2n) / b;\nconst endo = {\n    beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n    splitScalar(k) {\n        const { n } = CURVE;\n        const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');\n        const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');\n        const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');\n        const b2 = a1;\n        const POW_2_128 = BigInt('0x100000000000000000000000000000000');\n        const c1 = divNearest(b2 * k, n);\n        const c2 = divNearest(-b1 * k, n);\n        let k1 = mod(k - c1 * a1 - c2 * a2, n);\n        let k2 = mod(-c1 * b1 - c2 * b2, n);\n        const k1neg = k1 > POW_2_128;\n        const k2neg = k2 > POW_2_128;\n        if (k1neg)\n            k1 = n - k1;\n        if (k2neg)\n            k2 = n - k2;\n        if (k1 > POW_2_128 || k2 > POW_2_128) {\n            throw new Error('splitScalarEndo: Endomorphism failed, k=' + k);\n        }\n        return { k1neg, k1, k2neg, k2 };\n    },\n};\nconst fieldLen = 32;\nconst groupLen = 32;\nconst hashLen = 32;\nconst compressedLen = fieldLen + 1;\nconst uncompressedLen = 2 * fieldLen + 1;\nexport { CURVE };\nfunction weierstrass(x) {\n    const { a, b } = CURVE;\n    const x2 = mod(x * x);\n    const x3 = mod(x2 * x);\n    return mod(x3 + a * x + b);\n}\nconst USE_ENDOMORPHISM = CURVE.a === _0n;\nclass ShaError extends Error {\n    constructor(message) {\n        super(message);\n    }\n}\nfunction assertJacPoint(other) {\n    if (!(other instanceof JacobianPoint))\n        throw new TypeError('JacobianPoint expected');\n}\nclass JacobianPoint {\n    constructor(x, y, z) {\n        this.x = x;\n        this.y = y;\n        this.z = z;\n    }\n    static fromAffine(p) {\n        if (!(p instanceof Point)) {\n            throw new TypeError('JacobianPoint#fromAffine: expected Point');\n        }\n        if (p.equals(Point.ZERO))\n            return JacobianPoint.ZERO;\n        return new JacobianPoint(p.x, p.y, _1n);\n    }\n    static toAffineBatch(points) {\n        const toInv = invertBatch(points.map((p) => p.z));\n        return points.map((p, i) => p.toAffine(toInv[i]));\n    }\n    static normalizeZ(points) {\n        return JacobianPoint.toAffineBatch(points).map(JacobianPoint.fromAffine);\n    }\n    equals(other) {\n        assertJacPoint(other);\n        const { x: X1, y: Y1, z: Z1 } = this;\n        const { x: X2, y: Y2, z: Z2 } = other;\n        const Z1Z1 = mod(Z1 * Z1);\n        const Z2Z2 = mod(Z2 * Z2);\n        const U1 = mod(X1 * Z2Z2);\n        const U2 = mod(X2 * Z1Z1);\n        const S1 = mod(mod(Y1 * Z2) * Z2Z2);\n        const S2 = mod(mod(Y2 * Z1) * Z1Z1);\n        return U1 === U2 && S1 === S2;\n    }\n    negate() {\n        return new JacobianPoint(this.x, mod(-this.y), this.z);\n    }\n    double() {\n        const { x: X1, y: Y1, z: Z1 } = this;\n        const A = mod(X1 * X1);\n        const B = mod(Y1 * Y1);\n        const C = mod(B * B);\n        const x1b = X1 + B;\n        const D = mod(_2n * (mod(x1b * x1b) - A - C));\n        const E = mod(_3n * A);\n        const F = mod(E * E);\n        const X3 = mod(F - _2n * D);\n        const Y3 = mod(E * (D - X3) - _8n * C);\n        const Z3 = mod(_2n * Y1 * Z1);\n        return new JacobianPoint(X3, Y3, Z3);\n    }\n    add(other) {\n        assertJacPoint(other);\n        const { x: X1, y: Y1, z: Z1 } = this;\n        const { x: X2, y: Y2, z: Z2 } = other;\n        if (X2 === _0n || Y2 === _0n)\n            return this;\n        if (X1 === _0n || Y1 === _0n)\n            return other;\n        const Z1Z1 = mod(Z1 * Z1);\n        const Z2Z2 = mod(Z2 * Z2);\n        const U1 = mod(X1 * Z2Z2);\n        const U2 = mod(X2 * Z1Z1);\n        const S1 = mod(mod(Y1 * Z2) * Z2Z2);\n        const S2 = mod(mod(Y2 * Z1) * Z1Z1);\n        const H = mod(U2 - U1);\n        const r = mod(S2 - S1);\n        if (H === _0n) {\n            if (r === _0n) {\n                return this.double();\n            }\n            else {\n                return JacobianPoint.ZERO;\n            }\n        }\n        const HH = mod(H * H);\n        const HHH = mod(H * HH);\n        const V = mod(U1 * HH);\n        const X3 = mod(r * r - HHH - _2n * V);\n        const Y3 = mod(r * (V - X3) - S1 * HHH);\n        const Z3 = mod(Z1 * Z2 * H);\n        return new JacobianPoint(X3, Y3, Z3);\n    }\n    subtract(other) {\n        return this.add(other.negate());\n    }\n    multiplyUnsafe(scalar) {\n        const P0 = JacobianPoint.ZERO;\n        if (typeof scalar === 'bigint' && scalar === _0n)\n            return P0;\n        let n = normalizeScalar(scalar);\n        if (n === _1n)\n            return this;\n        if (!USE_ENDOMORPHISM) {\n            let p = P0;\n            let d = this;\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        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n        let k1p = P0;\n        let k2p = P0;\n        let d = this;\n        while (k1 > _0n || k2 > _0n) {\n            if (k1 & _1n)\n                k1p = k1p.add(d);\n            if (k2 & _1n)\n                k2p = k2p.add(d);\n            d = d.double();\n            k1 >>= _1n;\n            k2 >>= _1n;\n        }\n        if (k1neg)\n            k1p = k1p.negate();\n        if (k2neg)\n            k2p = k2p.negate();\n        k2p = new JacobianPoint(mod(k2p.x * endo.beta), k2p.y, k2p.z);\n        return k1p.add(k2p);\n    }\n    precomputeWindow(W) {\n        const windows = USE_ENDOMORPHISM ? 128 / W + 1 : 256 / W + 1;\n        const points = [];\n        let p = this;\n        let base = p;\n        for (let window = 0; window < windows; window++) {\n            base = p;\n            points.push(base);\n            for (let i = 1; i < 2 ** (W - 1); i++) {\n                base = base.add(p);\n                points.push(base);\n            }\n            p = base.double();\n        }\n        return points;\n    }\n    wNAF(n, affinePoint) {\n        if (!affinePoint && this.equals(JacobianPoint.BASE))\n            affinePoint = Point.BASE;\n        const W = (affinePoint && affinePoint._WINDOW_SIZE) || 1;\n        if (256 % W) {\n            throw new Error('Point#wNAF: Invalid precomputation window, must be power of 2');\n        }\n        let precomputes = affinePoint && pointPrecomputes.get(affinePoint);\n        if (!precomputes) {\n            precomputes = this.precomputeWindow(W);\n            if (affinePoint && W !== 1) {\n                precomputes = JacobianPoint.normalizeZ(precomputes);\n                pointPrecomputes.set(affinePoint, precomputes);\n            }\n        }\n        let p = JacobianPoint.ZERO;\n        let f = JacobianPoint.BASE;\n        const windows = 1 + (USE_ENDOMORPHISM ? 128 / W : 256 / W);\n        const windowSize = 2 ** (W - 1);\n        const mask = BigInt(2 ** W - 1);\n        const maxNumber = 2 ** W;\n        const shiftBy = BigInt(W);\n        for (let window = 0; window < windows; window++) {\n            const offset = window * windowSize;\n            let wbits = Number(n & mask);\n            n >>= shiftBy;\n            if (wbits > windowSize) {\n                wbits -= maxNumber;\n                n += _1n;\n            }\n            const offset1 = offset;\n            const offset2 = offset + Math.abs(wbits) - 1;\n            const cond1 = window % 2 !== 0;\n            const cond2 = wbits < 0;\n            if (wbits === 0) {\n                f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n            }\n            else {\n                p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n            }\n        }\n        return { p, f };\n    }\n    multiply(scalar, affinePoint) {\n        let n = normalizeScalar(scalar);\n        let point;\n        let fake;\n        if (USE_ENDOMORPHISM) {\n            const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n            let { p: k1p, f: f1p } = this.wNAF(k1, affinePoint);\n            let { p: k2p, f: f2p } = this.wNAF(k2, affinePoint);\n            k1p = constTimeNegate(k1neg, k1p);\n            k2p = constTimeNegate(k2neg, k2p);\n            k2p = new JacobianPoint(mod(k2p.x * endo.beta), k2p.y, k2p.z);\n            point = k1p.add(k2p);\n            fake = f1p.add(f2p);\n        }\n        else {\n            const { p, f } = this.wNAF(n, affinePoint);\n            point = p;\n            fake = f;\n        }\n        return JacobianPoint.normalizeZ([point, fake])[0];\n    }\n    toAffine(invZ) {\n        const { x, y, z } = this;\n        const is0 = this.equals(JacobianPoint.ZERO);\n        if (invZ == null)\n            invZ = is0 ? _8n : invert(z);\n        const iz1 = invZ;\n        const iz2 = mod(iz1 * iz1);\n        const iz3 = mod(iz2 * iz1);\n        const ax = mod(x * iz2);\n        const ay = mod(y * iz3);\n        const zz = mod(z * iz1);\n        if (is0)\n            return Point.ZERO;\n        if (zz !== _1n)\n            throw new Error('invZ was invalid');\n        return new Point(ax, ay);\n    }\n}\nJacobianPoint.BASE = new JacobianPoint(CURVE.Gx, CURVE.Gy, _1n);\nJacobianPoint.ZERO = new JacobianPoint(_0n, _1n, _0n);\nfunction constTimeNegate(condition, item) {\n    const neg = item.negate();\n    return condition ? neg : item;\n}\nconst pointPrecomputes = new WeakMap();\nexport class Point {\n    constructor(x, y) {\n        this.x = x;\n        this.y = y;\n    }\n    _setWindowSize(windowSize) {\n        this._WINDOW_SIZE = windowSize;\n        pointPrecomputes.delete(this);\n    }\n    hasEvenY() {\n        return this.y % _2n === _0n;\n    }\n    static fromCompressedHex(bytes) {\n        const isShort = bytes.length === 32;\n        const x = bytesToNumber(isShort ? bytes : bytes.subarray(1));\n        if (!isValidFieldElement(x))\n            throw new Error('Point is not on curve');\n        const y2 = weierstrass(x);\n        let y = sqrtMod(y2);\n        const isYOdd = (y & _1n) === _1n;\n        if (isShort) {\n            if (isYOdd)\n                y = mod(-y);\n        }\n        else {\n            const isFirstByteOdd = (bytes[0] & 1) === 1;\n            if (isFirstByteOdd !== isYOdd)\n                y = mod(-y);\n        }\n        const point = new Point(x, y);\n        point.assertValidity();\n        return point;\n    }\n    static fromUncompressedHex(bytes) {\n        const x = bytesToNumber(bytes.subarray(1, fieldLen + 1));\n        const y = bytesToNumber(bytes.subarray(fieldLen + 1, fieldLen * 2 + 1));\n        const point = new Point(x, y);\n        point.assertValidity();\n        return point;\n    }\n    static fromHex(hex) {\n        const bytes = ensureBytes(hex);\n        const len = bytes.length;\n        const header = bytes[0];\n        if (len === fieldLen)\n            return this.fromCompressedHex(bytes);\n        if (len === compressedLen && (header === 0x02 || header === 0x03)) {\n            return this.fromCompressedHex(bytes);\n        }\n        if (len === uncompressedLen && header === 0x04)\n            return this.fromUncompressedHex(bytes);\n        throw new Error(`Point.fromHex: received invalid point. Expected 32-${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes, not ${len}`);\n    }\n    static fromPrivateKey(privateKey) {\n        return Point.BASE.multiply(normalizePrivateKey(privateKey));\n    }\n    static fromSignature(msgHash, signature, recovery) {\n        const { r, s } = normalizeSignature(signature);\n        if (![0, 1, 2, 3].includes(recovery))\n            throw new Error('Cannot recover: invalid recovery bit');\n        const h = truncateHash(ensureBytes(msgHash));\n        const { n } = CURVE;\n        const radj = recovery === 2 || recovery === 3 ? r + n : r;\n        const rinv = invert(radj, n);\n        const u1 = mod(-h * rinv, n);\n        const u2 = mod(s * rinv, n);\n        const prefix = recovery & 1 ? '03' : '02';\n        const R = Point.fromHex(prefix + numTo32bStr(radj));\n        const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);\n        if (!Q)\n            throw new Error('Cannot recover signature: point at infinify');\n        Q.assertValidity();\n        return Q;\n    }\n    toRawBytes(isCompressed = false) {\n        return hexToBytes(this.toHex(isCompressed));\n    }\n    toHex(isCompressed = false) {\n        const x = numTo32bStr(this.x);\n        if (isCompressed) {\n            const prefix = this.hasEvenY() ? '02' : '03';\n            return `${prefix}${x}`;\n        }\n        else {\n            return `04${x}${numTo32bStr(this.y)}`;\n        }\n    }\n    toHexX() {\n        return this.toHex(true).slice(2);\n    }\n    toRawX() {\n        return this.toRawBytes(true).slice(1);\n    }\n    assertValidity() {\n        const msg = 'Point is not on elliptic curve';\n        const { x, y } = this;\n        if (!isValidFieldElement(x) || !isValidFieldElement(y))\n            throw new Error(msg);\n        const left = mod(y * y);\n        const right = weierstrass(x);\n        if (mod(left - right) !== _0n)\n            throw new Error(msg);\n    }\n    equals(other) {\n        return this.x === other.x && this.y === other.y;\n    }\n    negate() {\n        return new Point(this.x, mod(-this.y));\n    }\n    double() {\n        return JacobianPoint.fromAffine(this).double().toAffine();\n    }\n    add(other) {\n        return JacobianPoint.fromAffine(this).add(JacobianPoint.fromAffine(other)).toAffine();\n    }\n    subtract(other) {\n        return this.add(other.negate());\n    }\n    multiply(scalar) {\n        return JacobianPoint.fromAffine(this).multiply(scalar, this).toAffine();\n    }\n    multiplyAndAddUnsafe(Q, a, b) {\n        const P = JacobianPoint.fromAffine(this);\n        const aP = a === _0n || a === _1n || this !== Point.BASE ? P.multiplyUnsafe(a) : P.multiply(a);\n        const bQ = JacobianPoint.fromAffine(Q).multiplyUnsafe(b);\n        const sum = aP.add(bQ);\n        return sum.equals(JacobianPoint.ZERO) ? undefined : sum.toAffine();\n    }\n}\nPoint.BASE = new Point(CURVE.Gx, CURVE.Gy);\nPoint.ZERO = new Point(_0n, _0n);\nfunction sliceDER(s) {\n    return Number.parseInt(s[0], 16) >= 8 ? '00' + s : s;\n}\nfunction parseDERInt(data) {\n    if (data.length < 2 || data[0] !== 0x02) {\n        throw new Error(`Invalid signature integer tag: ${bytesToHex(data)}`);\n    }\n    const len = data[1];\n    const res = data.subarray(2, len + 2);\n    if (!len || res.length !== len) {\n        throw new Error(`Invalid signature integer: wrong length`);\n    }\n    if (res[0] === 0x00 && res[1] <= 0x7f) {\n        throw new Error('Invalid signature integer: trailing length');\n    }\n    return { data: bytesToNumber(res), left: data.subarray(len + 2) };\n}\nfunction parseDERSignature(data) {\n    if (data.length < 2 || data[0] != 0x30) {\n        throw new Error(`Invalid signature tag: ${bytesToHex(data)}`);\n    }\n    if (data[1] !== data.length - 2) {\n        throw new Error('Invalid signature: incorrect length');\n    }\n    const { data: r, left: sBytes } = parseDERInt(data.subarray(2));\n    const { data: s, left: rBytesLeft } = parseDERInt(sBytes);\n    if (rBytesLeft.length) {\n        throw new Error(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`);\n    }\n    return { r, s };\n}\nexport class Signature {\n    constructor(r, s) {\n        this.r = r;\n        this.s = s;\n        this.assertValidity();\n    }\n    static fromCompact(hex) {\n        const arr = hex instanceof Uint8Array;\n        const name = 'Signature.fromCompact';\n        if (typeof hex !== 'string' && !arr)\n            throw new TypeError(`${name}: Expected string or Uint8Array`);\n        const str = arr ? bytesToHex(hex) : hex;\n        if (str.length !== 128)\n            throw new Error(`${name}: Expected 64-byte hex`);\n        return new Signature(hexToNumber(str.slice(0, 64)), hexToNumber(str.slice(64, 128)));\n    }\n    static fromDER(hex) {\n        const arr = hex instanceof Uint8Array;\n        if (typeof hex !== 'string' && !arr)\n            throw new TypeError(`Signature.fromDER: Expected string or Uint8Array`);\n        const { r, s } = parseDERSignature(arr ? hex : hexToBytes(hex));\n        return new Signature(r, s);\n    }\n    static fromHex(hex) {\n        return this.fromDER(hex);\n    }\n    assertValidity() {\n        const { r, s } = this;\n        if (!isWithinCurveOrder(r))\n            throw new Error('Invalid Signature: r must be 0 < r < n');\n        if (!isWithinCurveOrder(s))\n            throw new Error('Invalid Signature: s must be 0 < s < n');\n    }\n    hasHighS() {\n        const HALF = CURVE.n >> _1n;\n        return this.s > HALF;\n    }\n    normalizeS() {\n        return this.hasHighS() ? new Signature(this.r, mod(-this.s, CURVE.n)) : this;\n    }\n    toDERRawBytes() {\n        return hexToBytes(this.toDERHex());\n    }\n    toDERHex() {\n        const sHex = sliceDER(numberToHexUnpadded(this.s));\n        const rHex = sliceDER(numberToHexUnpadded(this.r));\n        const sHexL = sHex.length / 2;\n        const rHexL = rHex.length / 2;\n        const sLen = numberToHexUnpadded(sHexL);\n        const rLen = numberToHexUnpadded(rHexL);\n        const length = numberToHexUnpadded(rHexL + sHexL + 4);\n        return `30${length}02${rLen}${rHex}02${sLen}${sHex}`;\n    }\n    toRawBytes() {\n        return this.toDERRawBytes();\n    }\n    toHex() {\n        return this.toDERHex();\n    }\n    toCompactRawBytes() {\n        return hexToBytes(this.toCompactHex());\n    }\n    toCompactHex() {\n        return numTo32bStr(this.r) + numTo32bStr(this.s);\n    }\n}\nfunction concatBytes(...arrays) {\n    if (!arrays.every((b) => b instanceof Uint8Array))\n        throw new Error('Uint8Array list expected');\n    if (arrays.length === 1)\n        return arrays[0];\n    const length = arrays.reduce((a, arr) => a + arr.length, 0);\n    const result = new Uint8Array(length);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const arr = arrays[i];\n        result.set(arr, pad);\n        pad += arr.length;\n    }\n    return result;\n}\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\nfunction bytesToHex(uint8a) {\n    if (!(uint8a instanceof Uint8Array))\n        throw new Error('Expected Uint8Array');\n    let hex = '';\n    for (let i = 0; i < uint8a.length; i++) {\n        hex += hexes[uint8a[i]];\n    }\n    return hex;\n}\nconst POW_2_256 = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');\nfunction numTo32bStr(num) {\n    if (typeof num !== 'bigint')\n        throw new Error('Expected bigint');\n    if (!(_0n <= num && num < POW_2_256))\n        throw new Error('Expected number 0 <= n < 2^256');\n    return num.toString(16).padStart(64, '0');\n}\nfunction numTo32b(num) {\n    const b = hexToBytes(numTo32bStr(num));\n    if (b.length !== 32)\n        throw new Error('Error: expected 32 bytes');\n    return b;\n}\nfunction numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? `0${hex}` : hex;\n}\nfunction hexToNumber(hex) {\n    if (typeof hex !== 'string') {\n        throw new TypeError('hexToNumber: expected string, got ' + typeof hex);\n    }\n    return BigInt(`0x${hex}`);\n}\nfunction hexToBytes(hex) {\n    if (typeof hex !== 'string') {\n        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\n    }\n    if (hex.length % 2)\n        throw new Error('hexToBytes: received invalid unpadded hex' + hex.length);\n    const array = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\nfunction bytesToNumber(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nfunction ensureBytes(hex) {\n    return hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);\n}\nfunction normalizeScalar(num) {\n    if (typeof num === 'number' && Number.isSafeInteger(num) && num > 0)\n        return BigInt(num);\n    if (typeof num === 'bigint' && isWithinCurveOrder(num))\n        return num;\n    throw new TypeError('Expected valid private scalar: 0 < scalar < curve.n');\n}\nfunction mod(a, b = CURVE.P) {\n    const result = a % b;\n    return result >= _0n ? result : b + result;\n}\nfunction pow2(x, power) {\n    const { P } = CURVE;\n    let res = x;\n    while (power-- > _0n) {\n        res *= res;\n        res %= P;\n    }\n    return res;\n}\nfunction sqrtMod(x) {\n    const { P } = CURVE;\n    const _6n = BigInt(6);\n    const _11n = BigInt(11);\n    const _22n = BigInt(22);\n    const _23n = BigInt(23);\n    const _44n = BigInt(44);\n    const _88n = BigInt(88);\n    const b2 = (x * x * x) % P;\n    const b3 = (b2 * b2 * x) % P;\n    const b6 = (pow2(b3, _3n) * b3) % P;\n    const b9 = (pow2(b6, _3n) * b3) % P;\n    const b11 = (pow2(b9, _2n) * b2) % P;\n    const b22 = (pow2(b11, _11n) * b11) % P;\n    const b44 = (pow2(b22, _22n) * b22) % P;\n    const b88 = (pow2(b44, _44n) * b44) % P;\n    const b176 = (pow2(b88, _88n) * b88) % P;\n    const b220 = (pow2(b176, _44n) * b44) % P;\n    const b223 = (pow2(b220, _3n) * b3) % P;\n    const t1 = (pow2(b223, _23n) * b22) % P;\n    const t2 = (pow2(t1, _6n) * b2) % P;\n    const rt = pow2(t2, _2n);\n    const xc = (rt * rt) % P;\n    if (xc !== x)\n        throw new Error('Cannot find square root');\n    return rt;\n}\nfunction invert(number, modulo = CURVE.P) {\n    if (number === _0n || modulo <= _0n) {\n        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\n    }\n    let a = mod(number, modulo);\n    let b = modulo;\n    let x = _0n, y = _1n, u = _1n, v = _0n;\n    while (a !== _0n) {\n        const q = b / a;\n        const r = b % a;\n        const m = x - u * q;\n        const n = y - v * q;\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 invertBatch(nums, p = CURVE.P) {\n    const scratch = new Array(nums.length);\n    const lastMultiplied = nums.reduce((acc, num, i) => {\n        if (num === _0n)\n            return acc;\n        scratch[i] = acc;\n        return mod(acc * num, p);\n    }, _1n);\n    const inverted = invert(lastMultiplied, p);\n    nums.reduceRight((acc, num, i) => {\n        if (num === _0n)\n            return acc;\n        scratch[i] = mod(acc * scratch[i], p);\n        return mod(acc * num, p);\n    }, inverted);\n    return scratch;\n}\nfunction bits2int_2(bytes) {\n    const delta = bytes.length * 8 - groupLen * 8;\n    const num = bytesToNumber(bytes);\n    return delta > 0 ? num >> BigInt(delta) : num;\n}\nfunction truncateHash(hash, truncateOnly = false) {\n    const h = bits2int_2(hash);\n    if (truncateOnly)\n        return h;\n    const { n } = CURVE;\n    return h >= n ? h - n : h;\n}\nlet _sha256Sync;\nlet _hmacSha256Sync;\nclass HmacDrbg {\n    constructor(hashLen, qByteLen) {\n        this.hashLen = hashLen;\n        this.qByteLen = qByteLen;\n        if (typeof hashLen !== 'number' || hashLen < 2)\n            throw new Error('hashLen must be a number');\n        if (typeof qByteLen !== 'number' || qByteLen < 2)\n            throw new Error('qByteLen must be a number');\n        this.v = new Uint8Array(hashLen).fill(1);\n        this.k = new Uint8Array(hashLen).fill(0);\n        this.counter = 0;\n    }\n    hmac(...values) {\n        return utils.hmacSha256(this.k, ...values);\n    }\n    hmacSync(...values) {\n        return _hmacSha256Sync(this.k, ...values);\n    }\n    checkSync() {\n        if (typeof _hmacSha256Sync !== 'function')\n            throw new ShaError('hmacSha256Sync needs to be set');\n    }\n    incr() {\n        if (this.counter >= 1000)\n            throw new Error('Tried 1,000 k values for sign(), all were invalid');\n        this.counter += 1;\n    }\n    async reseed(seed = new Uint8Array()) {\n        this.k = await this.hmac(this.v, Uint8Array.from([0x00]), seed);\n        this.v = await this.hmac(this.v);\n        if (seed.length === 0)\n            return;\n        this.k = await this.hmac(this.v, Uint8Array.from([0x01]), seed);\n        this.v = await this.hmac(this.v);\n    }\n    reseedSync(seed = new Uint8Array()) {\n        this.checkSync();\n        this.k = this.hmacSync(this.v, Uint8Array.from([0x00]), seed);\n        this.v = this.hmacSync(this.v);\n        if (seed.length === 0)\n            return;\n        this.k = this.hmacSync(this.v, Uint8Array.from([0x01]), seed);\n        this.v = this.hmacSync(this.v);\n    }\n    async generate() {\n        this.incr();\n        let len = 0;\n        const out = [];\n        while (len < this.qByteLen) {\n            this.v = await this.hmac(this.v);\n            const sl = this.v.slice();\n            out.push(sl);\n            len += this.v.length;\n        }\n        return concatBytes(...out);\n    }\n    generateSync() {\n        this.checkSync();\n        this.incr();\n        let len = 0;\n        const out = [];\n        while (len < this.qByteLen) {\n            this.v = this.hmacSync(this.v);\n            const sl = this.v.slice();\n            out.push(sl);\n            len += this.v.length;\n        }\n        return concatBytes(...out);\n    }\n}\nfunction isWithinCurveOrder(num) {\n    return _0n < num && num < CURVE.n;\n}\nfunction isValidFieldElement(num) {\n    return _0n < num && num < CURVE.P;\n}\nfunction kmdToSig(kBytes, m, d, lowS = true) {\n    const { n } = CURVE;\n    const k = truncateHash(kBytes, true);\n    if (!isWithinCurveOrder(k))\n        return;\n    const kinv = invert(k, n);\n    const q = Point.BASE.multiply(k);\n    const r = mod(q.x, n);\n    if (r === _0n)\n        return;\n    const s = mod(kinv * mod(m + d * r, n), n);\n    if (s === _0n)\n        return;\n    let sig = new Signature(r, s);\n    let recovery = (q.x === sig.r ? 0 : 2) | Number(q.y & _1n);\n    if (lowS && sig.hasHighS()) {\n        sig = sig.normalizeS();\n        recovery ^= 1;\n    }\n    return { sig, recovery };\n}\nfunction normalizePrivateKey(key) {\n    let num;\n    if (typeof key === 'bigint') {\n        num = key;\n    }\n    else if (typeof key === 'number' && Number.isSafeInteger(key) && key > 0) {\n        num = BigInt(key);\n    }\n    else if (typeof key === 'string') {\n        if (key.length !== 2 * groupLen)\n            throw new Error('Expected 32 bytes of private key');\n        num = hexToNumber(key);\n    }\n    else if (key instanceof Uint8Array) {\n        if (key.length !== groupLen)\n            throw new Error('Expected 32 bytes of private key');\n        num = bytesToNumber(key);\n    }\n    else {\n        throw new TypeError('Expected valid private key');\n    }\n    if (!isWithinCurveOrder(num))\n        throw new Error('Expected private key: 0 < key < n');\n    return num;\n}\nfunction normalizePublicKey(publicKey) {\n    if (publicKey instanceof Point) {\n        publicKey.assertValidity();\n        return publicKey;\n    }\n    else {\n        return Point.fromHex(publicKey);\n    }\n}\nfunction normalizeSignature(signature) {\n    if (signature instanceof Signature) {\n        signature.assertValidity();\n        return signature;\n    }\n    try {\n        return Signature.fromDER(signature);\n    }\n    catch (error) {\n        return Signature.fromCompact(signature);\n    }\n}\nexport function getPublicKey(privateKey, isCompressed = false) {\n    return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\n}\nexport function recoverPublicKey(msgHash, signature, recovery, isCompressed = false) {\n    return Point.fromSignature(msgHash, signature, recovery).toRawBytes(isCompressed);\n}\nfunction isProbPub(item) {\n    const arr = item instanceof Uint8Array;\n    const str = typeof item === 'string';\n    const len = (arr || str) && item.length;\n    if (arr)\n        return len === compressedLen || len === uncompressedLen;\n    if (str)\n        return len === compressedLen * 2 || len === uncompressedLen * 2;\n    if (item instanceof Point)\n        return true;\n    return false;\n}\nexport function getSharedSecret(privateA, publicB, isCompressed = false) {\n    if (isProbPub(privateA))\n        throw new TypeError('getSharedSecret: first arg must be private key');\n    if (!isProbPub(publicB))\n        throw new TypeError('getSharedSecret: second arg must be public key');\n    const b = normalizePublicKey(publicB);\n    b.assertValidity();\n    return b.multiply(normalizePrivateKey(privateA)).toRawBytes(isCompressed);\n}\nfunction bits2int(bytes) {\n    const slice = bytes.length > fieldLen ? bytes.slice(0, fieldLen) : bytes;\n    return bytesToNumber(slice);\n}\nfunction bits2octets(bytes) {\n    const z1 = bits2int(bytes);\n    const z2 = mod(z1, CURVE.n);\n    return int2octets(z2 < _0n ? z1 : z2);\n}\nfunction int2octets(num) {\n    return numTo32b(num);\n}\nfunction initSigArgs(msgHash, privateKey, extraEntropy) {\n    if (msgHash == null)\n        throw new Error(`sign: expected valid message hash, not \"${msgHash}\"`);\n    const h1 = ensureBytes(msgHash);\n    const d = normalizePrivateKey(privateKey);\n    const seedArgs = [int2octets(d), bits2octets(h1)];\n    if (extraEntropy != null) {\n        if (extraEntropy === true)\n            extraEntropy = utils.randomBytes(fieldLen);\n        const e = ensureBytes(extraEntropy);\n        if (e.length !== fieldLen)\n            throw new Error(`sign: Expected ${fieldLen} bytes of extra data`);\n        seedArgs.push(e);\n    }\n    const seed = concatBytes(...seedArgs);\n    const m = bits2int(h1);\n    return { seed, m, d };\n}\nfunction finalizeSig(recSig, opts) {\n    const { sig, recovery } = recSig;\n    const { der, recovered } = Object.assign({ canonical: true, der: true }, opts);\n    const hashed = der ? sig.toDERRawBytes() : sig.toCompactRawBytes();\n    return recovered ? [hashed, recovery] : hashed;\n}\nasync function sign(msgHash, privKey, opts = {}) {\n    const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);\n    const drbg = new HmacDrbg(hashLen, groupLen);\n    await drbg.reseed(seed);\n    let sig;\n    while (!(sig = kmdToSig(await drbg.generate(), m, d, opts.canonical)))\n        await drbg.reseed();\n    return finalizeSig(sig, opts);\n}\nfunction signSync(msgHash, privKey, opts = {}) {\n    const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);\n    const drbg = new HmacDrbg(hashLen, groupLen);\n    drbg.reseedSync(seed);\n    let sig;\n    while (!(sig = kmdToSig(drbg.generateSync(), m, d, opts.canonical)))\n        drbg.reseedSync();\n    return finalizeSig(sig, opts);\n}\nexport { sign, signSync };\nconst vopts = { strict: true };\nexport function verify(signature, msgHash, publicKey, opts = vopts) {\n    let sig;\n    try {\n        sig = normalizeSignature(signature);\n        msgHash = ensureBytes(msgHash);\n    }\n    catch (error) {\n        return false;\n    }\n    const { r, s } = sig;\n    if (opts.strict && sig.hasHighS())\n        return false;\n    const h = truncateHash(msgHash);\n    let P;\n    try {\n        P = normalizePublicKey(publicKey);\n    }\n    catch (error) {\n        return false;\n    }\n    const { n } = CURVE;\n    const sinv = invert(s, n);\n    const u1 = mod(h * sinv, n);\n    const u2 = mod(r * sinv, n);\n    const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2);\n    if (!R)\n        return false;\n    const v = mod(R.x, n);\n    return v === r;\n}\nfunction schnorrChallengeFinalize(ch) {\n    return mod(bytesToNumber(ch), CURVE.n);\n}\nclass SchnorrSignature {\n    constructor(r, s) {\n        this.r = r;\n        this.s = s;\n        this.assertValidity();\n    }\n    static fromHex(hex) {\n        const bytes = ensureBytes(hex);\n        if (bytes.length !== 64)\n            throw new TypeError(`SchnorrSignature.fromHex: expected 64 bytes, not ${bytes.length}`);\n        const r = bytesToNumber(bytes.subarray(0, 32));\n        const s = bytesToNumber(bytes.subarray(32, 64));\n        return new SchnorrSignature(r, s);\n    }\n    assertValidity() {\n        const { r, s } = this;\n        if (!isValidFieldElement(r) || !isWithinCurveOrder(s))\n            throw new Error('Invalid signature');\n    }\n    toHex() {\n        return numTo32bStr(this.r) + numTo32bStr(this.s);\n    }\n    toRawBytes() {\n        return hexToBytes(this.toHex());\n    }\n}\nfunction schnorrGetPublicKey(privateKey) {\n    return Point.fromPrivateKey(privateKey).toRawX();\n}\nclass InternalSchnorrSignature {\n    constructor(message, privateKey, auxRand = utils.randomBytes()) {\n        if (message == null)\n            throw new TypeError(`sign: Expected valid message, not \"${message}\"`);\n        this.m = ensureBytes(message);\n        const { x, scalar } = this.getScalar(normalizePrivateKey(privateKey));\n        this.px = x;\n        this.d = scalar;\n        this.rand = ensureBytes(auxRand);\n        if (this.rand.length !== 32)\n            throw new TypeError('sign: Expected 32 bytes of aux randomness');\n    }\n    getScalar(priv) {\n        const point = Point.fromPrivateKey(priv);\n        const scalar = point.hasEvenY() ? priv : CURVE.n - priv;\n        return { point, scalar, x: point.toRawX() };\n    }\n    initNonce(d, t0h) {\n        return numTo32b(d ^ bytesToNumber(t0h));\n    }\n    finalizeNonce(k0h) {\n        const k0 = mod(bytesToNumber(k0h), CURVE.n);\n        if (k0 === _0n)\n            throw new Error('sign: Creation of signature failed. k is zero');\n        const { point: R, x: rx, scalar: k } = this.getScalar(k0);\n        return { R, rx, k };\n    }\n    finalizeSig(R, k, e, d) {\n        return new SchnorrSignature(R.x, mod(k + e * d, CURVE.n)).toRawBytes();\n    }\n    error() {\n        throw new Error('sign: Invalid signature produced');\n    }\n    async calc() {\n        const { m, d, px, rand } = this;\n        const tag = utils.taggedHash;\n        const t = this.initNonce(d, await tag(TAGS.aux, rand));\n        const { R, rx, k } = this.finalizeNonce(await tag(TAGS.nonce, t, px, m));\n        const e = schnorrChallengeFinalize(await tag(TAGS.challenge, rx, px, m));\n        const sig = this.finalizeSig(R, k, e, d);\n        if (!(await schnorrVerify(sig, m, px)))\n            this.error();\n        return sig;\n    }\n    calcSync() {\n        const { m, d, px, rand } = this;\n        const tag = utils.taggedHashSync;\n        const t = this.initNonce(d, tag(TAGS.aux, rand));\n        const { R, rx, k } = this.finalizeNonce(tag(TAGS.nonce, t, px, m));\n        const e = schnorrChallengeFinalize(tag(TAGS.challenge, rx, px, m));\n        const sig = this.finalizeSig(R, k, e, d);\n        if (!schnorrVerifySync(sig, m, px))\n            this.error();\n        return sig;\n    }\n}\nasync function schnorrSign(msg, privKey, auxRand) {\n    return new InternalSchnorrSignature(msg, privKey, auxRand).calc();\n}\nfunction schnorrSignSync(msg, privKey, auxRand) {\n    return new InternalSchnorrSignature(msg, privKey, auxRand).calcSync();\n}\nfunction initSchnorrVerify(signature, message, publicKey) {\n    const raw = signature instanceof SchnorrSignature;\n    const sig = raw ? signature : SchnorrSignature.fromHex(signature);\n    if (raw)\n        sig.assertValidity();\n    return {\n        ...sig,\n        m: ensureBytes(message),\n        P: normalizePublicKey(publicKey),\n    };\n}\nfunction finalizeSchnorrVerify(r, P, s, e) {\n    const R = Point.BASE.multiplyAndAddUnsafe(P, normalizePrivateKey(s), mod(-e, CURVE.n));\n    if (!R || !R.hasEvenY() || R.x !== r)\n        return false;\n    return true;\n}\nasync function schnorrVerify(signature, message, publicKey) {\n    try {\n        const { r, s, m, P } = initSchnorrVerify(signature, message, publicKey);\n        const e = schnorrChallengeFinalize(await utils.taggedHash(TAGS.challenge, numTo32b(r), P.toRawX(), m));\n        return finalizeSchnorrVerify(r, P, s, e);\n    }\n    catch (error) {\n        return false;\n    }\n}\nfunction schnorrVerifySync(signature, message, publicKey) {\n    try {\n        const { r, s, m, P } = initSchnorrVerify(signature, message, publicKey);\n        const e = schnorrChallengeFinalize(utils.taggedHashSync(TAGS.challenge, numTo32b(r), P.toRawX(), m));\n        return finalizeSchnorrVerify(r, P, s, e);\n    }\n    catch (error) {\n        if (error instanceof ShaError)\n            throw error;\n        return false;\n    }\n}\nexport const schnorr = {\n    Signature: SchnorrSignature,\n    getPublicKey: schnorrGetPublicKey,\n    sign: schnorrSign,\n    verify: schnorrVerify,\n    signSync: schnorrSignSync,\n    verifySync: schnorrVerifySync,\n};\nPoint.BASE._setWindowSize(8);\nconst crypto = {\n    node: nodeCrypto,\n    web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\n};\nconst TAGS = {\n    challenge: 'BIP0340/challenge',\n    aux: 'BIP0340/aux',\n    nonce: 'BIP0340/nonce',\n};\nconst TAGGED_HASH_PREFIXES = {};\nexport const utils = {\n    bytesToHex,\n    hexToBytes,\n    concatBytes,\n    mod,\n    invert,\n    isValidPrivateKey(privateKey) {\n        try {\n            normalizePrivateKey(privateKey);\n            return true;\n        }\n        catch (error) {\n            return false;\n        }\n    },\n    _bigintTo32Bytes: numTo32b,\n    _normalizePrivateKey: normalizePrivateKey,\n    hashToPrivateKey: (hash) => {\n        hash = ensureBytes(hash);\n        const minLen = groupLen + 8;\n        if (hash.length < minLen || hash.length > 1024) {\n            throw new Error(`Expected valid bytes of private key as per FIPS 186`);\n        }\n        const num = mod(bytesToNumber(hash), CURVE.n - _1n) + _1n;\n        return numTo32b(num);\n    },\n    randomBytes: (bytesLength = 32) => {\n        if (crypto.web) {\n            return crypto.web.getRandomValues(new Uint8Array(bytesLength));\n        }\n        else if (crypto.node) {\n            const { randomBytes } = crypto.node;\n            return Uint8Array.from(randomBytes(bytesLength));\n        }\n        else {\n            throw new Error(\"The environment doesn't have randomBytes function\");\n        }\n    },\n    randomPrivateKey: () => utils.hashToPrivateKey(utils.randomBytes(groupLen + 8)),\n    precompute(windowSize = 8, point = Point.BASE) {\n        const cached = point === Point.BASE ? point : new Point(point.x, point.y);\n        cached._setWindowSize(windowSize);\n        cached.multiply(_3n);\n        return cached;\n    },\n    sha256: async (...messages) => {\n        if (crypto.web) {\n            const buffer = await crypto.web.subtle.digest('SHA-256', concatBytes(...messages));\n            return new Uint8Array(buffer);\n        }\n        else if (crypto.node) {\n            const { createHash } = crypto.node;\n            const hash = createHash('sha256');\n            messages.forEach((m) => hash.update(m));\n            return Uint8Array.from(hash.digest());\n        }\n        else {\n            throw new Error(\"The environment doesn't have sha256 function\");\n        }\n    },\n    hmacSha256: async (key, ...messages) => {\n        if (crypto.web) {\n            const ckey = await crypto.web.subtle.importKey('raw', key, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign']);\n            const message = concatBytes(...messages);\n            const buffer = await crypto.web.subtle.sign('HMAC', ckey, message);\n            return new Uint8Array(buffer);\n        }\n        else if (crypto.node) {\n            const { createHmac } = crypto.node;\n            const hash = createHmac('sha256', key);\n            messages.forEach((m) => hash.update(m));\n            return Uint8Array.from(hash.digest());\n        }\n        else {\n            throw new Error(\"The environment doesn't have hmac-sha256 function\");\n        }\n    },\n    sha256Sync: undefined,\n    hmacSha256Sync: undefined,\n    taggedHash: async (tag, ...messages) => {\n        let tagP = TAGGED_HASH_PREFIXES[tag];\n        if (tagP === undefined) {\n            const tagH = await utils.sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n            tagP = concatBytes(tagH, tagH);\n            TAGGED_HASH_PREFIXES[tag] = tagP;\n        }\n        return utils.sha256(tagP, ...messages);\n    },\n    taggedHashSync: (tag, ...messages) => {\n        if (typeof _sha256Sync !== 'function')\n            throw new ShaError('sha256Sync is undefined, you need to set it');\n        let tagP = TAGGED_HASH_PREFIXES[tag];\n        if (tagP === undefined) {\n            const tagH = _sha256Sync(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n            tagP = concatBytes(tagH, tagH);\n            TAGGED_HASH_PREFIXES[tag] = tagP;\n        }\n        return _sha256Sync(tagP, ...messages);\n    },\n    _JacobianPoint: JacobianPoint,\n};\nObject.defineProperties(utils, {\n    sha256Sync: {\n        configurable: false,\n        get() {\n            return _sha256Sync;\n        },\n        set(val) {\n            if (!_sha256Sync)\n                _sha256Sync = val;\n        },\n    },\n    hmacSha256Sync: {\n        configurable: false,\n        get() {\n            return _hmacSha256Sync;\n        },\n        set(val) {\n            if (!_hmacSha256Sync)\n                _hmacSha256Sync = val;\n        },\n    },\n});\n","import { Logger } from './logger';\nexport const BLOCKSTACK_HANDLER = 'blockstack';\nexport function nextYear() {\n    return new Date(new Date().setFullYear(new Date().getFullYear() + 1));\n}\nexport function nextMonth() {\n    return new Date(new Date().setMonth(new Date().getMonth() + 1));\n}\nexport function nextHour() {\n    return new Date(new Date().setHours(new Date().getHours() + 1));\n}\nexport function megabytesToBytes(megabytes) {\n    if (!Number.isFinite(megabytes)) {\n        return 0;\n    }\n    return Math.floor(megabytes * 1024 * 1024);\n}\nexport function getAesCbcOutputLength(inputByteLength) {\n    const cipherTextLength = (Math.floor(inputByteLength / 16) + 1) * 16;\n    return cipherTextLength;\n}\nexport function getBase64OutputLength(inputByteLength) {\n    const encodedLength = Math.ceil(inputByteLength / 3) * 4;\n    return encodedLength;\n}\nexport function updateQueryStringParameter(uri, key, value) {\n    const re = new RegExp(`([?&])${key}=.*?(&|$)`, 'i');\n    const separator = uri.indexOf('?') !== -1 ? '&' : '?';\n    if (uri.match(re)) {\n        return uri.replace(re, `$1${key}=${value}$2`);\n    }\n    else {\n        return `${uri}${separator}${key}=${value}`;\n    }\n}\nexport function isLaterVersion(v1, v2) {\n    if (v1 === undefined || v1 === '') {\n        v1 = '0.0.0';\n    }\n    if (v2 === undefined || v1 === '') {\n        v2 = '0.0.0';\n    }\n    const v1tuple = v1.split('.').map(x => parseInt(x, 10));\n    const v2tuple = v2.split('.').map(x => parseInt(x, 10));\n    for (let index = 0; index < v2.length; index++) {\n        if (index >= v1.length) {\n            v2tuple.push(0);\n        }\n        if (v1tuple[index] < v2tuple[index]) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function makeUUID4() {\n    let d = new Date().getTime();\n    if (typeof performance !== 'undefined' && typeof performance.now === 'function') {\n        d += performance.now();\n    }\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\n        const r = (d + Math.random() * 16) % 16 | 0;\n        d = Math.floor(d / 16);\n        return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);\n    });\n}\nexport function isSameOriginAbsoluteUrl(uri1, uri2) {\n    try {\n        const parsedUri1 = new URL(uri1);\n        const parsedUri2 = new URL(uri2);\n        const port1 = parseInt(parsedUri1.port || '0', 10) | 0 || (parsedUri1.protocol === 'https:' ? 443 : 80);\n        const port2 = parseInt(parsedUri2.port || '0', 10) | 0 || (parsedUri2.protocol === 'https:' ? 443 : 80);\n        const match = {\n            scheme: parsedUri1.protocol === parsedUri2.protocol,\n            hostname: parsedUri1.hostname === parsedUri2.hostname,\n            port: port1 === port2,\n            absolute: (uri1.includes('http://') || uri1.includes('https://')) &&\n                (uri2.includes('http://') || uri2.includes('https://')),\n        };\n        return match.scheme && match.hostname && match.port && match.absolute;\n    }\n    catch (error) {\n        console.log(error);\n        console.log('Parsing error in same URL origin check');\n        return false;\n    }\n}\nexport function getGlobalScope() {\n    if (typeof self !== 'undefined') {\n        return self;\n    }\n    if (typeof window !== 'undefined') {\n        return window;\n    }\n    if (typeof global !== 'undefined') {\n        return global;\n    }\n    throw new Error('Unexpected runtime environment - no supported global scope (`window`, `self`, `global`) available');\n}\nfunction getAPIUsageErrorMessage(scopeObject, apiName, usageDesc) {\n    if (usageDesc) {\n        return `Use of '${usageDesc}' requires \\`${apiName}\\` which is unavailable on the '${scopeObject}' object within the currently executing environment.`;\n    }\n    else {\n        return `\\`${apiName}\\` is unavailable on the '${scopeObject}' object within the currently executing environment.`;\n    }\n}\nexport function getGlobalObject(name, { throwIfUnavailable, usageDesc, returnEmptyObject } = {}) {\n    let globalScope = undefined;\n    try {\n        globalScope = getGlobalScope();\n        if (globalScope) {\n            const obj = globalScope[name];\n            if (obj) {\n                return obj;\n            }\n        }\n    }\n    catch (error) {\n        Logger.error(`Error getting object '${name}' from global scope '${globalScope}': ${error}`);\n    }\n    if (throwIfUnavailable) {\n        const errMsg = getAPIUsageErrorMessage(globalScope, name.toString(), usageDesc);\n        Logger.error(errMsg);\n        throw new Error(errMsg);\n    }\n    if (returnEmptyObject) {\n        return {};\n    }\n    return undefined;\n}\nexport function getGlobalObjects(names, { throwIfUnavailable, usageDesc, returnEmptyObject } = {}) {\n    let globalScope;\n    try {\n        globalScope = getGlobalScope();\n    }\n    catch (error) {\n        Logger.error(`Error getting global scope: ${error}`);\n        if (throwIfUnavailable) {\n            const errMsg = getAPIUsageErrorMessage(globalScope, names[0].toString(), usageDesc);\n            Logger.error(errMsg);\n            throw errMsg;\n        }\n        else if (returnEmptyObject) {\n            globalScope = {};\n        }\n    }\n    const result = {};\n    for (let i = 0; i < names.length; i++) {\n        const name = names[i];\n        try {\n            if (globalScope) {\n                const obj = globalScope[name];\n                if (obj) {\n                    result[name] = obj;\n                }\n                else if (throwIfUnavailable) {\n                    const errMsg = getAPIUsageErrorMessage(globalScope, name.toString(), usageDesc);\n                    Logger.error(errMsg);\n                    throw new Error(errMsg);\n                }\n                else if (returnEmptyObject) {\n                    result[name] = {};\n                }\n            }\n        }\n        catch (error) {\n            if (throwIfUnavailable) {\n                const errMsg = getAPIUsageErrorMessage(globalScope, name.toString(), usageDesc);\n                Logger.error(errMsg);\n                throw new Error(errMsg);\n            }\n        }\n    }\n    return result;\n}\nexport function intToBytes(value, byteLength) {\n    return bigIntToBytes(intToBigInt(value), byteLength);\n}\nexport function intToBigInt(value) {\n    if (typeof value === 'bigint')\n        return value;\n    if (typeof value === 'string')\n        return BigInt(value);\n    if (typeof value === 'number') {\n        if (!Number.isInteger(value)) {\n            throw new RangeError(`Invalid value. Values of type 'number' must be an integer.`);\n        }\n        if (value > Number.MAX_SAFE_INTEGER) {\n            throw new RangeError(`Invalid value. Values of type 'number' must be less than or equal to ${Number.MAX_SAFE_INTEGER}. For larger values, try using a BigInt instead.`);\n        }\n        return BigInt(value);\n    }\n    if (isInstance(value, Uint8Array))\n        return BigInt(`0x${bytesToHex(value)}`);\n    throw new TypeError(`intToBigInt: Invalid value type. Must be a number, bigint, BigInt-compatible string, or Uint8Array.`);\n}\nexport function with0x(value) {\n    return /^0x/i.test(value)\n        ? value\n        : `0x${value}`;\n}\nexport function without0x(value) {\n    return /^0x/i.test(value)\n        ? value.slice(2)\n        : value;\n}\nexport function hexToBigInt(hex) {\n    if (typeof hex !== 'string')\n        throw new TypeError(`hexToBigInt: expected string, got ${typeof hex}`);\n    return BigInt(`0x${hex}`);\n}\nexport function intToHex(integer, byteLength = 8) {\n    const value = typeof integer === 'bigint' ? integer : intToBigInt(integer);\n    return value.toString(16).padStart(byteLength * 2, '0');\n}\nexport function hexToInt(hex) {\n    return parseInt(hex, 16);\n}\nexport function bigIntToBytes(value, length = 16) {\n    const hex = intToHex(value, length);\n    return hexToBytes(hex);\n}\nexport function toTwos(value, width) {\n    if (value < -(BigInt(1) << (width - BigInt(1))) ||\n        (BigInt(1) << (width - BigInt(1))) - BigInt(1) < value) {\n        throw `Unable to represent integer in width: ${width}`;\n    }\n    if (value >= BigInt(0)) {\n        return BigInt(value);\n    }\n    return value + (BigInt(1) << width);\n}\nfunction nthBit(value, n) {\n    return value & (BigInt(1) << n);\n}\nexport function bytesToTwosBigInt(bytes) {\n    return fromTwos(BigInt(`0x${bytesToHex(bytes)}`), BigInt(bytes.byteLength * 8));\n}\nexport function fromTwos(value, width) {\n    if (nthBit(value, width - BigInt(1))) {\n        return value - (BigInt(1) << width);\n    }\n    return value;\n}\nconst hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\nexport function bytesToHex(uint8a) {\n    if (!(uint8a instanceof Uint8Array))\n        throw new Error('Uint8Array expected');\n    let hex = '';\n    for (const u of uint8a) {\n        hex += hexes[u];\n    }\n    return hex;\n}\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string') {\n        throw new TypeError(`hexToBytes: expected string, got ${typeof hex}`);\n    }\n    hex = without0x(hex);\n    hex = hex.length % 2 ? `0${hex}` : hex;\n    const array = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\nexport function utf8ToBytes(str) {\n    return new TextEncoder().encode(str);\n}\nexport function bytesToUtf8(arr) {\n    return new TextDecoder().decode(arr);\n}\nexport function asciiToBytes(str) {\n    const byteArray = [];\n    for (let i = 0; i < str.length; i++) {\n        byteArray.push(str.charCodeAt(i) & 0xff);\n    }\n    return new Uint8Array(byteArray);\n}\nexport function bytesToAscii(arr) {\n    return String.fromCharCode.apply(null, arr);\n}\nfunction isNotOctet(octet) {\n    return !Number.isInteger(octet) || octet < 0 || octet > 255;\n}\nexport function octetsToBytes(numbers) {\n    if (numbers.some(isNotOctet))\n        throw new Error('Some values are invalid bytes.');\n    return new Uint8Array(numbers);\n}\nexport function concatBytes(...arrays) {\n    if (!arrays.every(a => a instanceof Uint8Array))\n        throw new Error('Uint8Array list expected');\n    if (arrays.length === 1)\n        return arrays[0];\n    const length = arrays.reduce((a, arr) => a + arr.length, 0);\n    const result = new Uint8Array(length);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const arr = arrays[i];\n        result.set(arr, pad);\n        pad += arr.length;\n    }\n    return result;\n}\nexport function concatArray(elements) {\n    return concatBytes(...elements.map(e => {\n        if (typeof e === 'number')\n            return octetsToBytes([e]);\n        if (e instanceof Array)\n            return octetsToBytes(e);\n        return e;\n    }));\n}\nexport function isInstance(object, clazz) {\n    return object instanceof clazz || object?.constructor?.name?.toLowerCase() === clazz.name;\n}\nexport function validateHash256(hex) {\n    hex = without0x(hex);\n    if (hex.length !== 64)\n        return false;\n    return /^[0-9a-fA-F]+$/.test(hex);\n}\n//# sourceMappingURL=utils.js.map","export const ERROR_CODES = {\n    MISSING_PARAMETER: 'missing_parameter',\n    REMOTE_SERVICE_ERROR: 'remote_service_error',\n    INVALID_STATE: 'invalid_state',\n    NO_SESSION_DATA: 'no_session_data',\n    DOES_NOT_EXIST: 'does_not_exist',\n    FAILED_DECRYPTION_ERROR: 'failed_decryption_error',\n    INVALID_DID_ERROR: 'invalid_did_error',\n    NOT_ENOUGH_FUNDS_ERROR: 'not_enough_error',\n    INVALID_AMOUNT_ERROR: 'invalid_amount_error',\n    LOGIN_FAILED_ERROR: 'login_failed',\n    SIGNATURE_VERIFICATION_ERROR: 'signature_verification_failure',\n    CONFLICT_ERROR: 'conflict_error',\n    NOT_ENOUGH_PROOF_ERROR: 'not_enough_proof_error',\n    BAD_PATH_ERROR: 'bad_path_error',\n    VALIDATION_ERROR: 'validation_error',\n    PAYLOAD_TOO_LARGE_ERROR: 'payload_too_large_error',\n    PRECONDITION_FAILED_ERROR: 'precondition_failed_error',\n    UNKNOWN: 'unknown',\n};\nObject.freeze(ERROR_CODES);\nexport class BlockstackError extends Error {\n    constructor(error) {\n        super();\n        let message = error.message;\n        let bugDetails = `Error Code: ${error.code}`;\n        let stack = this.stack;\n        if (!stack) {\n            try {\n                throw new Error();\n            }\n            catch (e) {\n                stack = e.stack;\n            }\n        }\n        else {\n            bugDetails += `Stack Trace:\\n${stack}`;\n        }\n        message += `\\nIf you believe this exception is caused by a bug in stacks.js,\n      please file a bug report: https://github.com/blockstack/stacks.js/issues\\n\\n${bugDetails}`;\n        this.message = message;\n        this.code = error.code;\n        this.parameter = error.parameter ? error.parameter : undefined;\n    }\n    toString() {\n        return `${super.toString()}\n    code: ${this.code} param: ${this.parameter ? this.parameter : 'n/a'}`;\n    }\n}\nexport class InvalidParameterError extends BlockstackError {\n    constructor(parameter, message = '') {\n        super({ code: ERROR_CODES.MISSING_PARAMETER, message, parameter });\n        this.name = 'MissingParametersError';\n    }\n}\nexport class MissingParameterError extends BlockstackError {\n    constructor(parameter, message = '') {\n        super({ code: ERROR_CODES.MISSING_PARAMETER, message, parameter });\n        this.name = 'MissingParametersError';\n    }\n}\nexport class RemoteServiceError extends BlockstackError {\n    constructor(response, message = '') {\n        super({ code: ERROR_CODES.REMOTE_SERVICE_ERROR, message });\n        this.response = response;\n    }\n}\nexport class InvalidDIDError extends BlockstackError {\n    constructor(message = '') {\n        super({ code: ERROR_CODES.INVALID_DID_ERROR, message });\n        this.name = 'InvalidDIDError';\n    }\n}\nexport class NotEnoughFundsError extends BlockstackError {\n    constructor(leftToFund) {\n        const message = `Not enough UTXOs to fund. Left to fund: ${leftToFund}`;\n        super({ code: ERROR_CODES.NOT_ENOUGH_FUNDS_ERROR, message });\n        this.leftToFund = leftToFund;\n        this.name = 'NotEnoughFundsError';\n        this.message = message;\n    }\n}\nexport class InvalidAmountError extends BlockstackError {\n    constructor(fees, specifiedAmount) {\n        const message = `Not enough coin to fund fees transaction fees. Fees would be ${fees},` +\n            ` specified spend is  ${specifiedAmount}`;\n        super({ code: ERROR_CODES.INVALID_AMOUNT_ERROR, message });\n        this.specifiedAmount = specifiedAmount;\n        this.fees = fees;\n        this.name = 'InvalidAmountError';\n        this.message = message;\n    }\n}\nexport class LoginFailedError extends BlockstackError {\n    constructor(reason) {\n        const message = `Failed to login: ${reason}`;\n        super({ code: ERROR_CODES.LOGIN_FAILED_ERROR, message });\n        this.message = message;\n        this.name = 'LoginFailedError';\n    }\n}\nexport class SignatureVerificationError extends BlockstackError {\n    constructor(reason) {\n        const message = `Failed to verify signature: ${reason}`;\n        super({ code: ERROR_CODES.SIGNATURE_VERIFICATION_ERROR, message });\n        this.message = message;\n        this.name = 'SignatureVerificationError';\n    }\n}\nexport class FailedDecryptionError extends BlockstackError {\n    constructor(message = 'Unable to decrypt cipher object.') {\n        super({ code: ERROR_CODES.FAILED_DECRYPTION_ERROR, message });\n        this.message = message;\n        this.name = 'FailedDecryptionError';\n    }\n}\nexport class InvalidStateError extends BlockstackError {\n    constructor(message) {\n        super({ code: ERROR_CODES.INVALID_STATE, message });\n        this.message = message;\n        this.name = 'InvalidStateError';\n    }\n}\nexport class NoSessionDataError extends BlockstackError {\n    constructor(message) {\n        super({ code: ERROR_CODES.INVALID_STATE, message });\n        this.message = message;\n        this.name = 'NoSessionDataError';\n    }\n}\nexport class GaiaHubError extends BlockstackError {\n    constructor(error, response) {\n        super(error);\n        if (response) {\n            this.hubError = {\n                statusCode: response.status,\n                statusText: response.statusText,\n            };\n            if (typeof response.body === 'string') {\n                this.hubError.message = response.body;\n            }\n            else if (typeof response.body === 'object') {\n                Object.assign(this.hubError, response.body);\n            }\n        }\n    }\n}\nexport class DoesNotExist extends GaiaHubError {\n    constructor(message, response) {\n        super({ message, code: ERROR_CODES.DOES_NOT_EXIST }, response);\n        this.name = 'DoesNotExist';\n    }\n}\nexport class ConflictError extends GaiaHubError {\n    constructor(message, response) {\n        super({ message, code: ERROR_CODES.CONFLICT_ERROR }, response);\n        this.name = 'ConflictError';\n    }\n}\nexport class NotEnoughProofError extends GaiaHubError {\n    constructor(message, response) {\n        super({ message, code: ERROR_CODES.NOT_ENOUGH_PROOF_ERROR }, response);\n        this.name = 'NotEnoughProofError';\n    }\n}\nexport class BadPathError extends GaiaHubError {\n    constructor(message, response) {\n        super({ message, code: ERROR_CODES.BAD_PATH_ERROR }, response);\n        this.name = 'BadPathError';\n    }\n}\nexport class ValidationError extends GaiaHubError {\n    constructor(message, response) {\n        super({ message, code: ERROR_CODES.VALIDATION_ERROR }, response);\n        this.name = 'ValidationError';\n    }\n}\nexport class PayloadTooLargeError extends GaiaHubError {\n    constructor(message, response, maxUploadByteSize) {\n        super({ message, code: ERROR_CODES.PAYLOAD_TOO_LARGE_ERROR }, response);\n        this.name = 'PayloadTooLargeError';\n        this.maxUploadByteSize = maxUploadByteSize;\n    }\n}\nexport class PreconditionFailedError extends GaiaHubError {\n    constructor(message, response) {\n        super({ message, code: ERROR_CODES.PRECONDITION_FAILED_ERROR }, response);\n        this.name = 'PreconditionFailedError';\n    }\n}\n//# sourceMappingURL=errors.js.map","import { hexToInt } from './utils';\nconst COORDINATE_BYTES = 32;\nexport function parseRecoverableSignatureVrs(signature) {\n    if (signature.length < COORDINATE_BYTES * 2 * 2 + 1) {\n        throw new Error('Invalid signature');\n    }\n    const recoveryIdHex = signature.slice(0, 2);\n    const r = signature.slice(2, 2 + COORDINATE_BYTES * 2);\n    const s = signature.slice(2 + COORDINATE_BYTES * 2);\n    return {\n        recoveryId: hexToInt(recoveryIdHex),\n        r,\n        s,\n    };\n}\nexport function signatureVrsToRsv(signature) {\n    return signature.slice(2) + signature.slice(0, 2);\n}\nexport function signatureRsvToVrs(signature) {\n    return signature.slice(-2) + signature.slice(0, -2);\n}\n//# sourceMappingURL=signatures.js.map","// @ts-ignore\nexport function isSubtleCryptoAvailable(): boolean {\n  return typeof crypto !== 'undefined' && typeof crypto.subtle !== 'undefined';\n}\n\nexport function isNodeCryptoAvailable<T>(\n  withFeature: (nodeCrypto: typeof import('crypto')) => boolean | T\n): false | T;\nexport function isNodeCryptoAvailable<T>(\n  withFeature?: (nodeCrypto: typeof import('crypto')) => boolean | T\n): boolean | T {\n  try {\n    const resolvedResult = require.resolve('crypto');\n    if (!resolvedResult) {\n      return false;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    const cryptoModule = require('crypto') as typeof import('crypto');\n    if (!cryptoModule) {\n      return false;\n    }\n    if (withFeature) {\n      const features = withFeature(cryptoModule);\n      return features;\n    }\n    return true;\n  } catch (error) {\n    return false;\n  }\n}\n\nexport const NO_CRYPTO_LIB =\n  'Crypto lib not found. Either the WebCrypto \"crypto.subtle\" or Node.js \"crypto\" module must be available.';\n\nexport interface WebCryptoLib {\n  lib: SubtleCrypto;\n  name: 'subtleCrypto';\n}\n\nexport interface NodeCryptoLib {\n  lib: typeof import('crypto');\n  name: 'nodeCrypto';\n}\n\n// Make async for future version which may lazy load.\n// eslint-disable-next-line @typescript-eslint/require-await\nexport async function getCryptoLib(): Promise<WebCryptoLib | NodeCryptoLib> {\n  if (isSubtleCryptoAvailable()) {\n    return {\n      lib: crypto.subtle,\n      name: 'subtleCrypto',\n    };\n  } else {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-var-requires\n      const nodeCrypto = require('crypto') as typeof import('crypto');\n      return {\n        lib: nodeCrypto,\n        name: 'nodeCrypto',\n      };\n    } catch (error) {\n      throw new Error(NO_CRYPTO_LIB);\n    }\n  }\n}\n","import { concatBytes } from '@stacks/common';\nimport { getCryptoLib } from './cryptoUtils';\n\ntype NodeCryptoCreateCipher = typeof import('crypto').createCipheriv;\ntype NodeCryptoCreateDecipher = typeof import('crypto').createDecipheriv;\n\nexport type CipherAlgorithm = 'aes-256-cbc' | 'aes-128-cbc';\n\nexport interface AesCipher {\n  encrypt(\n    algorithm: CipherAlgorithm,\n    key: Uint8Array,\n    iv: Uint8Array,\n    data: Uint8Array\n  ): Promise<Uint8Array>;\n\n  decrypt(\n    algorithm: CipherAlgorithm,\n    key: Uint8Array,\n    iv: Uint8Array,\n    data: Uint8Array\n  ): Promise<Uint8Array>;\n}\n\nexport class NodeCryptoAesCipher implements AesCipher {\n  createCipher: NodeCryptoCreateCipher;\n\n  createDecipher: NodeCryptoCreateDecipher;\n\n  constructor(createCipher: NodeCryptoCreateCipher, createDecipher: NodeCryptoCreateDecipher) {\n    this.createCipher = createCipher;\n    this.createDecipher = createDecipher;\n  }\n\n  async encrypt(\n    algorithm: CipherAlgorithm,\n    key: Uint8Array,\n    iv: Uint8Array,\n    data: Uint8Array\n  ): Promise<Uint8Array> {\n    if (algorithm !== 'aes-128-cbc' && algorithm !== 'aes-256-cbc') {\n      throw new Error(`Unsupported cipher algorithm \"${algorithm}\"`);\n    }\n    const cipher = this.createCipher(algorithm, key, iv);\n    const result = new Uint8Array(concatBytes(cipher.update(data), cipher.final()));\n    return Promise.resolve(result);\n  }\n\n  async decrypt(\n    algorithm: CipherAlgorithm,\n    key: Uint8Array,\n    iv: Uint8Array,\n    data: Uint8Array\n  ): Promise<Uint8Array> {\n    if (algorithm !== 'aes-128-cbc' && algorithm !== 'aes-256-cbc') {\n      throw new Error(`Unsupported cipher algorithm \"${algorithm}\"`);\n    }\n    const cipher = this.createDecipher(algorithm, key, iv);\n    const result = new Uint8Array(concatBytes(cipher.update(data), cipher.final()));\n    return Promise.resolve(result);\n  }\n}\n\nexport class WebCryptoAesCipher implements AesCipher {\n  subtleCrypto: SubtleCrypto;\n\n  constructor(subtleCrypto: SubtleCrypto) {\n    this.subtleCrypto = subtleCrypto;\n  }\n\n  async encrypt(\n    algorithm: CipherAlgorithm,\n    key: Uint8Array,\n    iv: Uint8Array,\n    data: Uint8Array\n  ): Promise<Uint8Array> {\n    let algo: string;\n    let length: number;\n    if (algorithm === 'aes-128-cbc') {\n      algo = 'AES-CBC';\n      length = 128;\n    } else if (algorithm === 'aes-256-cbc') {\n      algo = 'AES-CBC';\n      length = 256;\n    } else {\n      throw new Error(`Unsupported cipher algorithm \"${algorithm}\"`);\n    }\n    const cryptoKey = await this.subtleCrypto.importKey('raw', key, { name: algo, length }, false, [\n      'encrypt',\n    ]);\n    const result = await this.subtleCrypto.encrypt({ name: algo, iv }, cryptoKey, data);\n    return new Uint8Array(result);\n  }\n\n  async decrypt(\n    algorithm: CipherAlgorithm,\n    key: Uint8Array,\n    iv: Uint8Array,\n    data: Uint8Array\n  ): Promise<Uint8Array> {\n    let algo: string;\n    let length: number;\n    if (algorithm === 'aes-128-cbc') {\n      algo = 'AES-CBC';\n      length = 128;\n    } else if (algorithm === 'aes-256-cbc') {\n      algo = 'AES-CBC';\n      length = 256;\n    } else {\n      throw new Error(`Unsupported cipher algorithm \"${algorithm}\"`);\n    }\n    const cryptoKey = await this.subtleCrypto.importKey('raw', key, { name: algo, length }, false, [\n      'decrypt',\n    ]);\n    const result = await this.subtleCrypto.decrypt({ name: algo, iv }, cryptoKey, data);\n    return new Uint8Array(result);\n  }\n}\n\nexport async function createCipher(): Promise<AesCipher> {\n  const cryptoLib = await getCryptoLib();\n  if (cryptoLib.name === 'subtleCrypto') {\n    return new WebCryptoAesCipher(cryptoLib.lib);\n  }\n  return new NodeCryptoAesCipher(cryptoLib.lib.createCipheriv, cryptoLib.lib.createDecipheriv);\n}\n","export function equals(a, b) {\n    if (a.byteLength !== b.byteLength)\n        return false;\n    for (let i = 0; i < a.byteLength; i++) {\n        if (a[i] !== b[i])\n            return false;\n    }\n    return true;\n}\nexport function alloc(length, value) {\n    const a = new Uint8Array(length);\n    for (let i = 0; i < length; i++) {\n        a[i] = value;\n    }\n    return a;\n}\nexport function readUInt16BE(source, offset) {\n    return ((source[offset + 0] << 8) | source[offset + 1]) >>> 0;\n}\nexport function writeUInt16BE(destination, value, offset = 0) {\n    destination[offset + 0] = value >>> 8;\n    destination[offset + 1] = value >>> 0;\n    return destination;\n}\nexport function readUInt8(source, offset) {\n    return source[offset];\n}\nexport function writeUInt8(destination, value, offset = 0) {\n    destination[offset] = value;\n    return destination;\n}\nexport function readUInt16LE(source, offset) {\n    return ((source[offset + 0] << 0) >>> 0) | ((source[offset + 1] << 8) >>> 0);\n}\nexport function writeUInt16LE(destination, value, offset = 0) {\n    destination[offset + 0] = value & 255;\n    value >>>= 8;\n    destination[offset + 1] = value & 255;\n    return destination;\n}\nexport function readUInt32BE(source, offset) {\n    return (source[offset] * 2 ** 24 +\n        source[offset + 1] * 2 ** 16 +\n        source[offset + 2] * 2 ** 8 +\n        source[offset + 3]);\n}\nexport function writeUInt32BE(destination, value, offset = 0) {\n    destination[offset + 3] = value;\n    value >>>= 8;\n    destination[offset + 2] = value;\n    value >>>= 8;\n    destination[offset + 1] = value;\n    value >>>= 8;\n    destination[offset] = value;\n    return destination;\n}\nexport function readUInt32LE(source, offset) {\n    return (((source[offset + 0] << 0) >>> 0) |\n        ((source[offset + 1] << 8) >>> 0) |\n        ((source[offset + 2] << 16) >>> 0) |\n        ((source[offset + 3] << 24) >>> 0));\n}\nexport function writeUInt32LE(destination, value, offset = 0) {\n    destination[offset + 0] = value & 255;\n    value >>>= 8;\n    destination[offset + 1] = value & 255;\n    value >>>= 8;\n    destination[offset + 2] = value & 255;\n    value >>>= 8;\n    destination[offset + 3] = value & 255;\n    return destination;\n}\n//# sourceMappingURL=buffer.js.map","import { hexToBytes } from './utils';\nexport function privateKeyToBytes(privateKey) {\n    const privateKeyBuffer = typeof privateKey === 'string' ? hexToBytes(privateKey) : privateKey;\n    if (privateKeyBuffer.length != 32 && privateKeyBuffer.length != 33) {\n        throw new Error(`Improperly formatted private-key. Private-key byte length should be 32 or 33. Length provided: ${privateKeyBuffer.length}`);\n    }\n    if (privateKeyBuffer.length == 33 && privateKeyBuffer[32] !== 1) {\n        throw new Error('Improperly formatted private-key. 33 bytes indicate compressed key, but the last byte must be == 01');\n    }\n    return privateKeyBuffer;\n}\n//# sourceMappingURL=keys.js.map","import { SHA2 } from './_sha2.js';\nimport { wrapConstructor } from './utils.js';\n// https://homes.esat.kuleuven.be/~bosselae/ripemd160.html\n// https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf\nconst Rho = new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);\nconst Id = Uint8Array.from({ length: 16 }, (_, i) => i);\nconst Pi = Id.map((i) => (9 * i + 5) % 16);\nlet idxL = [Id];\nlet idxR = [Pi];\nfor (let i = 0; i < 4; i++)\n    for (let j of [idxL, idxR])\n        j.push(j[i].map((k) => Rho[k]));\nconst shifts = [\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) => new Uint8Array(i));\nconst shiftsL = idxL.map((idx, i) => idx.map((j) => shifts[i][j]));\nconst shiftsR = idxR.map((idx, i) => idx.map((j) => shifts[i][j]));\nconst Kl = new Uint32Array([0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]);\nconst Kr = new Uint32Array([0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]);\n// The rotate left (circular left shift) operation for uint32\nconst rotl = (word, shift) => (word << shift) | (word >>> (32 - shift));\n// It's called f() in spec.\nfunction f(group, x, y, z) {\n    if (group === 0)\n        return x ^ y ^ z;\n    else if (group === 1)\n        return (x & y) | (~x & z);\n    else if (group === 2)\n        return (x | ~y) ^ z;\n    else if (group === 3)\n        return (x & z) | (y & ~z);\n    else\n        return x ^ (y | ~z);\n}\n// Temporary buffer, not used to store anything between runs\nconst BUF = new Uint32Array(16);\nexport class RIPEMD160 extends SHA2 {\n    constructor() {\n        super(64, 20, 8, true);\n        this.h0 = 0x67452301 | 0;\n        this.h1 = 0xefcdab89 | 0;\n        this.h2 = 0x98badcfe | 0;\n        this.h3 = 0x10325476 | 0;\n        this.h4 = 0xc3d2e1f0 | 0;\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[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 = Kl[group], hbr = Kr[group]; // prettier-ignore\n            const rl = idxL[group], rr = idxR[group]; // prettier-ignore\n            const sl = shiftsL[group], sr = shiftsR[group]; // prettier-ignore\n            for (let i = 0; i < 16; i++) {\n                const tl = (rotl(al + f(group, bl, cl, dl) + BUF[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 + f(rGroup, br, cr, dr) + BUF[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        BUF.fill(0);\n    }\n    destroy() {\n        this.destroyed = true;\n        this.buffer.fill(0);\n        this.set(0, 0, 0, 0, 0);\n    }\n}\n/**\n * RIPEMD-160 - a hash function from 1990s.\n * @param message - msg that would be hashed\n */\nexport const ripemd160 = wrapConstructor(() => new RIPEMD160());\n","const U32_MASK64 = BigInt(2 ** 32 - 1);\nconst _32n = BigInt(32);\n// We are not using BigUint64Array, because they are extremely slow as per 2022\nexport function 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}\nexport function split(lst, le = false) {\n    let Ah = new Uint32Array(lst.length);\n    let Al = new Uint32Array(lst.length);\n    for (let i = 0; i < lst.length; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\nexport const 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.\n// Removing \"export\" has 5% perf penalty -_-\nexport function 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\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","import { SHA2 } from './_sha2.js';\nimport u64 from './_u64.js';\nimport { wrapConstructor } from './utils.js';\n// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):\n// prettier-ignore\nconst [SHA512_Kh, SHA512_Kl] = 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)));\n// Temporary buffer, not used to store anything between runs\nconst SHA512_W_H = new Uint32Array(80);\nconst SHA512_W_L = new Uint32Array(80);\nexport class SHA512 extends SHA2 {\n    constructor() {\n        super(128, 64, 16, false);\n        // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.\n        // Also looks cleaner and easier to verify with spec.\n        // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0x6a09e667 | 0;\n        this.Al = 0xf3bcc908 | 0;\n        this.Bh = 0xbb67ae85 | 0;\n        this.Bl = 0x84caa73b | 0;\n        this.Ch = 0x3c6ef372 | 0;\n        this.Cl = 0xfe94f82b | 0;\n        this.Dh = 0xa54ff53a | 0;\n        this.Dl = 0x5f1d36f1 | 0;\n        this.Eh = 0x510e527f | 0;\n        this.El = 0xade682d1 | 0;\n        this.Fh = 0x9b05688c | 0;\n        this.Fl = 0x2b3e6c1f | 0;\n        this.Gh = 0x1f83d9ab | 0;\n        this.Gl = 0xfb41bd6b | 0;\n        this.Hh = 0x5be0cd19 | 0;\n        this.Hl = 0x137e2179 | 0;\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n            const W2h = SHA512_W_H[i - 2] | 0;\n            const W2l = SHA512_W_L[i - 2] | 0;\n            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n            SHA512_W_H[i] = SUMh | 0;\n            SHA512_W_L[i] = SUMl | 0;\n        }\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        // Compression function main loop, 80 rounds\n        for (let i = 0; i < 80; i++) {\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n            const CHIl = (El & Fl) ^ (~El & Gl);\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n            // prettier-ignore\n            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n            const T1l = T1ll | 0;\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n            Hh = Gh | 0;\n            Hl = Gl | 0;\n            Gh = Fh | 0;\n            Gl = Fl | 0;\n            Fh = Eh | 0;\n            Fl = El | 0;\n            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n            Dh = Ch | 0;\n            Dl = Cl | 0;\n            Ch = Bh | 0;\n            Cl = Bl | 0;\n            Bh = Ah | 0;\n            Bl = Al | 0;\n            const All = u64.add3L(T1l, sigma0l, MAJl);\n            Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n            Al = All | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n    }\n    roundClean() {\n        SHA512_W_H.fill(0);\n        SHA512_W_L.fill(0);\n    }\n    destroy() {\n        this.buffer.fill(0);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\nclass SHA512_224 extends SHA512 {\n    constructor() {\n        super();\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0x8c3d37c8 | 0;\n        this.Al = 0x19544da2 | 0;\n        this.Bh = 0x73e19966 | 0;\n        this.Bl = 0x89dcd4d6 | 0;\n        this.Ch = 0x1dfab7ae | 0;\n        this.Cl = 0x32ff9c82 | 0;\n        this.Dh = 0x679dd514 | 0;\n        this.Dl = 0x582f9fcf | 0;\n        this.Eh = 0x0f6d2b69 | 0;\n        this.El = 0x7bd44da8 | 0;\n        this.Fh = 0x77e36f73 | 0;\n        this.Fl = 0x04c48942 | 0;\n        this.Gh = 0x3f9d85a8 | 0;\n        this.Gl = 0x6a1d36c8 | 0;\n        this.Hh = 0x1112e6ad | 0;\n        this.Hl = 0x91d692a1 | 0;\n        this.outputLen = 28;\n    }\n}\nclass SHA512_256 extends SHA512 {\n    constructor() {\n        super();\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0x22312194 | 0;\n        this.Al = 0xfc2bf72c | 0;\n        this.Bh = 0x9f555fa3 | 0;\n        this.Bl = 0xc84c64c2 | 0;\n        this.Ch = 0x2393b86b | 0;\n        this.Cl = 0x6f53b151 | 0;\n        this.Dh = 0x96387719 | 0;\n        this.Dl = 0x5940eabd | 0;\n        this.Eh = 0x96283ee2 | 0;\n        this.El = 0xa88effe3 | 0;\n        this.Fh = 0xbe5e1e25 | 0;\n        this.Fl = 0x53863992 | 0;\n        this.Gh = 0x2b0199fc | 0;\n        this.Gl = 0x2c85b8aa | 0;\n        this.Hh = 0x0eb72ddc | 0;\n        this.Hl = 0x81c52ca2 | 0;\n        this.outputLen = 32;\n    }\n}\nclass SHA384 extends SHA512 {\n    constructor() {\n        super();\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0xcbbb9d5d | 0;\n        this.Al = 0xc1059ed8 | 0;\n        this.Bh = 0x629a292a | 0;\n        this.Bl = 0x367cd507 | 0;\n        this.Ch = 0x9159015a | 0;\n        this.Cl = 0x3070dd17 | 0;\n        this.Dh = 0x152fecd8 | 0;\n        this.Dl = 0xf70e5939 | 0;\n        this.Eh = 0x67332667 | 0;\n        this.El = 0xffc00b31 | 0;\n        this.Fh = 0x8eb44a87 | 0;\n        this.Fl = 0x68581511 | 0;\n        this.Gh = 0xdb0c2e0d | 0;\n        this.Gl = 0x64f98fa7 | 0;\n        this.Hh = 0x47b5481d | 0;\n        this.Hl = 0xbefa4fa4 | 0;\n        this.outputLen = 48;\n    }\n}\nexport const sha512 = wrapConstructor(() => new SHA512());\nexport const sha512_224 = wrapConstructor(() => new SHA512_224());\nexport const sha512_256 = wrapConstructor(() => new SHA512_256());\nexport const sha384 = wrapConstructor(() => new SHA384());\n","import { sha256 } from '@noble/hashes/sha256';\nimport { sha512 } from '@noble/hashes/sha512';\nimport { getCryptoLib } from './cryptoUtils';\n\ntype NodeCryptoCreateHash = typeof import('crypto').createHash;\n\nexport interface Sha2Hash {\n  digest(data: Uint8Array, algorithm?: 'sha256' | 'sha512'): Promise<Uint8Array>;\n}\n\nexport class NodeCryptoSha2Hash {\n  createHash: NodeCryptoCreateHash;\n\n  constructor(createHash: NodeCryptoCreateHash) {\n    this.createHash = createHash;\n  }\n\n  async digest(data: Uint8Array, algorithm = 'sha256'): Promise<Uint8Array> {\n    try {\n      const result = this.createHash(algorithm).update(data).digest();\n      return Promise.resolve(result);\n    } catch (error) {\n      console.log(error);\n      console.log(\n        `Error performing ${algorithm} digest with Node.js 'crypto.createHash', falling back to JS implementation.`\n      );\n      return Promise.resolve(algorithm === 'sha256' ? hashSha256Sync(data) : hashSha512Sync(data));\n    }\n  }\n}\n\nexport class WebCryptoSha2Hash implements Sha2Hash {\n  subtleCrypto: SubtleCrypto;\n\n  constructor(subtleCrypto: SubtleCrypto) {\n    this.subtleCrypto = subtleCrypto;\n  }\n\n  async digest(data: Uint8Array, algorithm = 'sha256'): Promise<Uint8Array> {\n    let algo: string;\n    if (algorithm === 'sha256') {\n      algo = 'SHA-256';\n    } else if (algorithm === 'sha512') {\n      algo = 'SHA-512';\n    } else {\n      throw new Error(`Unsupported hash algorithm ${algorithm}`);\n    }\n    try {\n      const hash = await this.subtleCrypto.digest(algo, data);\n      return new Uint8Array(hash);\n    } catch (error) {\n      console.log(error);\n      console.log(\n        `Error performing ${algorithm} digest with WebCrypto, falling back to JS implementation.`\n      );\n      return Promise.resolve(algorithm === 'sha256' ? hashSha256Sync(data) : hashSha512Sync(data));\n    }\n  }\n}\n\nexport async function createSha2Hash(): Promise<Sha2Hash> {\n  const cryptoLib = await getCryptoLib();\n  if (cryptoLib.name === 'subtleCrypto') {\n    return new WebCryptoSha2Hash(cryptoLib.lib);\n  } else {\n    return new NodeCryptoSha2Hash(cryptoLib.lib.createHash);\n  }\n}\n\nexport function hashSha256Sync(data: Uint8Array) {\n  return sha256(data);\n}\n\nexport function hashSha512Sync(data: Uint8Array) {\n  return sha512(data);\n}\n","import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { getPublicKey as nobleGetPublicKey, signSync, utils } from '@noble/secp256k1';\nimport {\n  PrivateKey,\n  bytesToHex,\n  concatBytes,\n  hexToBytes,\n  privateKeyToBytes,\n  readUInt8,\n} from '@stacks/common';\nimport base58 from 'bs58';\nimport { hashRipemd160 } from './hashRipemd160';\nimport { hashSha256Sync } from './sha2Hash';\n\nconst BITCOIN_PUBKEYHASH = 0x00;\n\n/**\n * To use secp256k1.signSync set utils.hmacSha256Sync to a function using noble-hashes\n * secp256k1.signSync is the counter part of secp256k1.sign (async version)\n * secp256k1.signSync is used within signWithKey in this file\n * secp256k1.signSync is used to maintain the semantics of signWithKey while migrating from elliptic lib\n * utils.hmacSha256Sync docs: https://github.com/paulmillr/noble-secp256k1 readme file\n */\nutils.hmacSha256Sync = (key: Uint8Array, ...msgs: Uint8Array[]) => {\n  const h = hmac.create(sha256, key);\n  msgs.forEach(msg => h.update(msg));\n  return h.digest();\n};\n\n/**\n * @ignore\n * @deprecated Use `randomPrivateKey` instead.\n */\nexport function makeECPrivateKey() {\n  return bytesToHex(utils.randomPrivateKey());\n}\n\n/**\n * Based on bitcoinjs-lib MIT https://github.com/bitcoinjs/bs58check/blob/12b3e700f355c5c49d0be3f8fc29be6c66e753e9/base.js\n * @ignore\n */\nexport function base58CheckDecode(btcAddress: string): {\n  version: number;\n  hash: Uint8Array;\n} {\n  const bytes = base58.decode(btcAddress);\n  const payload = bytes.slice(0, -4);\n  const checksum = bytes.slice(-4);\n  const newChecksum = sha256(sha256(payload));\n\n  if (\n    (checksum[0] ^ newChecksum[0]) |\n    (checksum[1] ^ newChecksum[1]) |\n    (checksum[2] ^ newChecksum[2]) |\n    (checksum[3] ^ newChecksum[3])\n  ) {\n    throw new Error('Invalid checksum');\n  }\n\n  if (payload.length !== 21) throw new TypeError('Invalid address length');\n\n  const version = readUInt8(payload, 0);\n  const hash = payload.slice(1);\n\n  return { version, hash };\n}\n\n/**\n * @ignore\n */\nexport function base58Encode(hash: Uint8Array) {\n  const checksum = sha256(sha256(hash));\n  return base58.encode(concatBytes(hash, checksum).slice(0, hash.length + 4));\n}\n\n/**\n * @ignore\n */\nexport function base58CheckEncode(version: number, hash: Uint8Array) {\n  return base58Encode(concatBytes(new Uint8Array([version]), hash.slice(0, 20)));\n}\n\n/**\n * @ignore\n */\nexport function publicKeyToBtcAddress(\n  publicKey: string | Uint8Array,\n  version: number = BITCOIN_PUBKEYHASH\n) {\n  const publicKeyBytes = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n  const publicKeyHash160 = hashRipemd160(hashSha256Sync(publicKeyBytes));\n  return base58CheckEncode(version, publicKeyHash160);\n}\n\n/**\n * @ignore\n * @returns a compressed public key\n */\nexport function getPublicKeyFromPrivate(privateKey: PrivateKey): string {\n  const privateKeyBytes = privateKeyToBytes(privateKey);\n  // for backwards compatibility we always return a compressed public key, regardless of private key mode\n  return bytesToHex(nobleGetPublicKey(privateKeyBytes.slice(0, 32), true));\n}\n\n/**\n * @ignore\n */\nexport function ecSign(messageHash: Uint8Array, privateKey: PrivateKey) {\n  return signSync(messageHash, privateKeyToBytes(privateKey).slice(0, 32), {\n    der: false,\n  });\n}\n","import { ripemd160 } from '@noble/hashes/ripemd160';\n\nexport function hashRipemd160(data: Uint8Array) {\n  return ripemd160(data);\n}\n","import {\n  readUInt16LE,\n  readUInt32LE,\n  readUInt8,\n  writeUInt16LE,\n  writeUInt32LE,\n  writeUInt8,\n} from '@stacks/common';\n\n// The following methods are based on `bitcoinjs/varuint-bitcoin` implementation\n// https://github.com/bitcoinjs/varuint-bitcoin/blob/8342fe7362f20a412d61b9ade20839aafaa7f78e/index.js\n\n// Copyright (c) 2016 Kirill Fomichev\n// Parts of this software are based on https://github.com/mappum/bitcoin-protocol\n// Copyright (c) 2016 Matt Bell\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the “Software”), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n\n// Number.MAX_SAFE_INTEGER\nconst MAX_SAFE_INTEGER = 9_007_199_254_740_991;\n\nfunction ensureUInt53(n: number) {\n  if (n < 0 || n > MAX_SAFE_INTEGER || n % 1 !== 0) throw new RangeError('value out of range');\n}\n\n/** @ignore */\nexport function encode(number: number, bytes?: Uint8Array, offset: number = 0) {\n  ensureUInt53(number);\n  if (!bytes) bytes = new Uint8Array(encodingLength(number));\n\n  // 8 bit\n  if (number < 0xfd) {\n    writeUInt8(bytes, number, offset);\n\n    // 16 bit\n  } else if (number <= 0xff_ff) {\n    writeUInt8(bytes, 0xfd, offset);\n    writeUInt16LE(bytes, number, offset + 1);\n\n    // 32 bit\n  } else if (number <= 0xff_ff_ff_ff) {\n    writeUInt8(bytes, 0xfe, offset);\n    writeUInt32LE(bytes, number, offset + 1);\n\n    // 64 bit\n  } else {\n    writeUInt8(bytes, 0xff, offset);\n    writeUInt32LE(bytes, number >>> 0, offset + 1);\n    writeUInt32LE(bytes, (number / 0x1_00_00_00_00) | 0, offset + 5);\n  }\n\n  return bytes;\n}\n\n/** @ignore */\nexport function decode(bytes: Uint8Array, offset: number = 0) {\n  const first = readUInt8(bytes, offset);\n\n  // 8 bit\n  if (first < 0xfd) {\n    return first;\n\n    // 16 bit\n  } else if (first === 0xfd) {\n    return readUInt16LE(bytes, offset + 1);\n\n    // 32 bit\n  } else if (first === 0xfe) {\n    return readUInt32LE(bytes, offset + 1);\n\n    // 64 bit\n  } else {\n    const lo = readUInt32LE(bytes, offset + 1);\n    const hi = readUInt32LE(bytes, offset + 5);\n    const number = hi * 0x01_00_00_00_00 + lo;\n    ensureUInt53(number);\n\n    return number;\n  }\n}\n\n/** @ignore */\nexport function encodingLength(number: number) {\n  ensureUInt53(number);\n\n  return number < 0xfd ? 1 : number <= 0xff_ff ? 3 : number <= 0xff_ff_ff_ff ? 5 : 9;\n}\n","import { sha256 } from '@noble/hashes/sha256';\nimport { concatBytes, utf8ToBytes } from '@stacks/common';\nimport { decode, encode, encodingLength } from './varuint';\n\n// 'Stacks Signed Message:\\n'.length === 23\n// 'Stacks Signed Message:\\n'.length.toString(16) === 17\nconst chainPrefix = '\\x17Stacks Signed Message:\\n';\n\nexport function hashMessage(message: string, prefix: string = chainPrefix): Uint8Array {\n  return sha256(encodeMessage(message, prefix));\n}\n\nexport function encodeMessage(\n  /** UTF-8 string or Uint8Array (bytes) */\n  message: string | Uint8Array,\n  prefix: string = chainPrefix\n): Uint8Array {\n  const messageBytes = typeof message == 'string' ? utf8ToBytes(message) : message;\n  const encodedLength = encode(messageBytes.length);\n  return concatBytes(utf8ToBytes(prefix), encodedLength, messageBytes);\n}\n\nexport function decodeMessage(\n  encodedMessage: Uint8Array,\n  prefix: string = chainPrefix\n): Uint8Array {\n  // Remove the chain prefix\n  const prefixByteLength = utf8ToBytes(prefix).byteLength;\n  const messageWithoutChainPrefix = encodedMessage.subarray(prefixByteLength);\n  const decoded = decode(messageWithoutChainPrefix);\n  const varIntLength = encodingLength(decoded);\n  // Remove the varint prefix\n  return messageWithoutChainPrefix.slice(varIntLength);\n}\n","import { Signature, verify } from '@noble/secp256k1';\n\nexport { Signature, verify as verifySignature };\n\n/**\n * Calculate the AES-CBC ciphertext output byte length a given input length.\n * AES has a fixed block size of 16-bytes regardless key size.\n * @ignore\n */\nexport function getAesCbcOutputLength(inputByteLength: number) {\n  // AES-CBC block mode rounds up to the next block size.\n  const cipherTextLength = (Math.floor(inputByteLength / 16) + 1) * 16;\n  return cipherTextLength;\n}\n\n/**\n * Calculate the base64 encoded string length for a given input length.\n * This is equivalent to the byte length when the string is ASCII or UTF8-8\n * encoded.\n * @param number\n */\nexport function getBase64OutputLength(inputByteLength: number) {\n  const encodedLength = Math.ceil(inputByteLength / 3) * 4;\n  return encodedLength;\n}\n\n/**\n *\n * @ignore\n */\nexport function hashCode(string: string) {\n  let hash = 0;\n  if (string.length === 0) return hash;\n  for (let i = 0; i < string.length; i++) {\n    const character = string.charCodeAt(i);\n    hash = (hash << 5) - hash + character;\n    hash &= hash;\n  }\n  return hash & 0x7fffffff;\n}\n","import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport {\n  getPublicKey,\n  getSharedSecret,\n  Point,\n  Signature,\n  signSync,\n  utils,\n  verify,\n} from '@noble/secp256k1';\nimport {\n  bigIntToBytes,\n  bytesToHex,\n  bytesToUtf8,\n  concatBytes,\n  FailedDecryptionError,\n  hexToBigInt,\n  hexToBytes,\n  parseRecoverableSignatureVrs,\n  signatureRsvToVrs,\n  utf8ToBytes,\n} from '@stacks/common';\nimport { fromByteArray, toByteArray } from 'base64-js';\nimport { createCipher } from './aesCipher';\nimport { getPublicKeyFromPrivate } from './keys';\nimport { encodeMessage, hashMessage } from './messageSignature';\nimport { hashSha256Sync, hashSha512Sync } from './sha2Hash';\nimport { getAesCbcOutputLength, getBase64OutputLength } from './utils';\n\n/**\n * To use secp256k1.signSync set utils.hmacSha256Sync to a function using noble-hashes\n * secp256k1.signSync is the counter part of secp256k1.sign (async version)\n * secp256k1.signSync is used within signECDSA in this file\n * secp256k1.signSync is used to maintain the semantics of signECDSA while migrating from elliptic lib\n * utils.hmacSha256Sync docs: https://github.com/paulmillr/noble-secp256k1 readme file\n */\nutils.hmacSha256Sync = (key: Uint8Array, ...msgs: Uint8Array[]) => {\n  const h = hmac.create(sha256, key);\n  msgs.forEach(msg => h.update(msg));\n  return h.digest();\n};\n\n/**\n * Controls how the encrypted data bytes will be encoded as a string in the JSON payload.\n * Options:\n *    `hex` -- the legacy default, file size increase 100% (2x).\n *    `base64` -- file size increased ~33%.\n * @ignore\n */\nexport type CipherTextEncoding = 'hex' | 'base64';\n\n/**\n * @ignore\n */\nexport type CipherObject = {\n  iv: string;\n  ephemeralPK: string;\n  cipherText: string;\n  /** If undefined then hex encoding is used for the `cipherText` string. */\n  cipherTextEncoding?: CipherTextEncoding;\n  mac: string;\n  wasString: boolean;\n};\n\n/**\n * @ignore\n */\nexport type SignedCipherObject = {\n  /** Hex encoded DER signature (up to 144 chars) */\n  signature: string;\n  /** Hex encoded public key (66 char length) */\n  publicKey: string;\n  /** The stringified json of a `CipherObject` */\n  cipherText: string;\n};\n\n/**\n * @ignore\n */\nexport enum InvalidPublicKeyReason {\n  InvalidFormat = 'InvalidFormat',\n  IsNotPoint = 'IsNotPoint',\n}\n\n/**\n * @ignore\n */\nexport async function aes256CbcEncrypt(\n  iv: Uint8Array,\n  key: Uint8Array,\n  plaintext: Uint8Array\n): Promise<Uint8Array> {\n  const cipher = await createCipher();\n  return await cipher.encrypt('aes-256-cbc', key, iv, plaintext);\n}\n\n/**\n * @ignore\n */\nasync function aes256CbcDecrypt(\n  iv: Uint8Array,\n  key: Uint8Array,\n  ciphertext: Uint8Array\n): Promise<Uint8Array> {\n  const cipher = await createCipher();\n  return await cipher.decrypt('aes-256-cbc', key, iv, ciphertext);\n}\n\n/**\n * @ignore\n */\nexport function hmacSha256(key: Uint8Array, content: Uint8Array): Uint8Array {\n  return hmac(sha256, key, content);\n}\n\n/**\n * @ignore\n */\nfunction equalsConstTime(a: Uint8Array, b: Uint8Array) {\n  if (a.length !== b.length) {\n    return false;\n  }\n  let res = 0;\n  for (let i = 0; i < a.length; i++) {\n    res |= a[i] ^ b[i];\n  }\n  return res === 0;\n}\n\n/**\n * @ignore\n */\nfunction sharedSecretToKeys(sharedSecret: Uint8Array): {\n  encryptionKey: Uint8Array;\n  hmacKey: Uint8Array;\n} {\n  // generate mac and encryption key from shared secret\n  const hashedSecret = hashSha512Sync(sharedSecret);\n  return {\n    encryptionKey: hashedSecret.slice(0, 32),\n    hmacKey: hashedSecret.slice(32),\n  };\n}\n\n/**\n * @ignore\n */\nfunction allHexChars(maybe: string): boolean {\n  return maybe.match(/^[0-9a-f]+$/i) !== null;\n}\n\n/**\n * @ignore\n */\nfunction isValidPublicKey(pub: string): {\n  result: boolean;\n  reason: string | null;\n  reason_data: string | null;\n} {\n  const invalidFormat = {\n    result: false,\n    reason_data: 'Invalid public key format',\n    reason: InvalidPublicKeyReason.InvalidFormat,\n  };\n  const invalidPoint = {\n    result: false,\n    reason_data: 'Public key is not a point',\n    reason: InvalidPublicKeyReason.IsNotPoint,\n  };\n  if (pub.length !== 66 && pub.length !== 130) return invalidFormat;\n\n  const firstByte = pub.slice(0, 2);\n\n  // uncompressed public key\n  if (pub.length === 130 && firstByte !== '04') return invalidFormat;\n\n  // compressed public key\n  if (pub.length === 66 && firstByte !== '02' && firstByte !== '03') return invalidFormat;\n\n  if (!allHexChars(pub)) return invalidFormat;\n\n  try {\n    // Converts public key to Point\n    const point = Point.fromHex(pub);\n\n    // Verify point on curve is valid if it conforms to equation\n    // Validate the public key\n    // Throws: Point is not on elliptic curve if point is not on curve\n    point.assertValidity();\n\n    // Validation passed\n    return {\n      result: true,\n      reason_data: null,\n      reason: null,\n    };\n  } catch (e) {\n    return invalidPoint;\n  }\n}\n\n/**\n * Hex encodes a 32-byte bigint instance.\n * The result string is zero padded and always 64 characters in length.\n * @ignore @internal @deprecated\n */\nexport function getHexFromBN(bnInput: bigint): string {\n  const hexOut = bnInput.toString(16);\n  if (hexOut.length === 64) {\n    return hexOut;\n  } else if (hexOut.length < 64) {\n    // pad with leading zeros\n    // the padStart function would require node 9\n    const padding = '0'.repeat(64 - hexOut.length);\n    return `${padding}${hexOut}`;\n  } else {\n    throw new Error('Generated a > 32-byte bigint for encryption. Failing.');\n  }\n}\n\n/**\n * Converts to zero padded 32 bytes\n * @ignore @deprecated\n */\nexport function getBytesFromBN(bnInput: bigint): Uint8Array {\n  // todo: remove method?\n  const result = bigIntToBytes(bnInput, 32);\n  if (result.byteLength !== 32) {\n    throw new Error('Failed to generate a 32-byte Uint8Array');\n  }\n  return result;\n}\n\n/**\n * Get details about the JSON envelope size overhead for ciphertext payloads.\n * @ignore\n */\nexport function getCipherObjectWrapper(opts: {\n  wasString: boolean;\n  cipherTextEncoding: CipherTextEncoding;\n}): {\n  /** The stringified JSON string of an empty `CipherObject`. */\n  payloadShell: string;\n  /** Total string length of all the `CipherObject` values that always have constant lengths. */\n  payloadValuesLength: number;\n} {\n  // Placeholder structure of the ciphertext payload, used to determine the\n  // stringified JSON overhead length.\n  const shell: CipherObject = {\n    iv: '',\n    ephemeralPK: '',\n    mac: '',\n    cipherText: '',\n    wasString: !!opts.wasString,\n  };\n  if (opts.cipherTextEncoding === 'base64') {\n    shell.cipherTextEncoding = 'base64';\n  }\n  // Hex encoded 16 bytes.\n  const ivLength = 32;\n  // Hex encoded, compressed EC pubkey of 33 bytes.\n  const ephemeralPKLength = 66;\n  // Hex encoded 32 byte hmac-sha256.\n  const macLength = 64;\n  return {\n    payloadValuesLength: ivLength + ephemeralPKLength + macLength,\n    payloadShell: JSON.stringify(shell),\n  };\n}\n\n/**\n * Get details about the JSON envelope size overhead for signed ciphertext payloads.\n * @param payloadShell - The JSON stringified empty `CipherObject`\n * @ignore\n */\nexport function getSignedCipherObjectWrapper(payloadShell: string): {\n  /** The stringified JSON string of an empty `SignedCipherObject`. */\n  signedPayloadValuesLength: number;\n  /** Total string length of all the `SignedCipherObject` values\n   * that always have constant lengths */\n  signedPayloadShell: string;\n} {\n  // Placeholder structure of the signed ciphertext payload, used to determine the\n  // stringified JSON overhead length.\n  const shell: SignedCipherObject = {\n    signature: '',\n    publicKey: '',\n    cipherText: payloadShell,\n  };\n  // Hex encoded DER signature, up to 72 byte length.\n  const signatureLength = 144;\n  // Hex encoded 33 byte public key.\n  const publicKeyLength = 66;\n  return {\n    signedPayloadValuesLength: signatureLength + publicKeyLength,\n    signedPayloadShell: JSON.stringify(shell),\n  };\n}\n\n/**\n * Fast function that determines the final ASCII string byte length of the\n * JSON stringified ECIES encrypted payload.\n * @ignore\n */\nexport function eciesGetJsonStringLength(opts: {\n  contentLength: number;\n  wasString: boolean;\n  sign: boolean;\n  cipherTextEncoding: CipherTextEncoding;\n}): number {\n  const { payloadShell, payloadValuesLength } = getCipherObjectWrapper(opts);\n\n  // Calculate the AES output length given the input length.\n  const cipherTextLength = getAesCbcOutputLength(opts.contentLength);\n\n  // Get the encoded string length of the cipherText.\n  let encodedCipherTextLength: number;\n  if (!opts.cipherTextEncoding || opts.cipherTextEncoding === 'hex') {\n    encodedCipherTextLength = cipherTextLength * 2;\n  } else if (opts.cipherTextEncoding === 'base64') {\n    encodedCipherTextLength = getBase64OutputLength(cipherTextLength);\n  } else {\n    throw new Error(`Unexpected cipherTextEncoding \"${opts.cipherTextEncoding}\"`);\n  }\n\n  if (!opts.sign) {\n    // Add the length of the JSON envelope, ciphertext length, and length of const values.\n    return payloadShell.length + payloadValuesLength + encodedCipherTextLength;\n  } else {\n    // Get the signed version of the JSON envelope\n    const { signedPayloadShell, signedPayloadValuesLength } =\n      getSignedCipherObjectWrapper(payloadShell);\n    // Add length of the JSON envelope, ciphertext length, and length of the const values.\n    return (\n      signedPayloadShell.length +\n      signedPayloadValuesLength +\n      payloadValuesLength +\n      encodedCipherTextLength\n    );\n  }\n}\n\n// todo: simplify and remove wasstring\n/**\n * Encrypt content to elliptic curve publicKey using ECIES\n * @param publicKey - secp256k1 public key hex string\n * @param content - content to encrypt\n * @return Object containing:\n *  iv (initialization vector, hex encoding),\n *  cipherText (cipher text either hex or base64 encoded),\n *  mac (message authentication code, hex encoded),\n *  ephemeral public key (hex encoded),\n *  wasString (boolean indicating with or not to return a Uint8Array or string on decrypt)\n * @ignore\n */\nexport async function encryptECIES(\n  publicKey: string,\n  content: Uint8Array,\n  wasString: boolean,\n  cipherTextEncoding?: CipherTextEncoding\n): Promise<CipherObject> {\n  const validity = isValidPublicKey(publicKey);\n  if (!validity.result) {\n    throw validity;\n  }\n  const ephemeralPrivateKey = utils.randomPrivateKey();\n  const ephemeralPublicKey = getPublicKey(ephemeralPrivateKey, true);\n  let sharedSecret = getSharedSecret(ephemeralPrivateKey, publicKey, true);\n  // Trim the compressed mode prefix byte\n  sharedSecret = sharedSecret.slice(1);\n  const sharedKeys = sharedSecretToKeys(sharedSecret);\n  const initializationVector = utils.randomBytes(16);\n\n  const cipherText = await aes256CbcEncrypt(\n    initializationVector,\n    sharedKeys.encryptionKey,\n    content\n  );\n\n  const macData = concatBytes(initializationVector, ephemeralPublicKey, cipherText);\n  const mac = hmacSha256(sharedKeys.hmacKey, macData);\n\n  let cipherTextString: string;\n\n  if (!cipherTextEncoding || cipherTextEncoding === 'hex') {\n    cipherTextString = bytesToHex(cipherText);\n  } else if (cipherTextEncoding === 'base64') {\n    cipherTextString = fromByteArray(cipherText);\n  } else {\n    throw new Error(`Unexpected cipherTextEncoding \"${cipherTextEncoding}\"`);\n  }\n\n  const result: CipherObject = {\n    iv: bytesToHex(initializationVector),\n    ephemeralPK: bytesToHex(ephemeralPublicKey),\n    cipherText: cipherTextString,\n    mac: bytesToHex(mac),\n    wasString,\n  };\n  if (cipherTextEncoding && cipherTextEncoding !== 'hex') {\n    result.cipherTextEncoding = cipherTextEncoding;\n  }\n  return result;\n}\n\n/**\n * Decrypt content encrypted using ECIES\n * @param {String} privateKey - secp256k1 private key hex string\n * @param {Object} cipherObject - object to decrypt, should contain:\n *  iv (initialization vector), cipherText (cipher text),\n *  mac (message authentication code), ephemeralPublicKey\n *  wasString (boolean indicating with or not to return bytes or string on decrypt)\n * @return {Uint8Array} plaintext\n * @throws {FailedDecryptionError} if unable to decrypt\n * @ignore\n */\nexport async function decryptECIES(\n  privateKey: string,\n  cipherObject: CipherObject\n): Promise<Uint8Array | string> {\n  if (!cipherObject.ephemeralPK) {\n    throw new FailedDecryptionError(\n      'Unable to get public key from cipher object. ' +\n        'You might be trying to decrypt an unencrypted object.'\n    );\n  }\n  const ephemeralPK = cipherObject.ephemeralPK;\n  let sharedSecret = getSharedSecret(privateKey, ephemeralPK, true);\n  // Trim the compressed mode prefix byte\n  sharedSecret = sharedSecret.slice(1);\n  const sharedKeys = sharedSecretToKeys(sharedSecret);\n  const ivBytes = hexToBytes(cipherObject.iv);\n\n  let cipherTextBytes: Uint8Array;\n\n  if (!cipherObject.cipherTextEncoding || cipherObject.cipherTextEncoding === 'hex') {\n    cipherTextBytes = hexToBytes(cipherObject.cipherText);\n  } else if (cipherObject.cipherTextEncoding === 'base64') {\n    cipherTextBytes = toByteArray(cipherObject.cipherText);\n  } else {\n    throw new Error(`Unexpected cipherTextEncoding \"${cipherObject.cipherText}\"`);\n  }\n\n  const macData = concatBytes(ivBytes, hexToBytes(ephemeralPK), cipherTextBytes);\n  const actualMac = hmacSha256(sharedKeys.hmacKey, macData);\n  const expectedMac = hexToBytes(cipherObject.mac);\n\n  if (!equalsConstTime(expectedMac, actualMac)) {\n    throw new FailedDecryptionError('Decryption failed: failure in MAC check');\n  }\n  const plainText = await aes256CbcDecrypt(ivBytes, sharedKeys.encryptionKey, cipherTextBytes);\n\n  if (cipherObject.wasString) {\n    return bytesToUtf8(plainText);\n  }\n  return plainText;\n}\n\n/**\n * Sign content using ECDSA\n *\n * @param {string} privateKey - secp256k1 private key hex string\n * @param {string | Uint8Array} content - content to sign\n * @return {Object} contains:\n * signature - Hex encoded DER signature\n * public key - Hex encoded private string taken from privateKey\n * @ignore\n */\nexport function signECDSA(\n  privateKey: string,\n  content: string | Uint8Array\n): {\n  publicKey: string;\n  signature: string;\n} {\n  const contentBytes = typeof content === 'string' ? utf8ToBytes(content) : content;\n  const publicKey = getPublicKeyFromPrivate(privateKey);\n  const contentHash = hashSha256Sync(contentBytes);\n  const signature = signSync(contentHash, privateKey);\n\n  return {\n    signature: bytesToHex(signature),\n    publicKey,\n  };\n}\n\n/**\n * Verify content using ECDSA\n * @param {String | Uint8Array} content - Content to verify was signed\n * @param {String} publicKey - secp256k1 private key hex string\n * @param {String} signature - Hex encoded DER signature\n * @return {Boolean} returns true when signature matches publickey + content, false if not\n * @ignore\n */\nexport function verifyECDSA(\n  content: string | Uint8Array,\n  publicKey: string,\n  signature: string\n): boolean {\n  const contentBytes = typeof content === 'string' ? utf8ToBytes(content) : content;\n  const contentHash = hashSha256Sync(contentBytes);\n  // verify() is strict: true by default. High-s signatures are rejected, which mirrors libsecp behavior\n  // Set verify options to strict: false, to support the legacy stacks implementations\n  // Reference: https://github.com/paulmillr/noble-secp256k1/releases/tag/1.4.0\n  return verify(signature, contentHash, publicKey, { strict: false });\n}\n\ninterface VerifyMessageSignatureArgs {\n  signature: string;\n  message: string | Uint8Array;\n  publicKey: string;\n}\n\n/**\n * Verify message signature (VRS format) with recoverable public key\n * @deprecated The Clarity compatible {@link verifyMessageSignatureRsv} is preferred\n */\nexport function verifyMessageSignature({\n  signature,\n  message,\n  publicKey,\n}: VerifyMessageSignatureArgs): boolean {\n  // todo: remove method and pull body to `verifyMessageSignatureRsv`\n  const { r, s } = parseRecoverableSignatureVrs(signature);\n  const sig = new Signature(hexToBigInt(r), hexToBigInt(s));\n  const hashedMsg = typeof message === 'string' ? hashMessage(message) : message;\n  // verify() is strict: true by default. High-s signatures are rejected, which mirrors libsecp behavior\n  // Set verify options to strict: false, to support the legacy stacks implementations\n  // Reference: https://github.com/paulmillr/noble-secp256k1/releases/tag/1.4.0\n  const verificationResult = verify(sig, hashedMsg, publicKey, { strict: false });\n\n  // Additional Check for Legacy Prefix ++++++++++++++++++++++++++++++++++++++++\n  if (verificationResult || typeof message !== 'string') return verificationResult;\n\n  const LEGACY_PREFIX = '\\x18Stacks Message Signing:\\n';\n  const legacyHash = sha256(encodeMessage(message, LEGACY_PREFIX));\n  return verify(sig, legacyHash, publicKey, { strict: false });\n  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n}\n\n/**\n * Verifies a Clarity compatible signed message using a public key. The\n * `signature` option needs to be in RSV format.\n */\nexport function verifyMessageSignatureRsv({\n  signature,\n  message,\n  publicKey,\n}: VerifyMessageSignatureArgs): boolean {\n  return verifyMessageSignature({\n    signature: signatureRsvToVrs(signature),\n    message,\n    publicKey,\n  });\n}\n","import { utils } from '@noble/secp256k1';\n\n/**\n * Reexports @noble/secp256k1's randombytes\n * Generates bytes with random bytes of given length\n * @param bytesLength an optional bytes length, default `32` bytes\n * @return {Uint8Array} random bytes\n */\nexport const randomBytes = (bytesLength: number = 32): Uint8Array => utils.randomBytes(bytesLength);\n\n/** @deprecated @ignore */\nexport type GetRandomBytes = (count: number) => Uint8Array;\n","import { utf8ToBytes } from '@stacks/common';\nimport {\n  CipherTextEncoding,\n  decryptECIES,\n  encryptECIES,\n  signECDSA,\n  SignedCipherObject,\n} from './ec';\nimport { getPublicKeyFromPrivate } from './keys';\n\nexport interface EncryptionOptions {\n  /**\n   * If set to `true` the data is signed using ECDSA on SHA256 hashes with the user's\n   * app private key. If a string is specified, it is used as the private key instead\n   * of the user's app private key.\n   * @default false\n   */\n  sign?: boolean | string;\n  /**\n   * String encoding format for the cipherText bytes.\n   * Currently defaults to 'hex' for legacy backwards-compatibility.\n   * Only used if the `encrypt` option is also used.\n   * Note: in the future this should default to 'base64' for the significant\n   * file size reduction.\n   */\n  cipherTextEncoding?: CipherTextEncoding;\n  /**\n   * Specifies if the original unencrypted content is a ASCII or UTF-8 string.\n   * For example stringified JSON.\n   * If true, then when the ciphertext is decrypted, it will be returned as\n   * a `string` type variable, otherwise will be returned as bytes.\n   */\n  wasString?: boolean;\n}\n\n/**\n * Specify encryption options, and whether to sign the ciphertext.\n */\nexport interface EncryptContentOptions extends EncryptionOptions {\n  /**\n   * Encrypt the data with this key.\n   */\n  publicKey?: string;\n  /**\n   * Encrypt the data with the public key corresponding to the supplied private key\n   */\n  privateKey?: string;\n}\n\n/**\n * Encrypts the data provided with the app public key.\n * @param {string | Uint8Array} content - data to encrypt\n * @param {Object} [options=null] - options object\n * @param {String} options.publicKey - the hex string of the ECDSA public\n * key to use for encryption. If not provided, will use user's appPublicKey.\n * @return {String} Stringified ciphertext object\n */\nexport async function encryptContent(\n  content: string | Uint8Array,\n  options?: EncryptContentOptions\n): Promise<string> {\n  const opts = Object.assign({}, options);\n  let privateKey: string | undefined;\n  if (!opts.publicKey) {\n    if (!opts.privateKey) {\n      throw new Error('Either public key or private key must be supplied for encryption.');\n    }\n    opts.publicKey = getPublicKeyFromPrivate(opts.privateKey);\n  }\n  const wasString =\n    typeof opts.wasString === 'boolean' ? opts.wasString : typeof content === 'string';\n  const contentBytes = typeof content === 'string' ? utf8ToBytes(content) : content;\n  const cipherObject = await encryptECIES(\n    opts.publicKey,\n    contentBytes,\n    wasString,\n    opts.cipherTextEncoding\n  );\n  let cipherPayload = JSON.stringify(cipherObject);\n  if (opts.sign) {\n    if (typeof opts.sign === 'string') {\n      privateKey = opts.sign;\n    } else if (!privateKey) {\n      privateKey = opts.privateKey;\n    }\n    const signatureObject = signECDSA(privateKey!, cipherPayload);\n    const signedCipherObject: SignedCipherObject = {\n      signature: signatureObject.signature,\n      publicKey: signatureObject.publicKey,\n      cipherText: cipherPayload,\n    };\n    cipherPayload = JSON.stringify(signedCipherObject);\n  }\n  return cipherPayload;\n}\n\n/**\n * Decrypts data encrypted with `encryptContent` with the\n * transit private key.\n * @param {string | Uint8Array} content - encrypted content.\n * @param {Object} [options=null] - options object\n * @param {string} options.privateKey - the hex string of the ECDSA private\n * key to use for decryption. If not provided, will use user's appPrivateKey.\n * @return {string | Uint8Array} decrypted content.\n */\nexport function decryptContent(\n  content: string,\n  options?: {\n    privateKey?: string;\n  }\n): Promise<string | Uint8Array> {\n  const opts = Object.assign({}, options);\n  if (!opts.privateKey) {\n    throw new Error('Private key is required for decryption.');\n  }\n\n  try {\n    const cipherObject = JSON.parse(content);\n    return decryptECIES(opts.privateKey, cipherObject);\n  } catch (err) {\n    if (err instanceof SyntaxError) {\n      throw new Error(\n        'Failed to parse encrypted content JSON. The content may not ' +\n          'be encrypted. If using getFile, try passing { decrypt: false }.'\n      );\n    } else {\n      throw err;\n    }\n  }\n}\n","import { utf8ToBytes, writeUInt32BE } from '@stacks/common';\nimport { getCryptoLib } from './cryptoUtils';\n\nexport type Pbkdf2Digests = 'sha512' | 'sha256';\n\nexport interface Pbkdf2 {\n  derive(\n    password: string,\n    salt: Uint8Array,\n    iterations: number,\n    keyLength: number,\n    digest: Pbkdf2Digests\n  ): Promise<Uint8Array>;\n}\n\ntype NodePbkdf2Fn = typeof import('crypto').pbkdf2;\n\nexport class NodeCryptoPbkdf2 implements Pbkdf2 {\n  nodePbkdf2: NodePbkdf2Fn;\n\n  constructor(nodePbkdf2: NodePbkdf2Fn) {\n    this.nodePbkdf2 = nodePbkdf2;\n  }\n\n  async derive(\n    password: string,\n    salt: Uint8Array,\n    iterations: number,\n    keyLength: number,\n    digest: Pbkdf2Digests\n  ): Promise<Uint8Array> {\n    if (digest !== 'sha512' && digest !== 'sha256') {\n      throw new Error(`Unsupported digest \"${digest}\" for Pbkdf2`);\n    }\n    return new Promise((resolve, reject) => {\n      this.nodePbkdf2(password, salt, iterations, keyLength, digest, (error, result) => {\n        if (error) {\n          reject(error);\n        }\n        resolve(result);\n      });\n    });\n  }\n}\n\nexport class WebCryptoPbkdf2 implements Pbkdf2 {\n  subtleCrypto: SubtleCrypto;\n\n  constructor(subtleCrypto: SubtleCrypto) {\n    this.subtleCrypto = subtleCrypto;\n  }\n\n  async derive(\n    password: string,\n    salt: Uint8Array,\n    iterations: number,\n    keyLength: number,\n    digest: Pbkdf2Digests\n  ): Promise<Uint8Array> {\n    let algo: string;\n    if (digest === 'sha256') {\n      algo = 'SHA-256';\n    } else if (digest === 'sha512') {\n      algo = 'SHA-512';\n    } else {\n      throw new Error(`Unsupported Pbkdf2 digest algorithm \"${digest}\"`);\n    }\n\n    const passwordBytes = utf8ToBytes(password);\n    try {\n      const key = await this.subtleCrypto.importKey('raw', passwordBytes, 'PBKDF2', false, [\n        'deriveBits',\n      ]);\n      const result = await this.subtleCrypto.deriveBits(\n        {\n          name: 'PBKDF2',\n          salt,\n          iterations,\n          hash: { name: algo },\n        },\n        key,\n        keyLength * 8\n      );\n      return new Uint8Array(result);\n    } catch (error) {\n      // Browser appears to support WebCrypto but missing pbkdf2 support.\n      const partialWebCrypto = new WebCryptoPartialPbkdf2(this.subtleCrypto);\n      return partialWebCrypto.derive(password, salt, iterations, keyLength, digest);\n    }\n  }\n}\n\nexport class WebCryptoPartialPbkdf2 implements Pbkdf2 {\n  // An async implementation for browsers that support WebCrypto hmac\n  // but not pbkdf2. Extracted from crypto-browserify/pbkdf2 and modified to\n  // use WebCrypto for hmac operations.\n  // Original: https://github.com/crypto-browserify/pbkdf2/tree/v3.0.17/lib\n\n  subtleCrypto: SubtleCrypto;\n\n  constructor(subtleCrypto: SubtleCrypto) {\n    this.subtleCrypto = subtleCrypto;\n  }\n\n  async derive(\n    password: string,\n    salt: Uint8Array,\n    iterations: number,\n    keyLength: number,\n    digest: Pbkdf2Digests\n  ): Promise<Uint8Array> {\n    if (digest !== 'sha512' && digest !== 'sha256') {\n      throw new Error(`Unsupported digest \"${digest}\" for Pbkdf2`);\n    }\n    const passwordBytes = utf8ToBytes(password);\n    const algo = digest === 'sha512' ? 'SHA-512' : 'SHA-256';\n    const algoOpts = { name: 'HMAC', hash: algo };\n    const hmacDigest = (key: ArrayBuffer, data: ArrayBuffer) =>\n      this.subtleCrypto\n        .importKey('raw', key, algoOpts, true, ['sign'])\n        .then(cryptoKey => this.subtleCrypto.sign(algoOpts, cryptoKey, data))\n        .then(result => new Uint8Array(result));\n\n    const DK = new Uint8Array(keyLength);\n    const saltLength = salt.length;\n    const block1 = new Uint8Array(saltLength + 4);\n    block1.set(salt);\n    let destPos = 0;\n    const hLen = digest === 'sha512' ? 64 : 32;\n    const l = Math.ceil(keyLength / hLen);\n\n    for (let i = 1; i <= l; i++) {\n      writeUInt32BE(block1, i, saltLength);\n      const T = await hmacDigest(passwordBytes, block1);\n      let U = T;\n      for (let j = 1; j < iterations; j++) {\n        U = await hmacDigest(passwordBytes, U);\n        for (let k = 0; k < hLen; k++) {\n          T[k] ^= U[k];\n        }\n      }\n      DK.set(T.subarray(0, DK.byteLength - destPos), destPos);\n      destPos += hLen;\n    }\n    return DK;\n  }\n}\n\nexport async function createPbkdf2(): Promise<Pbkdf2> {\n  const cryptoLib = await getCryptoLib();\n  if (cryptoLib.name === 'subtleCrypto') {\n    return new WebCryptoPbkdf2(cryptoLib.lib);\n  }\n  return new NodeCryptoPbkdf2(cryptoLib.lib.pbkdf2);\n}\n","import { entropyToMnemonic, mnemonicToEntropy, validateMnemonic } from '@scure/bip39';\n// Word lists not imported by default as that would increase bundle sizes too much as in case of bitcoinjs/bip39\n// Use default english world list similar to bitcoinjs/bip39\n// Backward compatible with bitcoinjs/bip39 dependency\n// Very small in size as compared to bitcoinjs/bip39 wordlist\n// Reference: https://github.com/paulmillr/scure-bip39\nimport { wordlist } from '@scure/bip39/wordlists/english';\nimport { bytesToHex, concatBytes, equals, hexToBytes } from '@stacks/common';\nimport { createCipher } from './aesCipher';\nimport { GetRandomBytes, randomBytes } from './cryptoRandom';\nimport { hmacSha256 } from './ec';\nimport { createPbkdf2 } from './pbkdf2';\nimport { createSha2Hash } from './sha2Hash';\n\n/**\n * Encrypt a raw mnemonic phrase to be password protected\n * @param {string} phrase - Raw mnemonic phrase\n * @param {string} password - Password to encrypt mnemonic with\n * @return {Promise<Uint8Array>} The encrypted phrase\n * @ignore\n * */\nexport async function encryptMnemonic(\n  phrase: string,\n  password: string,\n  opts?: {\n    getRandomBytes?: GetRandomBytes;\n  }\n): Promise<Uint8Array> {\n  // hex encoded mnemonic string\n  let mnemonicEntropy: string;\n  try {\n    // must be bip39 mnemonic\n    // `mnemonicToEntropy` converts mnemonic string to raw entropy in form of byte array\n    const entropyBytes = mnemonicToEntropy(phrase, wordlist);\n    // Convert byte array to hex string\n    mnemonicEntropy = bytesToHex(entropyBytes);\n  } catch (error) {\n    console.error('Invalid mnemonic phrase provided');\n    console.error(error);\n    throw new Error('Not a valid bip39 mnemonic');\n  }\n\n  // normalize plaintext to fixed length byte string\n  const plaintextNormalized = hexToBytes(mnemonicEntropy);\n\n  // AES-128-CBC with SHA256 HMAC\n  const pbkdf2 = await createPbkdf2();\n  const salt = opts?.getRandomBytes ? opts.getRandomBytes(16) : randomBytes(16);\n  const keysAndIV = await pbkdf2.derive(password, salt, 100_000, 48, 'sha512');\n  const encKey = keysAndIV.slice(0, 16);\n  const macKey = keysAndIV.slice(16, 32);\n  const iv = keysAndIV.slice(32, 48);\n\n  const cipher = await createCipher();\n  const cipherText = await cipher.encrypt('aes-128-cbc', encKey, iv, plaintextNormalized);\n\n  const hmacPayload = concatBytes(salt, cipherText);\n  const hmacDigest = hmacSha256(macKey, hmacPayload);\n\n  return concatBytes(salt, hmacDigest, cipherText);\n}\n\n// Used to distinguish bad password during decrypt vs invalid format\nclass PasswordError extends Error {}\n\n/**\n * @ignore\n */\nasync function decryptMnemonicBytes(dataBytes: Uint8Array, password: string): Promise<string> {\n  const salt = dataBytes.slice(0, 16);\n  const hmacSig = dataBytes.slice(16, 48); // 32 bytes\n  const cipherText = dataBytes.slice(48);\n  const hmacPayload = concatBytes(salt, cipherText);\n\n  const pbkdf2 = await createPbkdf2();\n  const keysAndIV = await pbkdf2.derive(password, salt, 100000, 48, 'sha512');\n  const encKey = keysAndIV.slice(0, 16);\n  const macKey = keysAndIV.slice(16, 32);\n  const iv = keysAndIV.slice(32, 48);\n\n  const decipher = await createCipher();\n  const decryptedResult = await decipher.decrypt('aes-128-cbc', encKey, iv, cipherText);\n\n  const hmacDigest = hmacSha256(macKey, hmacPayload);\n\n  // hash both hmacSig and hmacDigest so string comparison time\n  // is uncorrelated to the ciphertext\n  const sha2Hash = await createSha2Hash();\n  const hmacSigHash = await sha2Hash.digest(hmacSig);\n  const hmacDigestHash = await sha2Hash.digest(hmacDigest);\n\n  if (!equals(hmacSigHash, hmacDigestHash)) {\n    // not authentic\n    throw new PasswordError('Wrong password (HMAC mismatch)');\n  }\n\n  let mnemonic: string;\n  try {\n    // Converts raw entropy in form of byte array to mnemonic string\n    mnemonic = entropyToMnemonic(decryptedResult, wordlist);\n  } catch (error) {\n    console.error('Error thrown by `entropyToMnemonic`');\n    console.error(error);\n    throw new PasswordError('Wrong password (invalid plaintext)');\n  }\n  // Validates mnemonic for being 12-24 words contained in `wordlist`\n  if (!validateMnemonic(mnemonic, wordlist)) {\n    throw new PasswordError('Wrong password (invalid plaintext)');\n  }\n\n  return mnemonic;\n}\n\n/**\n * Decrypt an encrypted mnemonic phrase with a password.\n * @param data - Bytes or hex-encoded string of the encrypted mnemonic\n * @param password - Password for data\n * @return {string} the raw mnemonic phrase\n * @ignore\n */\nexport async function decryptMnemonic(\n  data: string | Uint8Array,\n  password: string\n): Promise<string> {\n  const dataBytes = typeof data === 'string' ? hexToBytes(data) : data;\n  return await decryptMnemonicBytes(dataBytes, password);\n}\n"],"names":["root","factory","exports","module","define","amd","this","leafPrototypes","getProto","Object","defineProperty","value","randomBytes","wrapConstructorWithOpts","wrapConstructor","checkOpts","Hash","concatBytes","toBytes","utf8ToBytes","asyncLoop","nextTick","hexToBytes","bytesToHex","isLE","rotr","createView","u32","u8","crypto_1","arr","Uint8Array","buffer","byteOffset","byteLength","Uint32Array","Math","floor","DataView","word","shift","Error","hexes","Array","from","length","v","i","toString","padStart","str","TypeError","TextEncoder","encode","data","uint8a","hex","array","j","hexByte","slice","byte","Number","parseInt","isNaN","async","iters","tick","cb","ts","Date","now","diff","arrays","every","a","reduce","result","pad","set","clone","_cloneInto","defaults","opts","undefined","obj","prototype","call","constructor","assign","hashConstructor","hashC","message","update","digest","tmp","outputLen","blockLen","create","hashCons","msg","bytesLength","crypto","web","getRandomValues","node","add","toBig","split","fromBig","U32_MASK64","BigInt","_32n","n","le","h","l","lst","Ah","Al","Bh","Bl","u64","shrSH","s","shrSL","rotrSH","rotrSL","rotrBH","rotrBL","rotr32H","rotr32L","rotlSH","rotlSL","rotlBH","rotlBL","add3L","Cl","add3H","low","Ch","add4L","Dl","add4H","Dh","add5H","Eh","add5L","El","_assert_1","sha256_1","base_1","nfkd","normalize","assertEntropy","entropy","default","bytes","calcChecksum","bitsLeft","sha256","getCoder","wordlist","isArray","forEach","utils","chain","checksum","radix2","alphabet","mnemonicToEntropy","mnemonic","words","norm","includes","decode","join","isJapanese","e","pbkdf2Async","pbkdf2","_assert_js_1","hmac_js_1","utils_js_1","pbkdf2Init","hash","_password","_salt","_opts","dkLen","asyncTick","number","c","password","salt","DK","PRF","hmac","PRFSalt","pbkdf2Output","prfW","u","destroy","fill","view","ti","pos","Ti","subarray","setInt32","digestInto","ui","basex","ALPHABET","BASE_MAP","x","charAt","xc","charCodeAt","BASE","LEADER","FACTOR","log","iFACTOR","decodeUnsafe","source","psz","zeroes","size","b256","charCode","carry","it3","it4","vch","ArrayBuffer","isView","pbegin","pend","b58","it1","it2","repeat","string","self","isSafeInteger","bool","b","lengths","exists","instance","checkFinished","destroyed","finished","output","out","min","assert","HMAC","_key","super","key","iHash","oHash","buf","to","getPrototypeOf","SHA2","padOffset","len","take","dataView","process","roundClean","setBigUint64","_u32_max","wh","wl","setUint32","oview","outLen","state","get","res","sha224","_sha2_js_1","Chi","Maj","SHA256_K","IV","SHA256_W","SHA256","A","B","C","D","E","F","G","H","offset","getUint32","W15","W2","s0","s1","T1","T2","SHA224","assertNumber","args","wrap","reverse","acc","digits","map","input","letter","index","indexOf","separator","padding","bits","chr","push","end","fn","convertRadix","d","done","digit","digitBase","stringToBytes","bytesToString","utf8","bech32m","bech32","base58check","base58xmr","base58xrp","base58flickr","base58","base64url","base64","base32crockford","base32hex","base32","base16","gcd","radix2carry","convertRadix2","mask","radix","num","revPadding","unsafeWrapper","apply","payload","newChecksum","oldChecksum","toUpperCase","replace","genBase58","abc","XMR_BLOCK_LEN","block","concat","BECH_ALPHABET","POLYMOD_GENERATORS","bech32Polymod","pre","chk","bechChecksum","prefix","encodingConst","genBech32","encoding","ENCODING_CONST","_words","fromWords","toWords","fromWordsUnsafe","limit","lowered","toLowerCase","sepIndex","lastIndexOf","sum","endsWith","actualLength","decodeToBytes","TextDecoder","CODERS","coderTypeError","keys","type","hasOwnProperty","sha384","sha512_256","sha512_224","sha512","SHA512","_u64_js_1","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","s0l","W2h","W2l","s1h","s1l","SUMl","SUMh","sigma1h","sigma1l","CHIh","CHIl","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","All","SHA512_224","SHA512_256","SHA384","b64","lens","validLen","getLens","placeHoldersLen","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","maxChunkLength","len2","encodeChunk","lookup","code","tripletToBase64","start","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","t","mode","then","ns","r","def","current","getOwnPropertyNames","definition","o","enumerable","g","globalThis","Function","window","prop","Symbol","toStringTag","_0n","_1n","_2n","_3n","_8n","CURVE","freeze","P","Gx","Gy","beta","divNearest","endo","splitScalar","k","a1","b1","a2","b2","POW_2_128","c1","c2","k1","mod","k2","k1neg","k2neg","fieldLen","groupLen","hashLen","compressedLen","uncompressedLen","weierstrass","x2","x3","USE_ENDOMORPHISM","ShaError","assertJacPoint","other","JacobianPoint","y","z","fromAffine","p","Point","equals","ZERO","toAffineBatch","points","toInv","nums","scratch","inverted","invert","reduceRight","invertBatch","toAffine","normalizeZ","X1","Y1","Z1","X2","Y2","Z2","Z1Z1","Z2Z2","U1","U2","S1","S2","negate","double","x1b","X3","Y3","Z3","HH","HHH","V","subtract","multiplyUnsafe","scalar","P0","normalizeScalar","k1p","k2p","precomputeWindow","W","windows","base","wNAF","affinePoint","_WINDOW_SIZE","precomputes","pointPrecomputes","f","windowSize","maxNumber","shiftBy","wbits","offset1","offset2","abs","cond1","cond2","constTimeNegate","multiply","point","fake","f1p","f2p","invZ","is0","iz1","iz2","iz3","ax","ay","zz","condition","item","neg","WeakMap","_setWindowSize","delete","hasEvenY","fromCompressedHex","isShort","bytesToNumber","isValidFieldElement","_6n","_11n","_22n","_23n","_44n","_88n","b3","b6","pow2","b9","b11","b22","b44","b88","b176","b220","b223","t1","t2","rt","sqrtMod","isYOdd","assertValidity","fromUncompressedHex","fromHex","ensureBytes","header","fromPrivateKey","privateKey","normalizePrivateKey","fromSignature","msgHash","signature","recovery","normalizeSignature","truncateHash","radj","rinv","u1","u2","R","numTo32bStr","Q","multiplyAndAddUnsafe","toRawBytes","isCompressed","toHex","toHexX","toRawX","left","aP","bQ","sliceDER","parseDERInt","Signature","fromCompact","name","hexToNumber","fromDER","sBytes","rBytesLeft","parseDERSignature","isWithinCurveOrder","hasHighS","HALF","normalizeS","toDERRawBytes","toDERHex","sHex","numberToHexUnpadded","rHex","sHexL","rHexL","sLen","rLen","toCompactRawBytes","toCompactHex","POW_2_256","numTo32b","power","modulo","q","m","truncateOnly","delta","bits2int_2","_sha256Sync","_hmacSha256Sync","HmacDrbg","qByteLen","counter","values","hmacSha256","hmacSync","checkSync","incr","reseed","seed","reseedSync","generate","sl","generateSync","kmdToSig","kBytes","lowS","kinv","sig","normalizePublicKey","publicKey","error","getPublicKey","isProbPub","getSharedSecret","privateA","publicB","bits2int","bits2octets","z1","z2","int2octets","signSync","privKey","extraEntropy","h1","seedArgs","initSigArgs","drbg","canonical","recSig","der","recovered","hashed","finalizeSig","vopts","strict","verify","sinv","TAGGED_HASH_PREFIXES","isValidPrivateKey","_bigintTo32Bytes","_normalizePrivateKey","hashToPrivateKey","minLen","randomPrivateKey","precompute","cached","messages","subtle","createHash","ckey","importKey","sign","createHmac","sha256Sync","hmacSha256Sync","taggedHash","tag","tagP","tagH","taggedHashSync","_JacobianPoint","hexToBigInt","bigIntToBytes","integer","isInteger","RangeError","MAX_SAFE_INTEGER","object","clazz","intToBigInt","intToHex","defineProperties","configurable","val","_","test","ERROR_CODES","MISSING_PARAMETER","REMOTE_SERVICE_ERROR","INVALID_STATE","NO_SESSION_DATA","DOES_NOT_EXIST","FAILED_DECRYPTION_ERROR","INVALID_DID_ERROR","NOT_ENOUGH_FUNDS_ERROR","INVALID_AMOUNT_ERROR","LOGIN_FAILED_ERROR","SIGNATURE_VERIFICATION_ERROR","CONFLICT_ERROR","NOT_ENOUGH_PROOF_ERROR","BAD_PATH_ERROR","VALIDATION_ERROR","PAYLOAD_TOO_LARGE_ERROR","PRECONDITION_FAILED_ERROR","UNKNOWN","BlockstackError","bugDetails","stack","parameter","FailedDecryptionError","COORDINATE_BYTES","signatureRsvToVrs","NO_CRYPTO_LIB","getCryptoLib","lib","NodeCryptoAesCipher","createCipher","createDecipher","encrypt","algorithm","iv","cipher","final","Promise","resolve","decrypt","WebCryptoAesCipher","subtleCrypto","algo","cryptoKey","cryptoLib","createCipheriv","createDecipheriv","readUInt8","writeUInt8","destination","writeUInt32BE","readUInt32LE","writeUInt32LE","privateKeyToBytes","privateKeyBuffer","Rho","Id","Pi","idxL","idxR","shifts","shiftsL","idx","shiftsR","Kl","Kr","rotl","group","BUF","RIPEMD160","h0","h2","h3","h4","al","ar","bl","br","cl","cr","dl","dr","el","er","rGroup","hbl","hbr","rl","rr","sr","tl","tr","ripemd160","NodeCryptoSha2Hash","console","hashSha256Sync","hashSha512Sync","WebCryptoSha2Hash","createSha2Hash","BITCOIN_PUBKEYHASH","makeECPrivateKey","base58CheckDecode","btcAddress","version","base58Encode","base58CheckEncode","publicKeyToBtcAddress","getPublicKeyFromPrivate","ecSign","messageHash","msgs","ensureUInt53","encodingLength","chainPrefix","hashMessage","encodeMessage","messageBytes","encodedLength","writeUInt16LE","decodeMessage","encodedMessage","prefixByteLength","messageWithoutChainPrefix","decoded","first","readUInt16LE","lo","varIntLength","inputByteLength","ceil","hashCode","InvalidPublicKeyReason","aes256CbcEncrypt","plaintext","content","sharedSecretToKeys","sharedSecret","hashedSecret","encryptionKey","hmacKey","getHexFromBN","bnInput","hexOut","getBytesFromBN","getCipherObjectWrapper","shell","ephemeralPK","mac","cipherText","wasString","cipherTextEncoding","payloadValuesLength","ivLength","payloadShell","JSON","stringify","getSignedCipherObjectWrapper","signedPayloadValuesLength","signatureLength","signedPayloadShell","eciesGetJsonStringLength","cipherTextLength","contentLength","encodedCipherTextLength","encryptECIES","validity","pub","invalidFormat","reason_data","reason","invalidPoint","firstByte","match","isValidPublicKey","ephemeralPrivateKey","ephemeralPublicKey","sharedKeys","initializationVector","macData","cipherTextString","decryptECIES","cipherObject","ivBytes","cipherTextBytes","actualMac","equalsConstTime","plainText","ciphertext","aes256CbcDecrypt","signECDSA","contentBytes","verifyECDSA","verifyMessageSignature","recoveryIdHex","recoveryId","parseRecoverableSignatureVrs","verificationResult","verifyMessageSignatureRsv","encryptContent","options","cipherPayload","signatureObject","signedCipherObject","decryptContent","parse","err","SyntaxError","NodeCryptoPbkdf2","nodePbkdf2","derive","iterations","keyLength","reject","WebCryptoPbkdf2","passwordBytes","deriveBits","WebCryptoPartialPbkdf2","algoOpts","hmacDigest","saltLength","block1","destPos","hLen","T","U","createPbkdf2","encryptMnemonic","phrase","mnemonicEntropy","plaintextNormalized","getRandomBytes","keysAndIV","encKey","macKey","hmacPayload","PasswordError","decryptMnemonic","dataBytes","hmacSig","decipher","decryptedResult","sha2Hash","decryptMnemonicBytes"],"sourceRoot":""}