npm - @stacks/stacking - Versions diffs - 7.2.0-beta.0 → 7.3.0-beta.0 - Mend

@stacks/stacking 7.2.0-beta.0 → 7.3.0-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/umd/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.js","mappings":"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","sources":["webpack://StacksStacking/webpack/universalModuleDefinition","webpack://StacksStacking/webpack/runtime/create fake namespace object","webpack://StacksStacking/../../node_modules/@noble/hashes/_assert.js","webpack://StacksStacking/../../node_modules/@noble/hashes/_sha2.js","webpack://StacksStacking/../../node_modules/@noble/hashes/cryptoBrowser.js","webpack://StacksStacking/../../node_modules/@noble/hashes/sha256.js","webpack://StacksStacking/../../node_modules/@noble/hashes/utils.js","webpack://StacksStacking/../../node_modules/base-x/src/index.js","webpack://StacksStacking/../../node_modules/base64-js/index.js","webpack://StacksStacking/../../node_modules/bs58/index.js","webpack://StacksStacking/../../node_modules/c32check/lib/address.js","webpack://StacksStacking/../../node_modules/c32check/lib/base58check.js","webpack://StacksStacking/../../node_modules/c32check/lib/checksum.js","webpack://StacksStacking/../../node_modules/c32check/lib/encoding.js","webpack://StacksStacking/../../node_modules/c32check/lib/index.js","webpack://StacksStacking/../../node_modules/lodash.clonedeep/index.js","webpack://StacksStacking/webpack/bootstrap","webpack://StacksStacking/webpack/runtime/compat get default export","webpack://StacksStacking/webpack/runtime/define property getters","webpack://StacksStacking/webpack/runtime/global","webpack://StacksStacking/webpack/runtime/hasOwnProperty shorthand","webpack://StacksStacking/webpack/runtime/make namespace object","webpack://StacksStacking/webpack/runtime/node module decorator","webpack://StacksStacking/../common/dist/esm/utils.js","webpack://StacksStacking/../common/dist/esm/constants.js","webpack://StacksStacking/../common/dist/esm/fetch.js","webpack://StacksStacking/../network/dist/esm/constants.js","webpack://StacksStacking/../network/dist/esm/network.js","webpack://StacksStacking/../transactions/dist/esm/errors.js","webpack://StacksStacking/../common/dist/esm/buffer.js","webpack://StacksStacking/../transactions/dist/esm/BytesReader.js","webpack://StacksStacking/../transactions/dist/esm/constants.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/_assert.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/utils.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/cryptoBrowser.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/_sha2.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/ripemd160.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/sha256.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/_u64.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/sha512.js","webpack://StacksStacking/../../node_modules/@noble/secp256k1/lib/esm/index.js","webpack://StacksStacking/../transactions/dist/esm/clarity/constants.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/intCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/bufferCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/booleanCV.js","webpack://StacksStacking/../transactions/dist/esm/wire/types.js","webpack://StacksStacking/../transactions/dist/esm/wire/create.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/hmac.js","webpack://StacksStacking/../common/dist/esm/signatures.js","webpack://StacksStacking/../common/dist/esm/keys.js","webpack://StacksStacking/../transactions/dist/esm/keys.js","webpack://StacksStacking/../transactions/dist/esm/wire/helpers.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/principalCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/optionalCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/tupleCV.js","webpack://StacksStacking/../transactions/dist/esm/utils.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/stringCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/deserialize.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/responseCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/listCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/serialize.js","webpack://StacksStacking/../transactions/dist/esm/wire/serialization.js","webpack://StacksStacking/../transactions/dist/esm/authorization.js","webpack://StacksStacking/../transactions/dist/esm/transaction.js","webpack://StacksStacking/../transactions/dist/esm/fetch.js","webpack://StacksStacking/../transactions/dist/esm/clarity/clarityValue.js","webpack://StacksStacking/../transactions/dist/esm/contract-abi.js","webpack://StacksStacking/../transactions/dist/esm/postcondition.js","webpack://StacksStacking/../transactions/dist/esm/signer.js","webpack://StacksStacking/../transactions/dist/esm/builders.js","webpack://StacksStacking/./src/constants.ts","webpack://StacksStacking/../../node_modules/@scure/base/lib/esm/index.js","webpack://StacksStacking/../encryption/dist/esm/keys.js","webpack://StacksStacking/../encryption/dist/esm/varuint.js","webpack://StacksStacking/../encryption/dist/esm/messageSignature.js","webpack://StacksStacking/../encryption/dist/esm/ec.js","webpack://StacksStacking/../transactions/dist/esm/structuredDataSignature.js","webpack://StacksStacking/./src/utils.ts","webpack://StacksStacking/./src/index.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[\"StacksStacking\"] = factory();\n\telse\n\t\troot[\"StacksStacking\"] = 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' && !~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\";\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.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.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.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/! 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'\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 // Decode character\n var carry = BASE_MAP[source.charCodeAt(psz)]\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'\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","const basex = require('base-x')\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nmodule.exports = basex(ALPHABET)\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32ToB58 = exports.b58ToC32 = exports.c32addressDecode = exports.c32address = exports.versions = void 0;\nconst checksum_1 = require(\"./checksum\");\nconst base58check = require(\"./base58check\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nexports.versions = {\n mainnet: {\n p2pkh: 22,\n p2sh: 20, // 'M'\n },\n testnet: {\n p2pkh: 26,\n p2sh: 21, // 'N'\n },\n};\n// address conversion : bitcoin to stacks\nconst ADDR_BITCOIN_TO_STACKS = {};\nADDR_BITCOIN_TO_STACKS[0] = exports.versions.mainnet.p2pkh;\nADDR_BITCOIN_TO_STACKS[5] = exports.versions.mainnet.p2sh;\nADDR_BITCOIN_TO_STACKS[111] = exports.versions.testnet.p2pkh;\nADDR_BITCOIN_TO_STACKS[196] = exports.versions.testnet.p2sh;\n// address conversion : stacks to bitcoin\nconst ADDR_STACKS_TO_BITCOIN = {};\nADDR_STACKS_TO_BITCOIN[exports.versions.mainnet.p2pkh] = 0;\nADDR_STACKS_TO_BITCOIN[exports.versions.mainnet.p2sh] = 5;\nADDR_STACKS_TO_BITCOIN[exports.versions.testnet.p2pkh] = 111;\nADDR_STACKS_TO_BITCOIN[exports.versions.testnet.p2sh] = 196;\n/*\n Make a c32check address with the given version and hash160\n * The only difference between a c32check string and c32 address\n * is that the letter 'S' is pre-pended.\n * @param {number} version - the address version number\n * @param {string} hash160hex - the hash160 to encode (must be a hash160)\n * @returns {string} the address\n /\nfunction c32address(version, hash160hex) {\n if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {\n throw new Error('Invalid argument: not a hash160 hex string');\n }\n const c32string = (0, checksum_1.c32checkEncode)(version, hash160hex);\n return `S${c32string}`;\n}\nexports.c32address = c32address;\n/\n Decode a c32 address into its version and hash160\n * @param {string} c32addr - the c32check-encoded address\n * @returns {[number, string]} a tuple with the version and hash160\n /\nfunction c32addressDecode(c32addr) {\n if (c32addr.length <= 5) {\n throw new Error('Invalid c32 address: invalid length');\n }\n if (c32addr[0] != 'S') {\n throw new Error('Invalid c32 address: must start with \"S\"');\n }\n return (0, checksum_1.c32checkDecode)(c32addr.slice(1));\n}\nexports.c32addressDecode = c32addressDecode;\n/\n * Convert a base58check address to a c32check address.\n * Try to convert the version number if one is not given.\n * @param {string} b58check - the base58check encoded address\n * @param {number} version - the version number, if not inferred from the address\n * @returns {string} the c32 address with the given version number (or the\n * semantically-equivalent c32 version number, if not given)\n /\nfunction b58ToC32(b58check, version = -1) {\n const addrInfo = base58check.decode(b58check);\n const hash160String = (0, utils_1.bytesToHex)(addrInfo.data);\n const addrVersion = parseInt((0, utils_1.bytesToHex)(addrInfo.prefix), 16);\n let stacksVersion;\n if (version < 0) {\n stacksVersion = addrVersion;\n if (ADDR_BITCOIN_TO_STACKS[addrVersion] !== undefined) {\n stacksVersion = ADDR_BITCOIN_TO_STACKS[addrVersion];\n }\n }\n else {\n stacksVersion = version;\n }\n return c32address(stacksVersion, hash160String);\n}\nexports.b58ToC32 = b58ToC32;\n/\n * Convert a c32check address to a base58check address.\n * @param {string} c32string - the c32check address\n * @param {number} version - the version number, if not inferred from the address\n * @returns {string} the base58 address with the given version number (or the\n * semantically-equivalent bitcoin version number, if not given)\n /\nfunction c32ToB58(c32string, version = -1) {\n const addrInfo = c32addressDecode(c32string);\n const stacksVersion = addrInfo[0];\n const hash160String = addrInfo[1];\n let bitcoinVersion;\n if (version < 0) {\n bitcoinVersion = stacksVersion;\n if (ADDR_STACKS_TO_BITCOIN[stacksVersion] !== undefined) {\n bitcoinVersion = ADDR_STACKS_TO_BITCOIN[stacksVersion];\n }\n }\n else {\n bitcoinVersion = version;\n }\n let prefix = bitcoinVersion.toString(16);\n if (prefix.length === 1) {\n prefix = `0${prefix}`;\n }\n return base58check.encode(hash160String, prefix);\n}\nexports.c32ToB58 = c32ToB58;\n","/\n * From https://github.com/wzbg/base58check\n * @Author: zyc\n * @Date: 2016-09-11 23:36:05\n /\n'use strict';\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decode = exports.encode = void 0;\nconst sha256_1 = require(\"@noble/hashes/sha256\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nconst basex = require(\"base-x\");\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\nfunction encode(data, prefix = '00') {\n const dataBytes = typeof data === 'string' ? (0, utils_1.hexToBytes)(data) : data;\n const prefixBytes = typeof prefix === 'string' ? (0, utils_1.hexToBytes)(prefix) : data;\n if (!(dataBytes instanceof Uint8Array) \|\| !(prefixBytes instanceof Uint8Array)) {\n throw new TypeError('Argument must be of type Uint8Array or string');\n }\n const checksum = (0, sha256_1.sha256)((0, sha256_1.sha256)(new Uint8Array([...prefixBytes, ...dataBytes])));\n return basex(ALPHABET).encode([...prefixBytes, ...dataBytes, ...checksum.slice(0, 4)]);\n}\nexports.encode = encode;\nfunction decode(string) {\n const bytes = basex(ALPHABET).decode(string);\n const prefixBytes = bytes.slice(0, 1);\n const dataBytes = bytes.slice(1, -4);\n // todo: for better performance replace spread with `concatBytes` method\n const checksum = (0, sha256_1.sha256)((0, sha256_1.sha256)(new Uint8Array([...prefixBytes, ...dataBytes])));\n bytes.slice(-4).forEach((check, index) => {\n if (check !== checksum[index]) {\n throw new Error('Invalid checksum');\n }\n });\n return { prefix: prefixBytes, data: dataBytes };\n}\nexports.decode = decode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32checkDecode = exports.c32checkEncode = void 0;\nconst sha256_1 = require(\"@noble/hashes/sha256\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nconst encoding_1 = require(\"./encoding\");\n/\n Get the c32check checksum of a hex-encoded string\n * @param {string} dataHex - the hex string\n * @returns {string} the c32 checksum, as a bin-encoded string\n /\nfunction c32checksum(dataHex) {\n const dataHash = (0, sha256_1.sha256)((0, sha256_1.sha256)((0, utils_1.hexToBytes)(dataHex)));\n const checksum = (0, utils_1.bytesToHex)(dataHash.slice(0, 4));\n return checksum;\n}\n/\n Encode a hex string as a c32check string. This is a lot like how\n * base58check works in Bitcoin-land, but this algorithm uses the\n * z-base-32 alphabet instead of the base58 alphabet. The algorithm\n * is as follows:\n * * calculate the c32checksum of version + data\n * * c32encode version + data + c32checksum\n * @param {number} version - the version string (between 0 and 31)\n * @param {string} data - the data to encode\n * @returns {string} the c32check representation\n /\nfunction c32checkEncode(version, data) {\n if (version < 0 \|\| version >= 32) {\n throw new Error('Invalid version (must be between 0 and 31)');\n }\n if (!data.match(/^[0-9a-fA-F]$/)) {\n throw new Error('Invalid data (not a hex string)');\n }\n data = data.toLowerCase();\n if (data.length % 2 !== 0) {\n data = `0${data}`;\n }\n let versionHex = version.toString(16);\n if (versionHex.length === 1) {\n versionHex = `0${versionHex}`;\n }\n const checksumHex = c32checksum(`${versionHex}${data}`);\n const c32str = (0, encoding_1.c32encode)(`${data}${checksumHex}`);\n return `${encoding_1.c32[version]}${c32str}`;\n}\nexports.c32checkEncode = c32checkEncode;\n/\n Decode a c32check string back into its version and data payload. This is\n * a lot like how base58check works in Bitcoin-land, but this algorithm uses\n * the z-base-32 alphabet instead of the base58 alphabet. The algorithm\n * is as follows:\n * * extract the version, data, and checksum\n * * verify the checksum matches c32checksum(version + data)\n * * return data\n * @param {string} c32data - the c32check-encoded string\n * @returns {array} [version (number), data (string)]. The returned data\n * will be a hex string. Throws an exception if the checksum does not match.\n /\nfunction c32checkDecode(c32data) {\n c32data = (0, encoding_1.c32normalize)(c32data);\n const dataHex = (0, encoding_1.c32decode)(c32data.slice(1));\n const versionChar = c32data[0];\n const version = encoding_1.c32.indexOf(versionChar);\n const checksum = dataHex.slice(-8);\n let versionHex = version.toString(16);\n if (versionHex.length === 1) {\n versionHex = `0${versionHex}`;\n }\n if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {\n throw new Error('Invalid c32check string: checksum mismatch');\n }\n return [version, dataHex.substring(0, dataHex.length - 8)];\n}\nexports.c32checkDecode = c32checkDecode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32decode = exports.c32normalize = exports.c32encode = exports.c32 = void 0;\nconst utils_1 = require(\"@noble/hashes/utils\");\nexports.c32 = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';\nconst hex = '0123456789abcdef';\n/\n Encode a hex string as a c32 string. Note that the hex string is assumed\n * to be big-endian (and the resulting c32 string will be as well).\n * @param {string} inputHex - the input to encode\n * @param {number} minLength - the minimum length of the c32 string\n * @returns {string} the c32check-encoded representation of the data, as a string\n /\nfunction c32encode(inputHex, minLength) {\n // must be hex\n if (!inputHex.match(/^[0-9a-fA-F]$/)) {\n throw new Error('Not a hex-encoded string');\n }\n if (inputHex.length % 2 !== 0) {\n inputHex = `0${inputHex}`;\n }\n inputHex = inputHex.toLowerCase();\n let res = [];\n let carry = 0;\n for (let i = inputHex.length - 1; i >= 0; i--) {\n if (carry < 4) {\n const currentCode = hex.indexOf(inputHex[i]) >> carry;\n let nextCode = 0;\n if (i !== 0) {\n nextCode = hex.indexOf(inputHex[i - 1]);\n }\n // carry = 0, nextBits is 1, carry = 1, nextBits is 2\n const nextBits = 1 + carry;\n const nextLowBits = nextCode % (1 << nextBits) << (5 - nextBits);\n const curC32Digit = exports.c32[currentCode + nextLowBits];\n carry = nextBits;\n res.unshift(curC32Digit);\n }\n else {\n carry = 0;\n }\n }\n let C32leadingZeros = 0;\n for (let i = 0; i < res.length; i++) {\n if (res[i] !== '0') {\n break;\n }\n else {\n C32leadingZeros++;\n }\n }\n res = res.slice(C32leadingZeros);\n const zeroPrefix = new TextDecoder().decode((0, utils_1.hexToBytes)(inputHex)).match(/^\\u0000/);\n const numLeadingZeroBytesInHex = zeroPrefix ? zeroPrefix[0].length : 0;\n for (let i = 0; i < numLeadingZeroBytesInHex; i++) {\n res.unshift(exports.c32[0]);\n }\n if (minLength) {\n const count = minLength - res.length;\n for (let i = 0; i < count; i++) {\n res.unshift(exports.c32[0]);\n }\n }\n return res.join('');\n}\nexports.c32encode = c32encode;\n/\n * Normalize a c32 string\n * @param {string} c32input - the c32-encoded input string\n * @returns {string} the canonical representation of the c32 input string\n /\nfunction c32normalize(c32input) {\n // must be upper-case\n // replace all O's with 0's\n // replace all I's and L's with 1's\n return c32input.toUpperCase().replace(/O/g, '0').replace(/L\|I/g, '1');\n}\nexports.c32normalize = c32normalize;\n/\n * Decode a c32 string back into a hex string. Note that the c32 input\n * string is assumed to be big-endian (and the resulting hex string will\n * be as well).\n * @param {string} c32input - the c32-encoded input to decode\n * @param {number} minLength - the minimum length of the output hex string (in bytes)\n * @returns {string} the hex-encoded representation of the data, as a string\n /\nfunction c32decode(c32input, minLength) {\n c32input = c32normalize(c32input);\n // must result in a c32 string\n if (!c32input.match(`^[${exports.c32}]$`)) {\n throw new Error('Not a c32-encoded string');\n }\n const zeroPrefix = c32input.match(`^${exports.c32[0]}`);\n const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0].length : 0;\n let res = [];\n let carry = 0;\n let carryBits = 0;\n for (let i = c32input.length - 1; i >= 0; i--) {\n if (carryBits === 4) {\n res.unshift(hex[carry]);\n carryBits = 0;\n carry = 0;\n }\n const currentCode = exports.c32.indexOf(c32input[i]) << carryBits;\n const currentValue = currentCode + carry;\n const currentHexDigit = hex[currentValue % 16];\n carryBits += 1;\n carry = currentValue >> 4;\n if (carry > 1 << carryBits) {\n throw new Error('Panic error in decoding.');\n }\n res.unshift(currentHexDigit);\n }\n // one last carry\n res.unshift(hex[carry]);\n if (res.length % 2 === 1) {\n res.unshift('0');\n }\n let hexLeadingZeros = 0;\n for (let i = 0; i < res.length; i++) {\n if (res[i] !== '0') {\n break;\n }\n else {\n hexLeadingZeros++;\n }\n }\n res = res.slice(hexLeadingZeros - (hexLeadingZeros % 2));\n let hexStr = res.join('');\n for (let i = 0; i < numLeadingZeroBytes; i++) {\n hexStr = `00${hexStr}`;\n }\n if (minLength) {\n const count = minLength 2 - hexStr.length;\n for (let i = 0; i < count; i += 2) {\n hexStr = `00${hexStr}`;\n }\n }\n return hexStr;\n}\nexports.c32decode = c32decode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.b58ToC32 = exports.c32ToB58 = exports.versions = exports.c32normalize = exports.c32addressDecode = exports.c32address = exports.c32checkDecode = exports.c32checkEncode = exports.c32decode = exports.c32encode = void 0;\nconst encoding_1 = require(\"./encoding\");\nObject.defineProperty(exports, \"c32encode\", { enumerable: true, get: function () { return encoding_1.c32encode; } });\nObject.defineProperty(exports, \"c32decode\", { enumerable: true, get: function () { return encoding_1.c32decode; } });\nObject.defineProperty(exports, \"c32normalize\", { enumerable: true, get: function () { return encoding_1.c32normalize; } });\nconst checksum_1 = require(\"./checksum\");\nObject.defineProperty(exports, \"c32checkEncode\", { enumerable: true, get: function () { return checksum_1.c32checkEncode; } });\nObject.defineProperty(exports, \"c32checkDecode\", { enumerable: true, get: function () { return checksum_1.c32checkDecode; } });\nconst address_1 = require(\"./address\");\nObject.defineProperty(exports, \"c32address\", { enumerable: true, get: function () { return address_1.c32address; } });\nObject.defineProperty(exports, \"c32addressDecode\", { enumerable: true, get: function () { return address_1.c32addressDecode; } });\nObject.defineProperty(exports, \"c32ToB58\", { enumerable: true, get: function () { return address_1.c32ToB58; } });\nObject.defineProperty(exports, \"b58ToC32\", { enumerable: true, get: function () { return address_1.b58ToC32; } });\nObject.defineProperty(exports, \"versions\", { enumerable: true, get: function () { return address_1.versions; } });\n","/*\n lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n /\n\n/* Used as the size to enable large array optimizations. /\nvar LARGE_ARRAY_SIZE = 200;\n\n/* Used to stand-in for `undefined` hash values. /\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/* Used as references for various `Number` constants. /\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/* `Object#toString` result references. /\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/\n Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n /\nvar reRegExpChar = /[\\\\^$.+?()[\\]{}\|]/g;\n\n/** Used to match `RegExp` flags from their coerced string values. /\nvar reFlags = /\\w$/;\n\n/** Used to detect host constructors (Safari). /\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/* Used to detect unsigned integer values. /\nvar reIsUint = /^(?:0\|[1-9]\\d)$/;\n\n/** Used to identify `toStringTag` values supported by `_.clone`. /\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/* Detect free variable `global` from Node.js. /\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/* Detect free variable `self`. /\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/* Used as a reference to the global object. /\nvar root = freeGlobal \|\| freeSelf \|\| Function('return this')();\n\n/* Detect free variable `exports`. /\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/* Detect free variable `module`. /\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/* Detect the popular CommonJS extension `module.exports`. /\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/\n Adds the key-value `pair` to `map`.\n \n @private\n * @param {Object} map The map to modify.\n * @param {Array} pair The key-value pair to add.\n * @returns {Object} Returns `map`.\n /\nfunction addMapEntry(map, pair) {\n // Don't return `map.set` because it's not chainable in IE 11.\n map.set(pair[0], pair[1]);\n return map;\n}\n\n/\n Adds `value` to `set`.\n \n @private\n * @param {Object} set The set to modify.\n * @param {} value The value to add.\n @returns {Object} Returns `set`.\n /\nfunction addSetEntry(set, value) {\n // Don't return `set.add` because it's not chainable in IE 11.\n set.add(value);\n return set;\n}\n\n/\n A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n \n @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n /\nfunction arrayEach(array, iteratee) {\n var index = -1,\n length = array ? array.length : 0;\n\n while (++index < length) {\n if (iteratee(array[index], index, array) === false) {\n break;\n }\n }\n return array;\n}\n\n/\n Appends the elements of `values` to `array`.\n \n @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n /\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\n/\n A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n \n @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {} [accumulator] The initial value.\n @param {boolean} [initAccum] Specify using the first element of `array` as\n * the initial value.\n * @returns {} Returns the accumulated value.\n /\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n var index = -1,\n length = array ? array.length : 0;\n\n if (initAccum && length) {\n accumulator = array[++index];\n }\n while (++index < length) {\n accumulator = iteratee(accumulator, array[index], index, array);\n }\n return accumulator;\n}\n\n/*\n The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n \n @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n /\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\n/\n Gets the value at `key` of `object`.\n \n @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {} Returns the property value.\n /\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\n/*\n Checks if `value` is a host object in IE < 9.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n /\nfunction isHostObject(value) {\n // Many host objects are `Object` objects that can coerce to strings\n // despite having improperly defined `toString` methods.\n var result = false;\n if (value != null && typeof value.toString != 'function') {\n try {\n result = !!(value + '');\n } catch (e) {}\n }\n return result;\n}\n\n/\n Converts `map` to its key-value pairs.\n \n @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n /\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\n/\n Creates a unary function that invokes `func` with its argument transformed.\n \n @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n /\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\n/\n Converts `set` to an array of its values.\n \n @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n /\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\n/* Used for built-in method references. /\nvar arrayProto = Array.prototype,\n funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/* Used to detect overreaching core-js shims. /\nvar coreJsData = root['__core-js_shared__'];\n\n/* Used to detect methods masquerading as native. /\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO \|\| '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/* Used to resolve the decompiled source of functions. /\nvar funcToString = funcProto.toString;\n\n/* Used to check objects for own properties. /\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/\n Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n /\nvar objectToString = objectProto.toString;\n\n/* Used to detect if a method is native. /\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty\|(function).?(?=\\\\\\()\| for .+?(?=\\\\\\])/g, '$1.?') + '$'\n);\n\n/* Built-in value references. /\nvar Buffer = moduleExports ? root.Buffer : undefined,\n Symbol = root.Symbol,\n Uint8Array = root.Uint8Array,\n getPrototype = overArg(Object.getPrototypeOf, Object),\n objectCreate = Object.create,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n splice = arrayProto.splice;\n\n/ Built-in method references for those with the same name as other `lodash` methods. /\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n nativeKeys = overArg(Object.keys, Object);\n\n/ Built-in method references that are verified to be native. /\nvar DataView = getNative(root, 'DataView'),\n Map = getNative(root, 'Map'),\n Promise = getNative(root, 'Promise'),\n Set = getNative(root, 'Set'),\n WeakMap = getNative(root, 'WeakMap'),\n nativeCreate = getNative(Object, 'create');\n\n/* Used to detect maps, sets, and weakmaps. /\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/* Used to convert symbols to primitives and strings. /\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/\n Creates a hash object.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction Hash(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the hash.\n \n @private\n * @name clear\n * @memberOf Hash\n /\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n\n/\n Removes `key` and its value from the hash.\n \n @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction hashDelete(key) {\n return this.has(key) && delete this.__data__[key];\n}\n\n/\n Gets the hash value for `key`.\n \n @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/*\n Checks if a hash value for `key` exists.\n \n @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/\n Sets the hash `key` to `value`.\n \n @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the hash instance.\n /\nfunction hashSet(key, value) {\n var data = this.__data__;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/\n Creates an list cache object.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction ListCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the list cache.\n \n @private\n * @name clear\n * @memberOf ListCache\n /\nfunction listCacheClear() {\n this.__data__ = [];\n}\n\n/\n Removes `key` and its value from the list cache.\n \n @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n return true;\n}\n\n/\n Gets the list cache value for `key`.\n \n @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\n/*\n Checks if a list cache value for `key` exists.\n \n @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\n/\n Sets the list cache `key` to `value`.\n \n @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the list cache instance.\n /\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/\n Creates a map cache object to store key-value pairs.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction MapCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the map.\n \n @private\n * @name clear\n * @memberOf MapCache\n /\nfunction mapCacheClear() {\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map \|\| ListCache),\n 'string': new Hash\n };\n}\n\n/\n Removes `key` and its value from the map.\n \n @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction mapCacheDelete(key) {\n return getMapData(this, key)['delete'](key);\n}\n\n/\n Gets the map value for `key`.\n \n @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\n/*\n Checks if a map value for `key` exists.\n \n @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\n/\n Sets the map `key` to `value`.\n \n @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the map cache instance.\n /\nfunction mapCacheSet(key, value) {\n getMapData(this, key).set(key, value);\n return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/\n Creates a stack cache object to store key-value pairs.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction Stack(entries) {\n this.__data__ = new ListCache(entries);\n}\n\n/\n Removes all key-value entries from the stack.\n \n @private\n * @name clear\n * @memberOf Stack\n /\nfunction stackClear() {\n this.__data__ = new ListCache;\n}\n\n/\n Removes `key` and its value from the stack.\n \n @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction stackDelete(key) {\n return this.__data__['delete'](key);\n}\n\n/\n Gets the stack value for `key`.\n \n @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\n/*\n Checks if a stack value for `key` exists.\n \n @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\n/\n Sets the stack `key` to `value`.\n \n @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the stack cache instance.\n /\nfunction stackSet(key, value) {\n var cache = this.__data__;\n if (cache instanceof ListCache) {\n var pairs = cache.__data__;\n if (!Map \|\| (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n return this;\n }\n cache = this.__data__ = new MapCache(pairs);\n }\n cache.set(key, value);\n return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/\n Creates an array of the enumerable property names of the array-like `value`.\n \n @private\n * @param {} value The value to query.\n @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n /\nfunction arrayLikeKeys(value, inherited) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n // Safari 9 makes `arguments.length` enumerable in strict mode.\n var result = (isArray(value) \|\| isArguments(value))\n ? baseTimes(value.length, String)\n : [];\n\n var length = result.length,\n skipIndexes = !!length;\n\n for (var key in value) {\n if ((inherited \|\| hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (key == 'length' \|\| isIndex(key, length)))) {\n result.push(key);\n }\n }\n return result;\n}\n\n/\n Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n \n @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {} value The value to assign.\n /\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) \|\|\n (value === undefined && !(key in object))) {\n object[key] = value;\n }\n}\n\n/*\n Gets the index at which the `key` is found in `array` of key-value pairs.\n \n @private\n * @param {Array} array The array to inspect.\n * @param {} key The key to search for.\n @returns {number} Returns the index of the matched value, else `-1`.\n /\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\n/\n The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n \n @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n /\nfunction baseAssign(object, source) {\n return object && copyObject(source, keys(source), object);\n}\n\n/\n The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n \n @private\n * @param {} value The value to clone.\n @param {boolean} [isDeep] Specify a deep clone.\n * @param {boolean} [isFull] Specify a clone including symbols.\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {} Returns the cloned value.\n /\nfunction baseClone(value, isDeep, isFull, customizer, key, object, stack) {\n var result;\n if (customizer) {\n result = object ? customizer(value, key, object, stack) : customizer(value);\n }\n if (result !== undefined) {\n return result;\n }\n if (!isObject(value)) {\n return value;\n }\n var isArr = isArray(value);\n if (isArr) {\n result = initCloneArray(value);\n if (!isDeep) {\n return copyArray(value, result);\n }\n } else {\n var tag = getTag(value),\n isFunc = tag == funcTag \|\| tag == genTag;\n\n if (isBuffer(value)) {\n return cloneBuffer(value, isDeep);\n }\n if (tag == objectTag \|\| tag == argsTag \|\| (isFunc && !object)) {\n if (isHostObject(value)) {\n return object ? value : {};\n }\n result = initCloneObject(isFunc ? {} : value);\n if (!isDeep) {\n return copySymbols(value, baseAssign(result, value));\n }\n } else {\n if (!cloneableTags[tag]) {\n return object ? value : {};\n }\n result = initCloneByTag(value, tag, baseClone, isDeep);\n }\n }\n // Check for circular references and return its corresponding clone.\n stack \|\| (stack = new Stack);\n var stacked = stack.get(value);\n if (stacked) {\n return stacked;\n }\n stack.set(value, result);\n\n if (!isArr) {\n var props = isFull ? getAllKeys(value) : keys(value);\n }\n arrayEach(props \|\| value, function(subValue, key) {\n if (props) {\n key = subValue;\n subValue = value[key];\n }\n // Recursively populate clone (susceptible to call stack limits).\n assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));\n });\n return result;\n}\n\n/*\n The base implementation of `_.create` without support for assigning\n * properties to the created object.\n \n @private\n * @param {Object} prototype The object to inherit from.\n * @returns {Object} Returns the new object.\n /\nfunction baseCreate(proto) {\n return isObject(proto) ? objectCreate(proto) : {};\n}\n\n/\n The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n /\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/\n The base implementation of `getTag`.\n \n @private\n * @param {} value The value to query.\n @returns {string} Returns the `toStringTag`.\n /\nfunction baseGetTag(value) {\n return objectToString.call(value);\n}\n\n/\n The base implementation of `_.isNative` without bad shim checks.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n /\nfunction baseIsNative(value) {\n if (!isObject(value) \|\| isMasked(value)) {\n return false;\n }\n var pattern = (isFunction(value) \|\| isHostObject(value)) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\n/\n The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n /\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\n/\n Creates a clone of `buffer`.\n \n @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n /\nfunction cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var result = new buffer.constructor(buffer.length);\n buffer.copy(result);\n return result;\n}\n\n/\n Creates a clone of `arrayBuffer`.\n \n @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n /\nfunction cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n}\n\n/\n Creates a clone of `dataView`.\n \n @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n /\nfunction cloneDataView(dataView, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\n/\n Creates a clone of `map`.\n \n @private\n * @param {Object} map The map to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned map.\n /\nfunction cloneMap(map, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);\n return arrayReduce(array, addMapEntry, new map.constructor);\n}\n\n/\n Creates a clone of `regexp`.\n \n @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n /\nfunction cloneRegExp(regexp) {\n var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n result.lastIndex = regexp.lastIndex;\n return result;\n}\n\n/\n Creates a clone of `set`.\n \n @private\n * @param {Object} set The set to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned set.\n /\nfunction cloneSet(set, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);\n return arrayReduce(array, addSetEntry, new set.constructor);\n}\n\n/\n Creates a clone of the `symbol` object.\n \n @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n /\nfunction cloneSymbol(symbol) {\n return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\n/\n Creates a clone of `typedArray`.\n \n @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n /\nfunction cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/\n Copies the values of `source` to `array`.\n \n @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n /\nfunction copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array \|\| (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n}\n\n/\n Copies properties of `source` to `object`.\n \n @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n /\nfunction copyObject(source, props, object, customizer) {\n object \|\| (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n assignValue(object, key, newValue === undefined ? source[key] : newValue);\n }\n return object;\n}\n\n/\n Copies own symbol properties of `source` to `object`.\n \n @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n /\nfunction copySymbols(source, object) {\n return copyObject(source, getSymbols(source), object);\n}\n\n/\n Creates an array of own enumerable property names and symbols of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n /\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/\n Gets the data for `map`.\n \n @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {} Returns the map data.\n /\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\n/*\n Gets the native function at `key` of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {} Returns the function if it's native, else `undefined`.\n /\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\n/*\n Creates an array of the own enumerable symbol properties of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n /\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/\n Gets the `toStringTag` of `value`.\n \n @private\n * @param {} value The value to query.\n @returns {string} Returns the `toStringTag`.\n /\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11,\n// for data views in Edge < 14, and promises in Node.js.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) \|\|\n (Map && getTag(new Map) != mapTag) \|\|\n (Promise && getTag(Promise.resolve()) != promiseTag) \|\|\n (Set && getTag(new Set) != setTag) \|\|\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = objectToString.call(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : undefined;\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\n/\n Initializes an array clone.\n \n @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n /\nfunction initCloneArray(array) {\n var length = array.length,\n result = array.constructor(length);\n\n // Add properties assigned by `RegExp#exec`.\n if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n result.index = array.index;\n result.input = array.input;\n }\n return result;\n}\n\n/\n Initializes an object clone.\n \n @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n /\nfunction initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n}\n\n/\n Initializes an object clone based on its `toStringTag`.\n \n Note: This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n \n @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n /\nfunction initCloneByTag(object, tag, cloneFunc, isDeep) {\n var Ctor = object.constructor;\n switch (tag) {\n case arrayBufferTag:\n return cloneArrayBuffer(object);\n\n case boolTag:\n case dateTag:\n return new Ctor(+object);\n\n case dataViewTag:\n return cloneDataView(object, isDeep);\n\n case float32Tag: case float64Tag:\n case int8Tag: case int16Tag: case int32Tag:\n case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n return cloneTypedArray(object, isDeep);\n\n case mapTag:\n return cloneMap(object, isDeep, cloneFunc);\n\n case numberTag:\n case stringTag:\n return new Ctor(object);\n\n case regexpTag:\n return cloneRegExp(object);\n\n case setTag:\n return cloneSet(object, isDeep, cloneFunc);\n\n case symbolTag:\n return cloneSymbol(object);\n }\n}\n\n/\n Checks if `value` is a valid array-like index.\n \n @private\n * @param {} value The value to check.\n @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n /\nfunction isIndex(value, length) {\n length = length == null ? MAX_SAFE_INTEGER : length;\n return !!length &&\n (typeof value == 'number' \|\| reIsUint.test(value)) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\n/\n Checks if `value` is suitable for use as unique object key.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n /\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' \|\| type == 'number' \|\| type == 'symbol' \|\| type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\n/\n Checks if `func` has its source masked.\n \n @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n /\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/\n Checks if `value` is likely a prototype object.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n /\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) \|\| objectProto;\n\n return value === proto;\n}\n\n/\n Converts `func` to its source code.\n \n @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n /\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\n/\n This method is like `_.clone` except that it recursively clones `value`.\n \n @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {} value The value to recursively clone.\n @returns {} Returns the deep cloned value.\n @see _.clone\n * @example\n \n var objects = [{ 'a': 1 }, { 'b': 2 }];\n \n var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n /\nfunction cloneDeep(value) {\n return baseClone(value, true, true);\n}\n\n/\n Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to compare.\n @param {} other The other value to compare.\n @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n \n var object = { 'a': 1 };\n * var other = { 'a': 1 };\n \n _.eq(object, object);\n * // => true\n \n _.eq(object, other);\n * // => false\n \n _.eq('a', 'a');\n * // => true\n \n _.eq('a', Object('a'));\n * // => false\n \n _.eq(NaN, NaN);\n * // => true\n /\nfunction eq(value, other) {\n return value === other \|\| (value !== value && other !== other);\n}\n\n/\n Checks if `value` is likely an `arguments` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n \n _.isArguments(function() { return arguments; }());\n * // => true\n \n _.isArguments([1, 2, 3]);\n * // => false\n /\nfunction isArguments(value) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n (!propertyIsEnumerable.call(value, 'callee') \|\| objectToString.call(value) == argsTag);\n}\n\n/\n Checks if `value` is classified as an `Array` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n \n _.isArray([1, 2, 3]);\n * // => true\n \n _.isArray(document.body.children);\n * // => false\n \n _.isArray('abc');\n * // => false\n \n _.isArray(_.noop);\n * // => false\n /\nvar isArray = Array.isArray;\n\n/\n Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n \n _.isArrayLike([1, 2, 3]);\n * // => true\n \n _.isArrayLike(document.body.children);\n * // => true\n \n _.isArrayLike('abc');\n * // => true\n \n _.isArrayLike(_.noop);\n * // => false\n /\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/\n This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n \n _.isArrayLikeObject([1, 2, 3]);\n * // => true\n \n _.isArrayLikeObject(document.body.children);\n * // => true\n \n _.isArrayLikeObject('abc');\n * // => false\n \n _.isArrayLikeObject(_.noop);\n * // => false\n /\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\n/\n Checks if `value` is a buffer.\n \n @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n \n _.isBuffer(new Buffer(2));\n * // => true\n \n _.isBuffer(new Uint8Array(2));\n * // => false\n /\nvar isBuffer = nativeIsBuffer \|\| stubFalse;\n\n/\n Checks if `value` is classified as a `Function` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n \n _.isFunction(_);\n * // => true\n \n _.isFunction(/abc/);\n * // => false\n /\nfunction isFunction(value) {\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 8-9 which returns 'object' for typed array and other constructors.\n var tag = isObject(value) ? objectToString.call(value) : '';\n return tag == funcTag \|\| tag == genTag;\n}\n\n/\n Checks if `value` is a valid array-like length.\n \n Note: This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n \n _.isLength(3);\n * // => true\n \n _.isLength(Number.MIN_VALUE);\n * // => false\n \n _.isLength(Infinity);\n * // => false\n \n _.isLength('3');\n * // => false\n /\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/\n Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n \n _.isObject({});\n * // => true\n \n _.isObject([1, 2, 3]);\n * // => true\n \n _.isObject(_.noop);\n * // => true\n \n _.isObject(null);\n * // => false\n /\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' \|\| type == 'function');\n}\n\n/\n Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n \n _.isObjectLike({});\n * // => true\n \n _.isObjectLike([1, 2, 3]);\n * // => true\n \n _.isObjectLike(_.noop);\n * // => false\n \n _.isObjectLike(null);\n * // => false\n /\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/\n Creates an array of the own enumerable property names of `object`.\n \n Note: Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n \n @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n \n function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n \n Foo.prototype.c = 3;\n \n _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n \n _.keys('hi');\n * // => ['0', '1']\n /\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/\n This method returns a new empty array.\n \n @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n \n var arrays = _.times(2, _.stubArray);\n \n console.log(arrays);\n * // => [[], []]\n \n console.log(arrays[0] === arrays[1]);\n * // => false\n /\nfunction stubArray() {\n return [];\n}\n\n/\n This method returns `false`.\n \n @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n \n _.times(2, _.stubFalse);\n * // => [false, false]\n /\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = cloneDeep;\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\tid: moduleId,\n\t\tloaded: false,\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// Flag the module as loaded\n\tmodule.loaded = true;\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};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\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 HIRO_MAINNET_URL = 'https://api.mainnet.hiro.so';\nexport const HIRO_TESTNET_URL = 'https://api.testnet.hiro.so';\nexport const DEVNET_URL = 'http://localhost:3999';\nexport const GAIA_URL = 'https://hub.blockstack.org';\nexport const PRIVATE_KEY_BYTES_COMPRESSED = 33;\nexport const PRIVATE_KEY_BYTES_UNCOMPRESSED = 32;\n//# sourceMappingURL=constants.js.map","const defaultFetchOpts = {\n referrerPolicy: 'origin',\n headers: {\n 'x-hiro-product': 'stacksjs',\n },\n};\nexport const getFetchOptions = () => {\n return defaultFetchOpts;\n};\nexport const setFetchOptions = (ops) => {\n return Object.assign(defaultFetchOpts, ops);\n};\nexport async function fetchWrapper(input, init) {\n const fetchOpts = {};\n Object.assign(fetchOpts, defaultFetchOpts, init);\n const fetchResult = await fetch(input, fetchOpts);\n return fetchResult;\n}\nexport function hostMatches(host, pattern) {\n if (typeof pattern === 'string')\n return pattern === host;\n return pattern.exec(host);\n}\nexport function createApiKeyMiddleware({ apiKey, host = /(.)api(.)(\\.stacks\\.co\|\\.hiro\\.so)$/i, httpHeader = 'x-api-key', }) {\n return {\n pre: context => {\n const reqUrl = new URL(context.url);\n if (!hostMatches(reqUrl.host, host))\n return;\n const headers = context.init.headers instanceof Headers\n ? context.init.headers\n : (context.init.headers = new Headers(context.init.headers));\n headers.set(httpHeader, apiKey);\n },\n };\n}\nfunction argsForCreateFetchFn(args) {\n let fetchLib = fetchWrapper;\n let middlewares = [];\n if (args.length > 0 && typeof args[0] === 'function') {\n fetchLib = args.shift();\n }\n if (args.length > 0) {\n middlewares = args;\n }\n return { fetchLib, middlewares };\n}\nexport function createFetchFn(...args) {\n const { fetchLib, middlewares } = argsForCreateFetchFn(args);\n const fetchFn = async (url, init) => {\n let fetchParams = { url, init: init ?? {} };\n for (const middleware of middlewares) {\n if (typeof middleware.pre === 'function') {\n const result = await Promise.resolve(middleware.pre({\n fetch: fetchLib,\n ...fetchParams,\n }));\n fetchParams = result ?? fetchParams;\n }\n }\n let response = await fetchLib(fetchParams.url, fetchParams.init);\n for (const middleware of middlewares) {\n if (typeof middleware.post === 'function') {\n const result = await Promise.resolve(middleware.post({\n fetch: fetchLib,\n url: fetchParams.url,\n init: fetchParams.init,\n response: response?.clone() ?? response,\n }));\n response = result ?? response;\n }\n }\n return response;\n };\n return fetchFn;\n}\n//# sourceMappingURL=fetch.js.map","export var ChainId;\n(function (ChainId) {\n ChainId[ChainId[\"Mainnet\"] = 1] = \"Mainnet\";\n ChainId[ChainId[\"Testnet\"] = 2147483648] = \"Testnet\";\n})(ChainId \|\| (ChainId = {}));\nexport var PeerNetworkId;\n(function (PeerNetworkId) {\n PeerNetworkId[PeerNetworkId[\"Mainnet\"] = 385875968] = \"Mainnet\";\n PeerNetworkId[PeerNetworkId[\"Testnet\"] = 4278190080] = \"Testnet\";\n})(PeerNetworkId \|\| (PeerNetworkId = {}));\nexport const DEFAULT_CHAIN_ID = ChainId.Mainnet;\nexport var TransactionVersion;\n(function (TransactionVersion) {\n TransactionVersion[TransactionVersion[\"Mainnet\"] = 0] = \"Mainnet\";\n TransactionVersion[TransactionVersion[\"Testnet\"] = 128] = \"Testnet\";\n})(TransactionVersion \|\| (TransactionVersion = {}));\nexport var AddressVersion;\n(function (AddressVersion) {\n AddressVersion[AddressVersion[\"MainnetSingleSig\"] = 22] = \"MainnetSingleSig\";\n AddressVersion[AddressVersion[\"MainnetMultiSig\"] = 20] = \"MainnetMultiSig\";\n AddressVersion[AddressVersion[\"TestnetSingleSig\"] = 26] = \"TestnetSingleSig\";\n AddressVersion[AddressVersion[\"TestnetMultiSig\"] = 21] = \"TestnetMultiSig\";\n})(AddressVersion \|\| (AddressVersion = {}));\nexport const DEFAULT_TRANSACTION_VERSION = TransactionVersion.Mainnet;\nexport function whenTransactionVersion(transactionVersion) {\n return (map) => map[transactionVersion];\n}\n//# sourceMappingURL=constants.js.map","import { DEVNET_URL, HIRO_MAINNET_URL, HIRO_TESTNET_URL, createFetchFn, createApiKeyMiddleware, } from '@stacks/common';\nimport { AddressVersion, ChainId, PeerNetworkId, TransactionVersion } from './constants';\nexport const STACKS_MAINNET = {\n chainId: ChainId.Mainnet,\n transactionVersion: TransactionVersion.Mainnet,\n peerNetworkId: PeerNetworkId.Mainnet,\n magicBytes: 'X2',\n bootAddress: 'SP000000000000000000002Q6VF78',\n addressVersion: {\n singleSig: AddressVersion.MainnetSingleSig,\n multiSig: AddressVersion.MainnetMultiSig,\n },\n client: { baseUrl: HIRO_MAINNET_URL },\n};\nexport const STACKS_TESTNET = {\n chainId: ChainId.Testnet,\n transactionVersion: TransactionVersion.Testnet,\n peerNetworkId: PeerNetworkId.Testnet,\n magicBytes: 'T2',\n bootAddress: 'ST000000000000000000002AMW42H',\n addressVersion: {\n singleSig: AddressVersion.TestnetSingleSig,\n multiSig: AddressVersion.TestnetMultiSig,\n },\n client: { baseUrl: HIRO_TESTNET_URL },\n};\nexport const STACKS_DEVNET = {\n ...STACKS_TESTNET,\n addressVersion: { ...STACKS_TESTNET.addressVersion },\n magicBytes: 'id',\n client: { baseUrl: DEVNET_URL },\n};\nexport const STACKS_MOCKNET = {\n ...STACKS_DEVNET,\n addressVersion: { ...STACKS_DEVNET.addressVersion },\n client: { ...STACKS_DEVNET.client },\n};\nexport const StacksNetworks = ['mainnet', 'testnet', 'devnet', 'mocknet'];\nexport function networkFromName(name) {\n switch (name) {\n case 'mainnet':\n return STACKS_MAINNET;\n case 'testnet':\n return STACKS_TESTNET;\n case 'devnet':\n return STACKS_DEVNET;\n case 'mocknet':\n return STACKS_MOCKNET;\n default:\n throw new Error(`Unknown network name: ${name}`);\n }\n}\nexport function networkFrom(network) {\n if (typeof network === 'string')\n return networkFromName(network);\n return network;\n}\nexport function defaultUrlFromNetwork(network) {\n if (!network)\n return HIRO_MAINNET_URL;\n network = networkFrom(network);\n return !network \|\| network.transactionVersion === TransactionVersion.Mainnet\n ? HIRO_MAINNET_URL\n : network.magicBytes === 'id'\n ? DEVNET_URL\n : HIRO_TESTNET_URL;\n}\nexport function clientFromNetwork(network) {\n if (network.client.fetch)\n return network.client;\n return {\n ...network.client,\n fetch: createFetchFn(),\n };\n}\nexport function createNetwork(arg1, arg2) {\n const baseNetwork = networkFrom(typeof arg1 === 'object' && 'network' in arg1 ? arg1.network : arg1);\n const newNetwork = {\n ...baseNetwork,\n addressVersion: { ...baseNetwork.addressVersion },\n client: { ...baseNetwork.client },\n };\n if (typeof arg1 === 'object' && 'network' in arg1) {\n if (arg1.client) {\n newNetwork.client.baseUrl = arg1.client.baseUrl ?? newNetwork.client.baseUrl;\n newNetwork.client.fetch = arg1.client.fetch ?? newNetwork.client.fetch;\n }\n if (typeof arg1.apiKey === 'string') {\n const middleware = createApiKeyMiddleware(arg1);\n newNetwork.client.fetch = newNetwork.client.fetch\n ? createFetchFn(newNetwork.client.fetch, middleware)\n : createFetchFn(middleware);\n }\n return newNetwork;\n }\n if (typeof arg2 === 'string') {\n const middleware = createApiKeyMiddleware({ apiKey: arg2 });\n newNetwork.client.fetch = newNetwork.client.fetch\n ? createFetchFn(newNetwork.client.fetch, middleware)\n : createFetchFn(middleware);\n return newNetwork;\n }\n return newNetwork;\n}\n//# sourceMappingURL=network.js.map","class TransactionError extends Error {\n constructor(message) {\n super(message);\n this.message = message;\n this.name = this.constructor.name;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, this.constructor);\n }\n }\n}\nexport class SerializationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class DeserializationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class NoEstimateAvailableError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class NotImplementedError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class SigningError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class VerificationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\n//# sourceMappingURL=errors.js.map","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 { bytesToHex, hexToBytes, readUInt16BE, readUInt32BE, readUInt8 } from '@stacks/common';\nfunction createEnumChecker(enumVariable) {\n const enumValues = Object.values(enumVariable).filter(v => typeof v === 'number');\n const enumValueSet = new Set(enumValues);\n return (value) => enumValueSet.has(value);\n}\nconst enumCheckFunctions = new Map();\nexport function isEnum(enumVariable, value) {\n const checker = enumCheckFunctions.get(enumVariable);\n if (checker !== undefined) {\n return checker(value);\n }\n const newChecker = createEnumChecker(enumVariable);\n enumCheckFunctions.set(enumVariable, newChecker);\n return isEnum(enumVariable, value);\n}\nexport class BytesReader {\n constructor(bytes) {\n this.consumed = 0;\n this.source = typeof bytes === 'string' ? hexToBytes(bytes) : bytes;\n }\n readBytes(length) {\n const view = this.source.subarray(this.consumed, this.consumed + length);\n this.consumed += length;\n return view;\n }\n readUInt32BE() {\n return readUInt32BE(this.readBytes(4), 0);\n }\n readUInt8() {\n return readUInt8(this.readBytes(1), 0);\n }\n readUInt16BE() {\n return readUInt16BE(this.readBytes(2), 0);\n }\n readBigUIntLE(length) {\n const bytes = this.readBytes(length).slice().reverse();\n const hex = bytesToHex(bytes);\n return BigInt(`0x${hex}`);\n }\n readBigUIntBE(length) {\n const bytes = this.readBytes(length);\n const hex = bytesToHex(bytes);\n return BigInt(`0x${hex}`);\n }\n get readOffset() {\n return this.consumed;\n }\n set readOffset(val) {\n this.consumed = val;\n }\n get internalBytes() {\n return this.source;\n }\n readUInt8Enum(enumVariable, invalidEnumErrorFormatter) {\n const num = this.readUInt8();\n if (isEnum(enumVariable, num)) {\n return num;\n }\n throw invalidEnumErrorFormatter(num);\n }\n}\n//# sourceMappingURL=BytesReader.js.map","export const BLOCKSTACK_DEFAULT_GAIA_HUB_URL = 'https://hub.blockstack.org';\nexport const MAX_STRING_LENGTH_BYTES = 128;\nexport const CLARITY_INT_SIZE = 128;\nexport const CLARITY_INT_BYTE_SIZE = 16;\nexport const COINBASE_BYTES_LENGTH = 32;\nexport const VRF_PROOF_BYTES_LENGTH = 80;\nexport const RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;\nexport const COMPRESSED_PUBKEY_LENGTH_BYTES = 32;\nexport const UNCOMPRESSED_PUBKEY_LENGTH_BYTES = 64;\nexport const MEMO_MAX_LENGTH_BYTES = 34;\nconst MAX_PAYLOAD_LEN = 1 + 16 * 1024 * 1024;\nconst PREAMBLE_ENCODED_SIZE = 165;\nconst MAX_RELAYERS_LEN = 16;\nconst PEER_ADDRESS_ENCODED_SIZE = 16;\nconst HASH160_ENCODED_SIZE = 20;\nconst NEIGHBOR_ADDRESS_ENCODED_SIZE = PEER_ADDRESS_ENCODED_SIZE + 2 + HASH160_ENCODED_SIZE;\nconst RELAY_DATA_ENCODED_SIZE = NEIGHBOR_ADDRESS_ENCODED_SIZE + 4;\nexport const STRING_MAX_LENGTH = MAX_PAYLOAD_LEN + (PREAMBLE_ENCODED_SIZE + MAX_RELAYERS_LEN * RELAY_DATA_ENCODED_SIZE);\nexport var PayloadType;\n(function (PayloadType) {\n PayloadType[PayloadType[\"TokenTransfer\"] = 0] = \"TokenTransfer\";\n PayloadType[PayloadType[\"SmartContract\"] = 1] = \"SmartContract\";\n PayloadType[PayloadType[\"VersionedSmartContract\"] = 6] = \"VersionedSmartContract\";\n PayloadType[PayloadType[\"ContractCall\"] = 2] = \"ContractCall\";\n PayloadType[PayloadType[\"PoisonMicroblock\"] = 3] = \"PoisonMicroblock\";\n PayloadType[PayloadType[\"Coinbase\"] = 4] = \"Coinbase\";\n PayloadType[PayloadType[\"CoinbaseToAltRecipient\"] = 5] = \"CoinbaseToAltRecipient\";\n PayloadType[PayloadType[\"TenureChange\"] = 7] = \"TenureChange\";\n PayloadType[PayloadType[\"NakamotoCoinbase\"] = 8] = \"NakamotoCoinbase\";\n})(PayloadType \|\| (PayloadType = {}));\nexport var ClarityVersion;\n(function (ClarityVersion) {\n ClarityVersion[ClarityVersion[\"Clarity1\"] = 1] = \"Clarity1\";\n ClarityVersion[ClarityVersion[\"Clarity2\"] = 2] = \"Clarity2\";\n ClarityVersion[ClarityVersion[\"Clarity3\"] = 3] = \"Clarity3\";\n})(ClarityVersion \|\| (ClarityVersion = {}));\nexport var AnchorMode;\n(function (AnchorMode) {\n AnchorMode[AnchorMode[\"OnChainOnly\"] = 1] = \"OnChainOnly\";\n AnchorMode[AnchorMode[\"OffChainOnly\"] = 2] = \"OffChainOnly\";\n AnchorMode[AnchorMode[\"Any\"] = 3] = \"Any\";\n})(AnchorMode \|\| (AnchorMode = {}));\nexport const AnchorModeNames = ['onChainOnly', 'offChainOnly', 'any'];\nconst AnchorModeMap = {\n [AnchorModeNames[0]]: AnchorMode.OnChainOnly,\n [AnchorModeNames[1]]: AnchorMode.OffChainOnly,\n [AnchorModeNames[2]]: AnchorMode.Any,\n [AnchorMode.OnChainOnly]: AnchorMode.OnChainOnly,\n [AnchorMode.OffChainOnly]: AnchorMode.OffChainOnly,\n [AnchorMode.Any]: AnchorMode.Any,\n};\nexport function anchorModeFrom(mode) {\n if (mode in AnchorModeMap)\n return AnchorModeMap[mode];\n throw new Error(`Invalid anchor mode \"${mode}\", must be one of: ${AnchorModeNames.join(', ')}`);\n}\nexport var PostConditionMode;\n(function (PostConditionMode) {\n PostConditionMode[PostConditionMode[\"Allow\"] = 1] = \"Allow\";\n PostConditionMode[PostConditionMode[\"Deny\"] = 2] = \"Deny\";\n})(PostConditionMode \|\| (PostConditionMode = {}));\nexport var PostConditionType;\n(function (PostConditionType) {\n PostConditionType[PostConditionType[\"STX\"] = 0] = \"STX\";\n PostConditionType[PostConditionType[\"Fungible\"] = 1] = \"Fungible\";\n PostConditionType[PostConditionType[\"NonFungible\"] = 2] = \"NonFungible\";\n})(PostConditionType \|\| (PostConditionType = {}));\nexport var AuthType;\n(function (AuthType) {\n AuthType[AuthType[\"Standard\"] = 4] = \"Standard\";\n AuthType[AuthType[\"Sponsored\"] = 5] = \"Sponsored\";\n})(AuthType \|\| (AuthType = {}));\nexport var AddressHashMode;\n(function (AddressHashMode) {\n AddressHashMode[AddressHashMode[\"P2PKH\"] = 0] = \"P2PKH\";\n AddressHashMode[AddressHashMode[\"P2SH\"] = 1] = \"P2SH\";\n AddressHashMode[AddressHashMode[\"P2WPKH\"] = 2] = \"P2WPKH\";\n AddressHashMode[AddressHashMode[\"P2WSH\"] = 3] = \"P2WSH\";\n AddressHashMode[AddressHashMode[\"P2SHNonSequential\"] = 5] = \"P2SHNonSequential\";\n AddressHashMode[AddressHashMode[\"P2WSHNonSequential\"] = 7] = \"P2WSHNonSequential\";\n})(AddressHashMode \|\| (AddressHashMode = {}));\nexport { AddressVersion } from '@stacks/network';\nexport var PubKeyEncoding;\n(function (PubKeyEncoding) {\n PubKeyEncoding[PubKeyEncoding[\"Compressed\"] = 0] = \"Compressed\";\n PubKeyEncoding[PubKeyEncoding[\"Uncompressed\"] = 1] = \"Uncompressed\";\n})(PubKeyEncoding \|\| (PubKeyEncoding = {}));\nexport var FungibleConditionCode;\n(function (FungibleConditionCode) {\n FungibleConditionCode[FungibleConditionCode[\"Equal\"] = 1] = \"Equal\";\n FungibleConditionCode[FungibleConditionCode[\"Greater\"] = 2] = \"Greater\";\n FungibleConditionCode[FungibleConditionCode[\"GreaterEqual\"] = 3] = \"GreaterEqual\";\n FungibleConditionCode[FungibleConditionCode[\"Less\"] = 4] = \"Less\";\n FungibleConditionCode[FungibleConditionCode[\"LessEqual\"] = 5] = \"LessEqual\";\n})(FungibleConditionCode \|\| (FungibleConditionCode = {}));\nexport var NonFungibleConditionCode;\n(function (NonFungibleConditionCode) {\n NonFungibleConditionCode[NonFungibleConditionCode[\"Sends\"] = 16] = \"Sends\";\n NonFungibleConditionCode[NonFungibleConditionCode[\"DoesNotSend\"] = 17] = \"DoesNotSend\";\n})(NonFungibleConditionCode \|\| (NonFungibleConditionCode = {}));\nexport var PostConditionPrincipalId;\n(function (PostConditionPrincipalId) {\n PostConditionPrincipalId[PostConditionPrincipalId[\"Origin\"] = 1] = \"Origin\";\n PostConditionPrincipalId[PostConditionPrincipalId[\"Standard\"] = 2] = \"Standard\";\n PostConditionPrincipalId[PostConditionPrincipalId[\"Contract\"] = 3] = \"Contract\";\n})(PostConditionPrincipalId \|\| (PostConditionPrincipalId = {}));\nexport var AssetType;\n(function (AssetType) {\n AssetType[AssetType[\"STX\"] = 0] = \"STX\";\n AssetType[AssetType[\"Fungible\"] = 1] = \"Fungible\";\n AssetType[AssetType[\"NonFungible\"] = 2] = \"NonFungible\";\n})(AssetType \|\| (AssetType = {}));\nexport var TenureChangeCause;\n(function (TenureChangeCause) {\n TenureChangeCause[TenureChangeCause[\"BlockFound\"] = 0] = \"BlockFound\";\n TenureChangeCause[TenureChangeCause[\"Extended\"] = 1] = \"Extended\";\n})(TenureChangeCause \|\| (TenureChangeCause = {}));\nexport var AuthFieldType;\n(function (AuthFieldType) {\n AuthFieldType[AuthFieldType[\"PublicKeyCompressed\"] = 0] = \"PublicKeyCompressed\";\n AuthFieldType[AuthFieldType[\"PublicKeyUncompressed\"] = 1] = \"PublicKeyUncompressed\";\n AuthFieldType[AuthFieldType[\"SignatureCompressed\"] = 2] = \"SignatureCompressed\";\n AuthFieldType[AuthFieldType[\"SignatureUncompressed\"] = 3] = \"SignatureUncompressed\";\n})(AuthFieldType \|\| (AuthFieldType = {}));\nexport var TxRejectedReason;\n(function (TxRejectedReason) {\n TxRejectedReason[\"Serialization\"] = \"Serialization\";\n TxRejectedReason[\"Deserialization\"] = \"Deserialization\";\n TxRejectedReason[\"SignatureValidation\"] = \"SignatureValidation\";\n TxRejectedReason[\"FeeTooLow\"] = \"FeeTooLow\";\n TxRejectedReason[\"BadNonce\"] = \"BadNonce\";\n TxRejectedReason[\"NotEnoughFunds\"] = \"NotEnoughFunds\";\n TxRejectedReason[\"NoSuchContract\"] = \"NoSuchContract\";\n TxRejectedReason[\"NoSuchPublicFunction\"] = \"NoSuchPublicFunction\";\n TxRejectedReason[\"BadFunctionArgument\"] = \"BadFunctionArgument\";\n TxRejectedReason[\"ContractAlreadyExists\"] = \"ContractAlreadyExists\";\n TxRejectedReason[\"PoisonMicroblocksDoNotConflict\"] = \"PoisonMicroblocksDoNotConflict\";\n TxRejectedReason[\"PoisonMicroblockHasUnknownPubKeyHash\"] = \"PoisonMicroblockHasUnknownPubKeyHash\";\n TxRejectedReason[\"PoisonMicroblockIsInvalid\"] = \"PoisonMicroblockIsInvalid\";\n TxRejectedReason[\"BadAddressVersionByte\"] = \"BadAddressVersionByte\";\n TxRejectedReason[\"NoCoinbaseViaMempool\"] = \"NoCoinbaseViaMempool\";\n TxRejectedReason[\"ServerFailureNoSuchChainTip\"] = \"ServerFailureNoSuchChainTip\";\n TxRejectedReason[\"ServerFailureDatabase\"] = \"ServerFailureDatabase\";\n TxRejectedReason[\"ServerFailureOther\"] = \"ServerFailureOther\";\n})(TxRejectedReason \|\| (TxRejectedReason = {}));\n//# sourceMappingURL=constants.js.map","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, 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 / (10246)) 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 { 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","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","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","/! 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","export var ClarityType;\n(function (ClarityType) {\n ClarityType[\"Int\"] = \"int\";\n ClarityType[\"UInt\"] = \"uint\";\n ClarityType[\"Buffer\"] = \"buffer\";\n ClarityType[\"BoolTrue\"] = \"true\";\n ClarityType[\"BoolFalse\"] = \"false\";\n ClarityType[\"PrincipalStandard\"] = \"address\";\n ClarityType[\"PrincipalContract\"] = \"contract\";\n ClarityType[\"ResponseOk\"] = \"ok\";\n ClarityType[\"ResponseErr\"] = \"err\";\n ClarityType[\"OptionalNone\"] = \"none\";\n ClarityType[\"OptionalSome\"] = \"some\";\n ClarityType[\"List\"] = \"list\";\n ClarityType[\"Tuple\"] = \"tuple\";\n ClarityType[\"StringASCII\"] = \"ascii\";\n ClarityType[\"StringUTF8\"] = \"utf8\";\n})(ClarityType \|\| (ClarityType = {}));\nexport var ClarityWireType;\n(function (ClarityWireType) {\n ClarityWireType[ClarityWireType[\"int\"] = 0] = \"int\";\n ClarityWireType[ClarityWireType[\"uint\"] = 1] = \"uint\";\n ClarityWireType[ClarityWireType[\"buffer\"] = 2] = \"buffer\";\n ClarityWireType[ClarityWireType[\"true\"] = 3] = \"true\";\n ClarityWireType[ClarityWireType[\"false\"] = 4] = \"false\";\n ClarityWireType[ClarityWireType[\"address\"] = 5] = \"address\";\n ClarityWireType[ClarityWireType[\"contract\"] = 6] = \"contract\";\n ClarityWireType[ClarityWireType[\"ok\"] = 7] = \"ok\";\n ClarityWireType[ClarityWireType[\"err\"] = 8] = \"err\";\n ClarityWireType[ClarityWireType[\"none\"] = 9] = \"none\";\n ClarityWireType[ClarityWireType[\"some\"] = 10] = \"some\";\n ClarityWireType[ClarityWireType[\"list\"] = 11] = \"list\";\n ClarityWireType[ClarityWireType[\"tuple\"] = 12] = \"tuple\";\n ClarityWireType[ClarityWireType[\"ascii\"] = 13] = \"ascii\";\n ClarityWireType[ClarityWireType[\"utf8\"] = 14] = \"utf8\";\n})(ClarityWireType \|\| (ClarityWireType = {}));\nexport function clarityTypeToByte(type) {\n return ClarityWireType[type];\n}\nexport function clarityByteToType(wireType) {\n return ClarityWireType[wireType];\n}\n//# sourceMappingURL=constants.js.map","import { bytesToTwosBigInt, hexToBytes, intToBigInt, isInstance, } from '@stacks/common';\nimport { ClarityType } from '../constants';\nconst MAX_U128 = BigInt('0xffffffffffffffffffffffffffffffff');\nconst MIN_U128 = BigInt(0);\nconst MAX_I128 = BigInt('0x7fffffffffffffffffffffffffffffff');\nconst MIN_I128 = BigInt('-170141183460469231731687303715884105728');\nexport const intCV = (value) => {\n if (typeof value === 'string' && value.toLowerCase().startsWith('0x')) {\n value = bytesToTwosBigInt(hexToBytes(value));\n }\n if (isInstance(value, Uint8Array))\n value = bytesToTwosBigInt(value);\n const bigInt = intToBigInt(value);\n if (bigInt > MAX_I128) {\n throw new RangeError(`Cannot construct clarity integer from value greater than ${MAX_I128}`);\n }\n else if (bigInt < MIN_I128) {\n throw new RangeError(`Cannot construct clarity integer form value less than ${MIN_I128}`);\n }\n return { type: ClarityType.Int, value: bigInt };\n};\nexport const uintCV = (value) => {\n const bigInt = intToBigInt(value);\n if (bigInt < MIN_U128) {\n throw new RangeError('Cannot construct unsigned clarity integer from negative value');\n }\n else if (bigInt > MAX_U128) {\n throw new RangeError(`Cannot construct unsigned clarity integer greater than ${MAX_U128}`);\n }\n return { type: ClarityType.UInt, value: bigInt };\n};\n//# sourceMappingURL=intCV.js.map","import { bytesToHex, utf8ToBytes } from '@stacks/common';\nimport { ClarityType } from '../constants';\nexport const bufferCV = (buffer) => {\n if (buffer.byteLength > 1048576) {\n throw new Error('Cannot construct clarity buffer that is greater than 1MB');\n }\n return { type: ClarityType.Buffer, value: bytesToHex(buffer) };\n};\nexport const bufferCVFromString = (str) => bufferCV(utf8ToBytes(str));\n//# sourceMappingURL=bufferCV.js.map","import { ClarityType } from '../constants';\nexport const trueCV = () => ({ type: ClarityType.BoolTrue });\nexport const falseCV = () => ({ type: ClarityType.BoolFalse });\nexport const boolCV = (bool) => (bool ? trueCV() : falseCV());\n//# sourceMappingURL=booleanCV.js.map","export var StacksWireType;\n(function (StacksWireType) {\n StacksWireType[StacksWireType[\"Address\"] = 0] = \"Address\";\n StacksWireType[StacksWireType[\"Principal\"] = 1] = \"Principal\";\n StacksWireType[StacksWireType[\"LengthPrefixedString\"] = 2] = \"LengthPrefixedString\";\n StacksWireType[StacksWireType[\"MemoString\"] = 3] = \"MemoString\";\n StacksWireType[StacksWireType[\"Asset\"] = 4] = \"Asset\";\n StacksWireType[StacksWireType[\"PostCondition\"] = 5] = \"PostCondition\";\n StacksWireType[StacksWireType[\"PublicKey\"] = 6] = \"PublicKey\";\n StacksWireType[StacksWireType[\"LengthPrefixedList\"] = 7] = \"LengthPrefixedList\";\n StacksWireType[StacksWireType[\"Payload\"] = 8] = \"Payload\";\n StacksWireType[StacksWireType[\"MessageSignature\"] = 9] = \"MessageSignature\";\n StacksWireType[StacksWireType[\"StructuredDataSignature\"] = 10] = \"StructuredDataSignature\";\n StacksWireType[StacksWireType[\"TransactionAuthField\"] = 11] = \"TransactionAuthField\";\n})(StacksWireType \|\| (StacksWireType = {}));\nexport function whenWireType(wireType) {\n return (wireTypeMap) => wireTypeMap[wireType];\n}\n//# sourceMappingURL=types.js.map","import { hexToBytes, intToBigInt } from '@stacks/common';\nimport { c32addressDecode } from 'c32check';\nimport { ClarityType, principalCV } from '../clarity';\nimport { AddressVersion, COINBASE_BYTES_LENGTH, MAX_STRING_LENGTH_BYTES, MEMO_MAX_LENGTH_BYTES, PayloadType, PostConditionPrincipalId, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, VRF_PROOF_BYTES_LENGTH, } from '../constants';\nimport { exceedsMaxLengthBytes } from '../utils';\nimport { StacksWireType, } from './types';\nexport function createEmptyAddress() {\n return {\n type: StacksWireType.Address,\n version: AddressVersion.MainnetSingleSig,\n hash160: '0'.repeat(40),\n };\n}\nexport function createMemoString(content) {\n if (content && exceedsMaxLengthBytes(content, MEMO_MAX_LENGTH_BYTES)) {\n throw new Error(`Memo exceeds maximum length of ${MEMO_MAX_LENGTH_BYTES} bytes`);\n }\n return { type: StacksWireType.MemoString, content };\n}\nexport function createLPList(values, lengthPrefixBytes) {\n return {\n type: StacksWireType.LengthPrefixedList,\n lengthPrefixBytes: lengthPrefixBytes \|\| 4,\n values,\n };\n}\nexport function createMessageSignature(signature) {\n const length = hexToBytes(signature).byteLength;\n if (length != RECOVERABLE_ECDSA_SIG_LENGTH_BYTES) {\n throw Error('Invalid signature');\n }\n return {\n type: StacksWireType.MessageSignature,\n data: signature,\n };\n}\nexport function createTokenTransferPayload(recipient, amount, memo) {\n if (typeof recipient === 'string') {\n recipient = principalCV(recipient);\n }\n if (typeof memo === 'string') {\n memo = createMemoString(memo);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.TokenTransfer,\n recipient,\n amount: intToBigInt(amount),\n memo: memo ?? createMemoString(''),\n };\n}\nexport function createContractCallPayload(contractAddress, contractName, functionName, functionArgs) {\n if (typeof contractName === 'string') {\n contractName = createLPString(contractName);\n }\n if (typeof functionName === 'string') {\n functionName = createLPString(functionName);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.ContractCall,\n contractAddress: typeof contractAddress === 'string' ? createAddress(contractAddress) : contractAddress,\n contractName,\n functionName,\n functionArgs,\n };\n}\nexport function codeBodyString(content) {\n return createLPString(content, 4, 100000);\n}\nexport function createSmartContractPayload(contractName, codeBody, clarityVersion) {\n if (typeof contractName === 'string') {\n contractName = createLPString(contractName);\n }\n if (typeof codeBody === 'string') {\n codeBody = codeBodyString(codeBody);\n }\n if (typeof clarityVersion === 'number') {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.VersionedSmartContract,\n clarityVersion,\n contractName,\n codeBody,\n };\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.SmartContract,\n contractName,\n codeBody,\n };\n}\nexport function createPoisonPayload() {\n return { type: StacksWireType.Payload, payloadType: PayloadType.PoisonMicroblock };\n}\nexport function createCoinbasePayload(coinbaseBytes, altRecipient) {\n if (coinbaseBytes.byteLength != COINBASE_BYTES_LENGTH) {\n throw Error(`Coinbase buffer size must be ${COINBASE_BYTES_LENGTH} bytes`);\n }\n if (altRecipient != undefined) {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.CoinbaseToAltRecipient,\n coinbaseBytes,\n recipient: altRecipient,\n };\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.Coinbase,\n coinbaseBytes,\n };\n}\nexport function createNakamotoCoinbasePayload(coinbaseBytes, recipient, vrfProof) {\n if (coinbaseBytes.byteLength != COINBASE_BYTES_LENGTH) {\n throw Error(`Coinbase buffer size must be ${COINBASE_BYTES_LENGTH} bytes`);\n }\n if (vrfProof.byteLength != VRF_PROOF_BYTES_LENGTH) {\n throw Error(`VRF proof buffer size must be ${VRF_PROOF_BYTES_LENGTH} bytes`);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.NakamotoCoinbase,\n coinbaseBytes,\n recipient: recipient.type === ClarityType.OptionalSome ? recipient.value : undefined,\n vrfProof,\n };\n}\nexport function createTenureChangePayload(tenureHash, previousTenureHash, burnViewHash, previousTenureEnd, previousTenureBlocks, cause, publicKeyHash) {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.TenureChange,\n tenureHash,\n previousTenureHash,\n burnViewHash,\n previousTenureEnd,\n previousTenureBlocks,\n cause,\n publicKeyHash,\n };\n}\nexport function createLPString(content, lengthPrefixBytes, maxLengthBytes) {\n const prefixLength = lengthPrefixBytes \|\| 1;\n const maxLength = maxLengthBytes \|\| MAX_STRING_LENGTH_BYTES;\n if (exceedsMaxLengthBytes(content, maxLength)) {\n throw new Error(`String length exceeds maximum bytes ${maxLength}`);\n }\n return {\n type: StacksWireType.LengthPrefixedString,\n content,\n lengthPrefixBytes: prefixLength,\n maxLengthBytes: maxLength,\n };\n}\nexport function createAsset(addressString, contractName, assetName) {\n return {\n type: StacksWireType.Asset,\n address: createAddress(addressString),\n contractName: createLPString(contractName),\n assetName: createLPString(assetName),\n };\n}\nexport function createAddress(c32AddressString) {\n const addressData = c32addressDecode(c32AddressString);\n return {\n type: StacksWireType.Address,\n version: addressData[0],\n hash160: addressData[1],\n };\n}\nexport function createContractPrincipal(addressString, contractName) {\n const addr = createAddress(addressString);\n const name = createLPString(contractName);\n return {\n type: StacksWireType.Principal,\n prefix: PostConditionPrincipalId.Contract,\n address: addr,\n contractName: name,\n };\n}\nexport function createStandardPrincipal(addressString) {\n const addr = createAddress(addressString);\n return {\n type: StacksWireType.Principal,\n prefix: PostConditionPrincipalId.Standard,\n address: addr,\n };\n}\nexport function createTransactionAuthField(pubKeyEncoding, contents) {\n return {\n pubKeyEncoding,\n type: StacksWireType.TransactionAuthField,\n contents,\n };\n}\n//# sourceMappingURL=create.js.map","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 { 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","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 { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { getPublicKey as nobleGetPublicKey, Point, Signature, signSync, utils, } from '@noble/secp256k1';\nimport { bytesToHex, hexToBigInt, hexToBytes, intToHex, parseRecoverableSignatureVrs, PRIVATE_KEY_BYTES_COMPRESSED, privateKeyToBytes, signatureRsvToVrs, signatureVrsToRsv, } from '@stacks/common';\nimport { networkFrom, STACKS_MAINNET } from '@stacks/network';\nimport { c32address } from 'c32check';\nimport { addressHashModeToVersion } from './address';\nimport { AddressHashMode, PubKeyEncoding } from './constants';\nimport { hash160, hashP2PKH } from './utils';\nimport { addressFromVersionHash, addressToString, StacksWireType } from './wire';\nutils.hmacSha256Sync = (key, ...msgs) => {\n const h = hmac.create(sha256, key);\n msgs.forEach(msg => h.update(msg));\n return h.digest();\n};\nexport function getAddressFromPrivateKey(privateKey, network = 'mainnet') {\n network = networkFrom(network);\n const publicKey = privateKeyToPublic(privateKey);\n return getAddressFromPublicKey(publicKey, network);\n}\nexport function getAddressFromPublicKey(publicKey, network = 'mainnet') {\n network = networkFrom(network);\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n const addrVer = addressHashModeToVersion(AddressHashMode.P2PKH, network);\n const addr = addressFromVersionHash(addrVer, hashP2PKH(publicKey));\n const addrString = addressToString(addr);\n return addrString;\n}\nexport function createStacksPublicKey(publicKey) {\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return {\n type: StacksWireType.PublicKey,\n data: publicKey,\n };\n}\nexport function publicKeyFromSignatureVrs(messageHash, messageSignature, pubKeyEncoding = PubKeyEncoding.Compressed) {\n const parsedSignature = parseRecoverableSignatureVrs(messageSignature);\n const signature = new Signature(hexToBigInt(parsedSignature.r), hexToBigInt(parsedSignature.s));\n const point = Point.fromSignature(messageHash, signature, parsedSignature.recoveryId);\n const compressed = pubKeyEncoding === PubKeyEncoding.Compressed;\n return point.toHex(compressed);\n}\nexport function publicKeyFromSignatureRsv(messageHash, messageSignature, pubKeyEncoding = PubKeyEncoding.Compressed) {\n return publicKeyFromSignatureVrs(messageHash, signatureRsvToVrs(messageSignature), pubKeyEncoding);\n}\nexport function privateKeyToHex(publicKey) {\n return typeof publicKey === 'string' ? publicKey : bytesToHex(publicKey);\n}\nexport const publicKeyToHex = privateKeyToHex;\nexport const isPrivateKeyCompressed = privateKeyIsCompressed;\nexport function privateKeyIsCompressed(privateKey) {\n const length = typeof privateKey === 'string' ? privateKey.length / 2 : privateKey.byteLength;\n return length === PRIVATE_KEY_BYTES_COMPRESSED;\n}\nexport const isPublicKeyCompressed = publicKeyIsCompressed;\nexport function publicKeyIsCompressed(publicKey) {\n return !publicKeyToHex(publicKey).startsWith('04');\n}\nexport function privateKeyToPublic(privateKey) {\n privateKey = privateKeyToBytes(privateKey);\n const isCompressed = privateKeyIsCompressed(privateKey);\n return bytesToHex(nobleGetPublicKey(privateKey.slice(0, 32), isCompressed));\n}\nexport function compressPublicKey(publicKey) {\n return Point.fromHex(publicKeyToHex(publicKey)).toHex(true);\n}\nexport function uncompressPublicKey(publicKey) {\n return Point.fromHex(publicKeyToHex(publicKey)).toHex(false);\n}\nexport const makeRandomPrivKey = randomPrivateKey;\nexport function randomPrivateKey() {\n return compressPrivateKey(utils.randomPrivateKey());\n}\nexport function signWithKey(privateKey, messageHash) {\n privateKey = privateKeyToBytes(privateKey);\n const [rawSignature, recoveryId] = signSync(messageHash, privateKey.slice(0, 32), {\n canonical: true,\n recovered: true,\n });\n if (recoveryId == null) {\n throw new Error('No signature recoveryId received');\n }\n const recoveryIdHex = intToHex(recoveryId, 1);\n return recoveryIdHex + Signature.fromHex(rawSignature).toCompactHex();\n}\nexport function signMessageHashRsv({ messageHash, privateKey, }) {\n return signatureVrsToRsv(signWithKey(privateKey, messageHash));\n}\nexport function compressPrivateKey(privateKey) {\n privateKey = privateKeyToHex(privateKey);\n return privateKey.length == PRIVATE_KEY_BYTES_COMPRESSED * 2\n ? privateKey\n : `${privateKey}01`;\n}\nexport function privateKeyToAddress(privateKey, network) {\n const publicKey = privateKeyToPublic(privateKey);\n return publicKeyToAddressSingleSig(publicKey, network);\n}\nexport function publicKeyToAddress(...args) {\n if (typeof args[0] === 'number')\n return _publicKeyToAddress(...args);\n return publicKeyToAddressSingleSig(...args);\n}\nfunction _publicKeyToAddress(version, publicKey) {\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return c32address(version, bytesToHex(hash160(publicKey)));\n}\nexport function publicKeyToAddressSingleSig(publicKey, network) {\n network = network ? networkFrom(network) : STACKS_MAINNET;\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return c32address(network.addressVersion.singleSig, bytesToHex(hash160(publicKey)));\n}\n//# sourceMappingURL=keys.js.map","import { c32address } from 'c32check';\nimport { AddressHashMode, PayloadType } from '../constants';\nimport { publicKeyIsCompressed } from '../keys';\nimport { hashP2PKH, hashP2SH, hashP2WPKH, hashP2WSH } from '../utils';\nimport { createAsset, createContractPrincipal, createStandardPrincipal } from './create';\nimport { serializePublicKeyBytes } from './serialization';\nimport { StacksWireType, } from './types';\nexport function addressFromPublicKeys(version, hashMode, numSigs, publicKeys) {\n if (publicKeys.length === 0) {\n throw Error('Invalid number of public keys');\n }\n if (hashMode === AddressHashMode.P2PKH \|\| hashMode === AddressHashMode.P2WPKH) {\n if (publicKeys.length !== 1 \|\| numSigs !== 1) {\n throw Error('Invalid number of public keys or signatures');\n }\n }\n if (hashMode === AddressHashMode.P2WPKH \|\|\n hashMode === AddressHashMode.P2WSH \|\|\n hashMode === AddressHashMode.P2WSHNonSequential) {\n if (!publicKeys.map(p => p.data).every(publicKeyIsCompressed)) {\n throw Error('Public keys must be compressed for segwit');\n }\n }\n switch (hashMode) {\n case AddressHashMode.P2PKH:\n return addressFromVersionHash(version, hashP2PKH(publicKeys[0].data));\n case AddressHashMode.P2WPKH:\n return addressFromVersionHash(version, hashP2WPKH(publicKeys[0].data));\n case AddressHashMode.P2SH:\n case AddressHashMode.P2SHNonSequential:\n return addressFromVersionHash(version, hashP2SH(numSigs, publicKeys.map(serializePublicKeyBytes)));\n case AddressHashMode.P2WSH:\n case AddressHashMode.P2WSHNonSequential:\n return addressFromVersionHash(version, hashP2WSH(numSigs, publicKeys.map(serializePublicKeyBytes)));\n }\n}\nexport function addressFromVersionHash(version, hash) {\n return { type: StacksWireType.Address, version, hash160: hash };\n}\nexport function addressToString(address) {\n return c32address(address.version, address.hash160);\n}\nexport function isTokenTransferPayload(p) {\n return p.payloadType === PayloadType.TokenTransfer;\n}\nexport function isContractCallPayload(p) {\n return p.payloadType === PayloadType.ContractCall;\n}\nexport function isSmartContractPayload(p) {\n return p.payloadType === PayloadType.SmartContract;\n}\nexport function isPoisonPayload(p) {\n return p.payloadType === PayloadType.PoisonMicroblock;\n}\nexport function isCoinbasePayload(p) {\n return p.payloadType === PayloadType.Coinbase;\n}\nexport function parseAssetString(id) {\n const [assetAddress, assetContractName, assetTokenName] = id.split(/\\.\|::/);\n const asset = createAsset(assetAddress, assetContractName, assetTokenName);\n return asset;\n}\nexport function parsePrincipalString(principalString) {\n if (principalString.includes('.')) {\n const [address, contractName] = principalString.split('.');\n return createContractPrincipal(address, contractName);\n }\n else {\n return createStandardPrincipal(principalString);\n }\n}\n//# sourceMappingURL=helpers.js.map","import { utf8ToBytes } from '@stacks/common';\nimport { addressToString, createAddress, createLPString, } from '../../wire';\nimport { ClarityType } from '../constants';\nexport function principalCV(principal) {\n if (principal.includes('.')) {\n const [address, contractName] = principal.split('.');\n return contractPrincipalCV(address, contractName);\n }\n else {\n return standardPrincipalCV(principal);\n }\n}\nexport function standardPrincipalCV(addressString) {\n const addr = createAddress(addressString);\n return { type: ClarityType.PrincipalStandard, value: addressToString(addr) };\n}\nexport function standardPrincipalCVFromAddress(address) {\n return { type: ClarityType.PrincipalStandard, value: addressToString(address) };\n}\nexport function contractPrincipalCV(addressString, contractName) {\n const addr = createAddress(addressString);\n const lengthPrefixedContractName = createLPString(contractName);\n return contractPrincipalCVFromAddress(addr, lengthPrefixedContractName);\n}\nexport function contractPrincipalCVFromAddress(address, contractName) {\n if (utf8ToBytes(contractName.content).byteLength >= 128) {\n throw new Error('Contract name must be less than 128 bytes');\n }\n return {\n type: ClarityType.PrincipalContract,\n value: `${addressToString(address)}.${contractName.content}`,\n };\n}\nexport function contractPrincipalCVFromStandard(sp, contractName) {\n return {\n type: ClarityType.PrincipalContract,\n value: `${sp.value}.${contractName}`,\n };\n}\n//# sourceMappingURL=principalCV.js.map","import { ClarityType } from '../constants';\nexport function noneCV() {\n return { type: ClarityType.OptionalNone };\n}\nexport function someCV(value) {\n return { type: ClarityType.OptionalSome, value };\n}\nexport function optionalCVOf(value) {\n return value ? someCV(value) : noneCV();\n}\n//# sourceMappingURL=optionalCV.js.map","import { ClarityType } from '../constants';\nimport { isClarityName } from '../../utils';\nexport function tupleCV(data) {\n for (const key in data) {\n if (!isClarityName(key)) {\n throw new Error(`\"${key}\" is not a valid Clarity name`);\n }\n }\n return { type: ClarityType.Tuple, value: data };\n}\n//# sourceMappingURL=tupleCV.js.map","import { ripemd160 } from '@noble/hashes/ripemd160';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { sha512_256 } from '@noble/hashes/sha512';\nimport { utils } from '@noble/secp256k1';\nimport { bytesToHex, concatArray, concatBytes, utf8ToBytes } from '@stacks/common';\nimport { c32addressDecode } from 'c32check';\nimport lodashCloneDeep from 'lodash.clonedeep';\nimport { deserializeCV, serializeCV } from './clarity';\nexport { verify as verifySignature } from '@noble/secp256k1';\nexport const randomBytes = (bytesLength) => utils.randomBytes(bytesLength);\nexport const leftPadHex = (hexString) => hexString.length % 2 ? `0${hexString}` : hexString;\nexport const leftPadHexToLength = (hexString, length) => hexString.padStart(length, '0');\nexport const rightPadHexToLength = (hexString, length) => hexString.padEnd(length, '0');\nexport const exceedsMaxLengthBytes = (string, maxLengthBytes) => string ? utf8ToBytes(string).length > maxLengthBytes : false;\nexport function cloneDeep(obj) {\n return lodashCloneDeep(obj);\n}\nexport function omit(obj, prop) {\n const clone = cloneDeep(obj);\n delete clone[prop];\n return clone;\n}\nexport const hash160 = (input) => {\n return ripemd160(sha256(input));\n};\nexport const txidFromData = (data) => {\n return bytesToHex(sha512_256(data));\n};\nexport const txidFromBytes = txidFromData;\nexport const hashP2PKH = (input) => {\n return bytesToHex(hash160(input));\n};\nexport const hashP2WPKH = (input) => {\n const keyHash = hash160(input);\n const redeemScript = concatBytes(new Uint8Array([0]), new Uint8Array([keyHash.length]), keyHash);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport const hashP2SH = (numSigs, pubKeys) => {\n if (numSigs > 15 \|\| pubKeys.length > 15) {\n throw Error('P2SH multisig address can only contain up to 15 public keys');\n }\n const bytesArray = [];\n bytesArray.push(80 + numSigs);\n pubKeys.forEach(pubKey => {\n bytesArray.push(pubKey.length);\n bytesArray.push(pubKey);\n });\n bytesArray.push(80 + pubKeys.length);\n bytesArray.push(174);\n const redeemScript = concatArray(bytesArray);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport const hashP2WSH = (numSigs, pubKeys) => {\n if (numSigs > 15 \|\| pubKeys.length > 15) {\n throw Error('P2WSH multisig address can only contain up to 15 public keys');\n }\n const scriptArray = [];\n scriptArray.push(80 + numSigs);\n pubKeys.forEach(pubKey => {\n scriptArray.push(pubKey.length);\n scriptArray.push(pubKey);\n });\n scriptArray.push(80 + pubKeys.length);\n scriptArray.push(174);\n const script = concatArray(scriptArray);\n const digest = sha256(script);\n const bytesArray = [];\n bytesArray.push(0);\n bytesArray.push(digest.length);\n bytesArray.push(digest);\n const redeemScript = concatArray(bytesArray);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport function isClarityName(name) {\n const regex = /^[a-zA-Z]([a-zA-Z0-9]\|[-_!?+<>=/])$\|^[-+=/]$\|^[<>]=?$/;\n return regex.test(name) && name.length < 128;\n}\nexport function cvToHex(cv) {\n const serialized = serializeCV(cv);\n return `0x${serialized}`;\n}\nexport function hexToCV(hex) {\n return deserializeCV(hex);\n}\nexport const parseReadOnlyResponse = (response) => {\n if (response.okay)\n return hexToCV(response.result);\n throw new Error(response.cause);\n};\nexport const validateStacksAddress = (address) => {\n try {\n c32addressDecode(address);\n return true;\n }\n catch (e) {\n return false;\n }\n};\nexport function parseContractId(contractId) {\n const [address, name] = contractId.split('.');\n if (!address \|\| !name)\n throw new Error(`Invalid contract identifier: ${contractId}`);\n return [address, name];\n}\n//# sourceMappingURL=utils.js.map","import { ClarityType } from '../constants';\nexport const stringAsciiCV = (data) => {\n return { type: ClarityType.StringASCII, value: data };\n};\nexport const stringUtf8CV = (data) => {\n return { type: ClarityType.StringUTF8, value: data };\n};\nexport const stringCV = (data, encoding) => {\n switch (encoding) {\n case 'ascii':\n return stringAsciiCV(data);\n case 'utf8':\n return stringUtf8CV(data);\n }\n};\n//# sourceMappingURL=stringCV.js.map","import { bytesToAscii, bytesToTwosBigInt, bytesToUtf8, hexToBytes } from '@stacks/common';\nimport { ClarityWireType, bufferCV, contractPrincipalCVFromAddress, falseCV, intCV, listCV, noneCV, responseErrorCV, responseOkCV, someCV, standardPrincipalCVFromAddress, stringAsciiCV, stringUtf8CV, trueCV, tupleCV, uintCV, } from '.';\nimport { BytesReader } from '../BytesReader';\nimport { DeserializationError } from '../errors';\nimport { deserializeAddress, deserializeLPString } from '../wire';\nexport function deserializeCV(serializedClarityValue) {\n let bytesReader;\n if (typeof serializedClarityValue === 'string') {\n const hasHexPrefix = serializedClarityValue.slice(0, 2).toLowerCase() === '0x';\n bytesReader = new BytesReader(hexToBytes(hasHexPrefix ? serializedClarityValue.slice(2) : serializedClarityValue));\n }\n else if (serializedClarityValue instanceof Uint8Array) {\n bytesReader = new BytesReader(serializedClarityValue);\n }\n else {\n bytesReader = serializedClarityValue;\n }\n const type = bytesReader.readUInt8Enum(ClarityWireType, n => {\n throw new DeserializationError(`Cannot recognize Clarity Type: ${n}`);\n });\n switch (type) {\n case ClarityWireType.int:\n return intCV(bytesToTwosBigInt(bytesReader.readBytes(16)));\n case ClarityWireType.uint:\n return uintCV(bytesReader.readBytes(16));\n case ClarityWireType.buffer:\n const bufferLength = bytesReader.readUInt32BE();\n return bufferCV(bytesReader.readBytes(bufferLength));\n case ClarityWireType.true:\n return trueCV();\n case ClarityWireType.false:\n return falseCV();\n case ClarityWireType.address:\n const sAddress = deserializeAddress(bytesReader);\n return standardPrincipalCVFromAddress(sAddress);\n case ClarityWireType.contract:\n const cAddress = deserializeAddress(bytesReader);\n const contractName = deserializeLPString(bytesReader);\n return contractPrincipalCVFromAddress(cAddress, contractName);\n case ClarityWireType.ok:\n return responseOkCV(deserializeCV(bytesReader));\n case ClarityWireType.err:\n return responseErrorCV(deserializeCV(bytesReader));\n case ClarityWireType.none:\n return noneCV();\n case ClarityWireType.some:\n return someCV(deserializeCV(bytesReader));\n case ClarityWireType.list:\n const listLength = bytesReader.readUInt32BE();\n const listContents = [];\n for (let i = 0; i < listLength; i++) {\n listContents.push(deserializeCV(bytesReader));\n }\n return listCV(listContents);\n case ClarityWireType.tuple:\n const tupleLength = bytesReader.readUInt32BE();\n const tupleContents = {};\n for (let i = 0; i < tupleLength; i++) {\n const clarityName = deserializeLPString(bytesReader).content;\n if (clarityName === undefined) {\n throw new DeserializationError('\"content\" is undefined');\n }\n tupleContents[clarityName] = deserializeCV(bytesReader);\n }\n return tupleCV(tupleContents);\n case ClarityWireType.ascii:\n const asciiStrLen = bytesReader.readUInt32BE();\n const asciiStr = bytesToAscii(bytesReader.readBytes(asciiStrLen));\n return stringAsciiCV(asciiStr);\n case ClarityWireType.utf8:\n const utf8StrLen = bytesReader.readUInt32BE();\n const utf8Str = bytesToUtf8(bytesReader.readBytes(utf8StrLen));\n return stringUtf8CV(utf8Str);\n default:\n throw new DeserializationError('Unable to deserialize Clarity Value from Uint8Array. Could not find valid Clarity Type.');\n }\n}\n//# sourceMappingURL=deserialize.js.map","import { ClarityType } from '../constants';\nexport function responseErrorCV(value) {\n return { type: ClarityType.ResponseErr, value };\n}\nexport function responseOkCV(value) {\n return { type: ClarityType.ResponseOk, value };\n}\n//# sourceMappingURL=responseCV.js.map","import { ClarityType } from '../constants';\nexport function listCV(values) {\n return { type: ClarityType.List, value: values };\n}\n//# sourceMappingURL=listCV.js.map","import { asciiToBytes, bigIntToBytes, bytesToHex, concatArray, concatBytes, hexToBytes, toTwos, utf8ToBytes, writeUInt32BE, } from '@stacks/common';\nimport { CLARITY_INT_BYTE_SIZE, CLARITY_INT_SIZE } from '../constants';\nimport { SerializationError } from '../errors';\nimport { parseContractId } from '../utils';\nimport { createAddress, createLPString, serializeAddressBytes, serializeLPStringBytes, } from '../wire';\nimport { ClarityType, clarityTypeToByte } from './constants';\nfunction bytesWithTypeID(typeId, bytes) {\n return concatArray([clarityTypeToByte(typeId), bytes]);\n}\nfunction serializeBoolCV(value) {\n return new Uint8Array([clarityTypeToByte(value.type)]);\n}\nfunction serializeOptionalCV(cv) {\n if (cv.type === ClarityType.OptionalNone) {\n return new Uint8Array([clarityTypeToByte(cv.type)]);\n }\n else {\n return bytesWithTypeID(cv.type, serializeCVBytes(cv.value));\n }\n}\nfunction serializeBufferCV(cv) {\n const length = new Uint8Array(4);\n writeUInt32BE(length, Math.ceil(cv.value.length / 2), 0);\n return bytesWithTypeID(cv.type, concatBytes(length, hexToBytes(cv.value)));\n}\nfunction serializeIntCV(cv) {\n const bytes = bigIntToBytes(toTwos(BigInt(cv.value), BigInt(CLARITY_INT_SIZE)), CLARITY_INT_BYTE_SIZE);\n return bytesWithTypeID(cv.type, bytes);\n}\nfunction serializeUIntCV(cv) {\n const bytes = bigIntToBytes(BigInt(cv.value), CLARITY_INT_BYTE_SIZE);\n return bytesWithTypeID(cv.type, bytes);\n}\nfunction serializeStandardPrincipalCV(cv) {\n return bytesWithTypeID(cv.type, serializeAddressBytes(createAddress(cv.value)));\n}\nfunction serializeContractPrincipalCV(cv) {\n const [address, name] = parseContractId(cv.value);\n return bytesWithTypeID(cv.type, concatBytes(serializeAddressBytes(createAddress(address)), serializeLPStringBytes(createLPString(name))));\n}\nfunction serializeResponseCV(cv) {\n return bytesWithTypeID(cv.type, serializeCVBytes(cv.value));\n}\nfunction serializeListCV(cv) {\n const bytesArray = [];\n const length = new Uint8Array(4);\n writeUInt32BE(length, cv.value.length, 0);\n bytesArray.push(length);\n for (const value of cv.value) {\n const serializedValue = serializeCVBytes(value);\n bytesArray.push(serializedValue);\n }\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeTupleCV(cv) {\n const bytesArray = [];\n const length = new Uint8Array(4);\n writeUInt32BE(length, Object.keys(cv.value).length, 0);\n bytesArray.push(length);\n const lexicographicOrder = Object.keys(cv.value).sort((a, b) => a.localeCompare(b));\n for (const key of lexicographicOrder) {\n const nameWithLength = createLPString(key);\n bytesArray.push(serializeLPStringBytes(nameWithLength));\n const serializedValue = serializeCVBytes(cv.value[key]);\n bytesArray.push(serializedValue);\n }\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeStringCV(cv, encoding) {\n const bytesArray = [];\n const str = encoding == 'ascii' ? asciiToBytes(cv.value) : utf8ToBytes(cv.value);\n const len = new Uint8Array(4);\n writeUInt32BE(len, str.length, 0);\n bytesArray.push(len);\n bytesArray.push(str);\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeStringAsciiCV(cv) {\n return serializeStringCV(cv, 'ascii');\n}\nfunction serializeStringUtf8CV(cv) {\n return serializeStringCV(cv, 'utf8');\n}\nexport function serializeCV(value) {\n return bytesToHex(serializeCVBytes(value));\n}\nexport function serializeCVBytes(value) {\n switch (value.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return serializeBoolCV(value);\n case ClarityType.OptionalNone:\n case ClarityType.OptionalSome:\n return serializeOptionalCV(value);\n case ClarityType.Buffer:\n return serializeBufferCV(value);\n case ClarityType.UInt:\n return serializeUIntCV(value);\n case ClarityType.Int:\n return serializeIntCV(value);\n case ClarityType.PrincipalStandard:\n return serializeStandardPrincipalCV(value);\n case ClarityType.PrincipalContract:\n return serializeContractPrincipalCV(value);\n case ClarityType.ResponseOk:\n case ClarityType.ResponseErr:\n return serializeResponseCV(value);\n case ClarityType.List:\n return serializeListCV(value);\n case ClarityType.Tuple:\n return serializeTupleCV(value);\n case ClarityType.StringASCII:\n return serializeStringAsciiCV(value);\n case ClarityType.StringUTF8:\n return serializeStringUtf8CV(value);\n default:\n throw new SerializationError('Unable to serialize. Invalid Clarity Value.');\n }\n}\n//# sourceMappingURL=serialize.js.map","import { bytesToHex, bytesToUtf8, concatArray, hexToBytes, hexToInt, intToBigInt, intToBytes, intToHex, isInstance, utf8ToBytes, writeUInt32BE, writeUInt8, } from '@stacks/common';\nimport { BytesReader } from '../BytesReader';\nimport { deserializeCV, noneCV, serializeCVBytes, someCV, } from '../clarity';\nimport { AuthFieldType, COINBASE_BYTES_LENGTH, COMPRESSED_PUBKEY_LENGTH_BYTES, ClarityVersion, FungibleConditionCode, STRING_MAX_LENGTH, MEMO_MAX_LENGTH_BYTES, NonFungibleConditionCode, PayloadType, PostConditionPrincipalId, PostConditionType, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, TenureChangeCause, UNCOMPRESSED_PUBKEY_LENGTH_BYTES, VRF_PROOF_BYTES_LENGTH, } from '../constants';\nimport { DeserializationError, SerializationError } from '../errors';\nimport { compressPublicKey, createStacksPublicKey, uncompressPublicKey } from '../keys';\nimport { rightPadHexToLength } from '../utils';\nimport { createCoinbasePayload, createContractCallPayload, createLPList, createLPString, createMessageSignature, createNakamotoCoinbasePayload, createPoisonPayload, createSmartContractPayload, createTenureChangePayload, createTokenTransferPayload, createTransactionAuthField, } from './create';\nimport { StacksWireType, } from './types';\nexport function serializeStacksWire(wire) {\n return bytesToHex(serializeStacksWireBytes(wire));\n}\nexport function serializeStacksWireBytes(wire) {\n switch (wire.type) {\n case StacksWireType.Address:\n return serializeAddressBytes(wire);\n case StacksWireType.Principal:\n return serializePrincipalBytes(wire);\n case StacksWireType.LengthPrefixedString:\n return serializeLPStringBytes(wire);\n case StacksWireType.MemoString:\n return serializeMemoStringBytes(wire);\n case StacksWireType.Asset:\n return serializeAssetBytes(wire);\n case StacksWireType.PostCondition:\n return serializePostConditionWireBytes(wire);\n case StacksWireType.PublicKey:\n return serializePublicKeyBytes(wire);\n case StacksWireType.LengthPrefixedList:\n return serializeLPListBytes(wire);\n case StacksWireType.Payload:\n return serializePayloadBytes(wire);\n case StacksWireType.TransactionAuthField:\n return serializeTransactionAuthFieldBytes(wire);\n case StacksWireType.MessageSignature:\n return serializeMessageSignatureBytes(wire);\n }\n}\nexport function deserializeStacksWire(bytesReader, type, listType) {\n switch (type) {\n case StacksWireType.Address:\n return deserializeAddress(bytesReader);\n case StacksWireType.Principal:\n return deserializePrincipal(bytesReader);\n case StacksWireType.LengthPrefixedString:\n return deserializeLPString(bytesReader);\n case StacksWireType.MemoString:\n return deserializeMemoString(bytesReader);\n case StacksWireType.Asset:\n return deserializeAsset(bytesReader);\n case StacksWireType.PostCondition:\n return deserializePostConditionWire(bytesReader);\n case StacksWireType.PublicKey:\n return deserializePublicKey(bytesReader);\n case StacksWireType.Payload:\n return deserializePayload(bytesReader);\n case StacksWireType.LengthPrefixedList:\n if (!listType) {\n throw new DeserializationError('No list type specified');\n }\n return deserializeLPList(bytesReader, listType);\n case StacksWireType.MessageSignature:\n return deserializeMessageSignature(bytesReader);\n default:\n throw new Error('Could not recognize StacksWireType');\n }\n}\nexport function serializeAddress(address) {\n return bytesToHex(serializeAddressBytes(address));\n}\nexport function serializeAddressBytes(address) {\n const bytesArray = [];\n bytesArray.push(hexToBytes(intToHex(address.version, 1)));\n bytesArray.push(hexToBytes(address.hash160));\n return concatArray(bytesArray);\n}\nexport function deserializeAddress(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const version = hexToInt(bytesToHex(bytesReader.readBytes(1)));\n const data = bytesToHex(bytesReader.readBytes(20));\n return { type: StacksWireType.Address, version, hash160: data };\n}\nexport function serializePrincipal(principal) {\n return bytesToHex(serializePrincipalBytes(principal));\n}\nexport function serializePrincipalBytes(principal) {\n const bytesArray = [];\n bytesArray.push(principal.prefix);\n if (principal.prefix === PostConditionPrincipalId.Standard \|\|\n principal.prefix === PostConditionPrincipalId.Contract) {\n bytesArray.push(serializeAddressBytes(principal.address));\n }\n if (principal.prefix === PostConditionPrincipalId.Contract) {\n bytesArray.push(serializeLPStringBytes(principal.contractName));\n }\n return concatArray(bytesArray);\n}\nexport function deserializePrincipal(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const prefix = bytesReader.readUInt8Enum(PostConditionPrincipalId, n => {\n throw new DeserializationError(`Unexpected Principal payload type: ${n}`);\n });\n if (prefix === PostConditionPrincipalId.Origin) {\n return { type: StacksWireType.Principal, prefix };\n }\n const address = deserializeAddress(bytesReader);\n if (prefix === PostConditionPrincipalId.Standard) {\n return { type: StacksWireType.Principal, prefix, address };\n }\n const contractName = deserializeLPString(bytesReader);\n return {\n type: StacksWireType.Principal,\n prefix,\n address,\n contractName,\n };\n}\nexport function serializeLPString(lps) {\n return bytesToHex(serializeLPStringBytes(lps));\n}\nexport function serializeLPStringBytes(lps) {\n const bytesArray = [];\n const contentBytes = utf8ToBytes(lps.content);\n const length = contentBytes.byteLength;\n bytesArray.push(hexToBytes(intToHex(length, lps.lengthPrefixBytes)));\n bytesArray.push(contentBytes);\n return concatArray(bytesArray);\n}\nexport function deserializeLPString(serialized, prefixBytes, maxLength) {\n prefixBytes = prefixBytes ? prefixBytes : 1;\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const length = hexToInt(bytesToHex(bytesReader.readBytes(prefixBytes)));\n const content = bytesToUtf8(bytesReader.readBytes(length));\n return createLPString(content, prefixBytes, maxLength ?? 128);\n}\nexport function serializeMemoString(memoString) {\n return bytesToHex(serializeMemoStringBytes(memoString));\n}\nexport function serializeMemoStringBytes(memoString) {\n const bytesArray = [];\n const contentBytes = utf8ToBytes(memoString.content);\n const paddedContent = rightPadHexToLength(bytesToHex(contentBytes), MEMO_MAX_LENGTH_BYTES 2);\n bytesArray.push(hexToBytes(paddedContent));\n return concatArray(bytesArray);\n}\nexport function deserializeMemoString(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n let content = bytesToUtf8(bytesReader.readBytes(MEMO_MAX_LENGTH_BYTES));\n content = content.replace(/\\u0000$/, '');\n return { type: StacksWireType.MemoString, content };\n}\nexport function serializeAsset(info) {\n return bytesToHex(serializeAssetBytes(info));\n}\nexport function serializeAssetBytes(info) {\n const bytesArray = [];\n bytesArray.push(serializeAddressBytes(info.address));\n bytesArray.push(serializeLPStringBytes(info.contractName));\n bytesArray.push(serializeLPStringBytes(info.assetName));\n return concatArray(bytesArray);\n}\nexport function deserializeAsset(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n return {\n type: StacksWireType.Asset,\n address: deserializeAddress(bytesReader),\n contractName: deserializeLPString(bytesReader),\n assetName: deserializeLPString(bytesReader),\n };\n}\nexport function serializeLPList(lpList) {\n return bytesToHex(serializeLPListBytes(lpList));\n}\nexport function serializeLPListBytes(lpList) {\n const list = lpList.values;\n const bytesArray = [];\n bytesArray.push(hexToBytes(intToHex(list.length, lpList.lengthPrefixBytes)));\n for (const l of list) {\n bytesArray.push(serializeStacksWireBytes(l));\n }\n return concatArray(bytesArray);\n}\nexport function deserializeLPList(serialized, type, lengthPrefixBytes) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const length = hexToInt(bytesToHex(bytesReader.readBytes(lengthPrefixBytes \|\| 4)));\n const l = [];\n for (let index = 0; index < length; index++) {\n switch (type) {\n case StacksWireType.Address:\n l.push(deserializeAddress(bytesReader));\n break;\n case StacksWireType.LengthPrefixedString:\n l.push(deserializeLPString(bytesReader));\n break;\n case StacksWireType.MemoString:\n l.push(deserializeMemoString(bytesReader));\n break;\n case StacksWireType.Asset:\n l.push(deserializeAsset(bytesReader));\n break;\n case StacksWireType.PostCondition:\n l.push(deserializePostConditionWire(bytesReader));\n break;\n case StacksWireType.PublicKey:\n l.push(deserializePublicKey(bytesReader));\n break;\n case StacksWireType.TransactionAuthField:\n l.push(deserializeTransactionAuthField(bytesReader));\n break;\n }\n }\n return createLPList(l, lengthPrefixBytes);\n}\nexport function serializePostConditionWire(postCondition) {\n return bytesToHex(serializePostConditionWireBytes(postCondition));\n}\nexport function serializePostConditionWireBytes(postCondition) {\n const bytesArray = [];\n bytesArray.push(postCondition.conditionType);\n bytesArray.push(serializePrincipalBytes(postCondition.principal));\n if (postCondition.conditionType === PostConditionType.Fungible \|\|\n postCondition.conditionType === PostConditionType.NonFungible) {\n bytesArray.push(serializeAssetBytes(postCondition.asset));\n }\n if (postCondition.conditionType === PostConditionType.NonFungible) {\n bytesArray.push(serializeCVBytes(postCondition.assetName));\n }\n bytesArray.push(postCondition.conditionCode);\n if (postCondition.conditionType === PostConditionType.STX \|\|\n postCondition.conditionType === PostConditionType.Fungible) {\n if (postCondition.amount > BigInt('0xffffffffffffffff'))\n throw new SerializationError('The post-condition amount may not be larger than 8 bytes');\n bytesArray.push(intToBytes(postCondition.amount, 8));\n }\n return concatArray(bytesArray);\n}\nexport function deserializePostConditionWire(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const postConditionType = bytesReader.readUInt8Enum(PostConditionType, n => {\n throw new DeserializationError(`Could not read ${n} as PostConditionType`);\n });\n const principal = deserializePrincipal(bytesReader);\n let conditionCode;\n let asset;\n let amount;\n switch (postConditionType) {\n case PostConditionType.STX:\n conditionCode = bytesReader.readUInt8Enum(FungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n amount = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.STX,\n principal,\n conditionCode,\n amount,\n };\n case PostConditionType.Fungible:\n asset = deserializeAsset(bytesReader);\n conditionCode = bytesReader.readUInt8Enum(FungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n amount = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.Fungible,\n principal,\n conditionCode,\n amount,\n asset: asset,\n };\n case PostConditionType.NonFungible:\n asset = deserializeAsset(bytesReader);\n const assetName = deserializeCV(bytesReader);\n conditionCode = bytesReader.readUInt8Enum(NonFungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.NonFungible,\n principal,\n conditionCode,\n asset,\n assetName,\n };\n }\n}\nexport function serializePayload(payload) {\n return bytesToHex(serializePayloadBytes(payload));\n}\nexport function serializePayloadBytes(payload) {\n const bytesArray = [];\n bytesArray.push(payload.payloadType);\n switch (payload.payloadType) {\n case PayloadType.TokenTransfer:\n bytesArray.push(serializeCVBytes(payload.recipient));\n bytesArray.push(intToBytes(payload.amount, 8));\n bytesArray.push(serializeStacksWireBytes(payload.memo));\n break;\n case PayloadType.ContractCall:\n bytesArray.push(serializeStacksWireBytes(payload.contractAddress));\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.functionName));\n const numArgs = new Uint8Array(4);\n writeUInt32BE(numArgs, payload.functionArgs.length, 0);\n bytesArray.push(numArgs);\n payload.functionArgs.forEach(arg => {\n bytesArray.push(serializeCVBytes(arg));\n });\n break;\n case PayloadType.SmartContract:\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.codeBody));\n break;\n case PayloadType.VersionedSmartContract:\n bytesArray.push(payload.clarityVersion);\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.codeBody));\n break;\n case PayloadType.PoisonMicroblock:\n break;\n case PayloadType.Coinbase:\n bytesArray.push(payload.coinbaseBytes);\n break;\n case PayloadType.CoinbaseToAltRecipient:\n bytesArray.push(payload.coinbaseBytes);\n bytesArray.push(serializeCVBytes(payload.recipient));\n break;\n case PayloadType.NakamotoCoinbase:\n bytesArray.push(payload.coinbaseBytes);\n bytesArray.push(serializeCVBytes(payload.recipient ? someCV(payload.recipient) : noneCV()));\n bytesArray.push(payload.vrfProof);\n break;\n case PayloadType.TenureChange:\n bytesArray.push(hexToBytes(payload.tenureHash));\n bytesArray.push(hexToBytes(payload.previousTenureHash));\n bytesArray.push(hexToBytes(payload.burnViewHash));\n bytesArray.push(hexToBytes(payload.previousTenureEnd));\n bytesArray.push(writeUInt32BE(new Uint8Array(4), payload.previousTenureBlocks));\n bytesArray.push(writeUInt8(new Uint8Array(1), payload.cause));\n bytesArray.push(hexToBytes(payload.publicKeyHash));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function deserializePayload(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const payloadType = bytesReader.readUInt8Enum(PayloadType, n => {\n throw new Error(`Cannot recognize PayloadType: ${n}`);\n });\n switch (payloadType) {\n case PayloadType.TokenTransfer:\n const recipient = deserializeCV(bytesReader);\n const amount = intToBigInt(bytesReader.readBytes(8));\n const memo = deserializeMemoString(bytesReader);\n return createTokenTransferPayload(recipient, amount, memo);\n case PayloadType.ContractCall:\n const contractAddress = deserializeAddress(bytesReader);\n const contractCallName = deserializeLPString(bytesReader);\n const functionName = deserializeLPString(bytesReader);\n const functionArgs = [];\n const numberOfArgs = bytesReader.readUInt32BE();\n for (let i = 0; i < numberOfArgs; i++) {\n const clarityValue = deserializeCV(bytesReader);\n functionArgs.push(clarityValue);\n }\n return createContractCallPayload(contractAddress, contractCallName, functionName, functionArgs);\n case PayloadType.SmartContract:\n const smartContractName = deserializeLPString(bytesReader);\n const codeBody = deserializeLPString(bytesReader, 4, 100000);\n return createSmartContractPayload(smartContractName, codeBody);\n case PayloadType.VersionedSmartContract: {\n const clarityVersion = bytesReader.readUInt8Enum(ClarityVersion, n => {\n throw new Error(`Cannot recognize ClarityVersion: ${n}`);\n });\n const smartContractName = deserializeLPString(bytesReader);\n const codeBody = deserializeLPString(bytesReader, 4, STRING_MAX_LENGTH);\n return createSmartContractPayload(smartContractName, codeBody, clarityVersion);\n }\n case PayloadType.PoisonMicroblock:\n return createPoisonPayload();\n case PayloadType.Coinbase: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n return createCoinbasePayload(coinbaseBytes);\n }\n case PayloadType.CoinbaseToAltRecipient: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n const altRecipient = deserializeCV(bytesReader);\n return createCoinbasePayload(coinbaseBytes, altRecipient);\n }\n case PayloadType.NakamotoCoinbase: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n const recipient = deserializeCV(bytesReader);\n const vrfProof = bytesReader.readBytes(VRF_PROOF_BYTES_LENGTH);\n return createNakamotoCoinbasePayload(coinbaseBytes, recipient, vrfProof);\n }\n case PayloadType.TenureChange:\n const tenureHash = bytesToHex(bytesReader.readBytes(20));\n const previousTenureHash = bytesToHex(bytesReader.readBytes(20));\n const burnViewHash = bytesToHex(bytesReader.readBytes(20));\n const previousTenureEnd = bytesToHex(bytesReader.readBytes(32));\n const previousTenureBlocks = bytesReader.readUInt32BE();\n const cause = bytesReader.readUInt8Enum(TenureChangeCause, n => {\n throw new Error(`Cannot recognize TenureChangeCause: ${n}`);\n });\n const publicKeyHash = bytesToHex(bytesReader.readBytes(20));\n return createTenureChangePayload(tenureHash, previousTenureHash, burnViewHash, previousTenureEnd, previousTenureBlocks, cause, publicKeyHash);\n }\n}\nexport function deserializeMessageSignature(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n return createMessageSignature(bytesToHex(bytesReader.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES)));\n}\nexport function deserializeTransactionAuthField(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const authFieldType = bytesReader.readUInt8Enum(AuthFieldType, n => {\n throw new DeserializationError(`Could not read ${n} as AuthFieldType`);\n });\n switch (authFieldType) {\n case AuthFieldType.PublicKeyCompressed:\n return createTransactionAuthField(PubKeyEncoding.Compressed, deserializePublicKey(bytesReader));\n case AuthFieldType.PublicKeyUncompressed:\n return createTransactionAuthField(PubKeyEncoding.Uncompressed, createStacksPublicKey(uncompressPublicKey(deserializePublicKey(bytesReader).data)));\n case AuthFieldType.SignatureCompressed:\n return createTransactionAuthField(PubKeyEncoding.Compressed, deserializeMessageSignature(bytesReader));\n case AuthFieldType.SignatureUncompressed:\n return createTransactionAuthField(PubKeyEncoding.Uncompressed, deserializeMessageSignature(bytesReader));\n default:\n throw new Error(`Unknown auth field type: ${JSON.stringify(authFieldType)}`);\n }\n}\nexport function serializeMessageSignature(messageSignature) {\n return bytesToHex(serializeMessageSignatureBytes(messageSignature));\n}\nexport function serializeMessageSignatureBytes(messageSignature) {\n return hexToBytes(messageSignature.data);\n}\nexport function serializeTransactionAuthField(field) {\n return bytesToHex(serializeTransactionAuthFieldBytes(field));\n}\nexport function serializeTransactionAuthFieldBytes(field) {\n const bytesArray = [];\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n bytesArray.push(field.pubKeyEncoding === PubKeyEncoding.Compressed\n ? AuthFieldType.PublicKeyCompressed\n : AuthFieldType.PublicKeyUncompressed);\n bytesArray.push(hexToBytes(compressPublicKey(field.contents.data)));\n break;\n case StacksWireType.MessageSignature:\n bytesArray.push(field.pubKeyEncoding === PubKeyEncoding.Compressed\n ? AuthFieldType.SignatureCompressed\n : AuthFieldType.SignatureUncompressed);\n bytesArray.push(serializeMessageSignatureBytes(field.contents));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function serializePublicKey(key) {\n return bytesToHex(serializePublicKeyBytes(key));\n}\nexport function serializePublicKeyBytes(key) {\n return key.data.slice();\n}\nexport function deserializePublicKey(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const fieldId = bytesReader.readUInt8();\n const keyLength = fieldId === 4 ? UNCOMPRESSED_PUBKEY_LENGTH_BYTES : COMPRESSED_PUBKEY_LENGTH_BYTES;\n return createStacksPublicKey(concatArray([fieldId, bytesReader.readBytes(keyLength)]));\n}\n//# sourceMappingURL=serialization.js.map","import { bytesToHex, concatArray, hexToBytes, intToBigInt, intToBytes, writeUInt16BE, } from '@stacks/common';\nimport { AddressHashMode, AuthType, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, } from './constants';\nimport { DeserializationError, SigningError, VerificationError } from './errors';\nimport { createStacksPublicKey, privateKeyToPublic, publicKeyFromSignatureVrs, publicKeyIsCompressed, signWithKey, } from './keys';\nimport { cloneDeep, leftPadHex, txidFromData } from './utils';\nimport { addressFromPublicKeys, createEmptyAddress, createLPList, deserializeLPList, deserializeMessageSignature, serializeLPListBytes, serializeMessageSignatureBytes, StacksWireType, } from './wire';\nexport function emptyMessageSignature() {\n return {\n type: StacksWireType.MessageSignature,\n data: bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES)),\n };\n}\nexport function createSpendingCondition(options) {\n if ('publicKey' in options) {\n return createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n return createMultiSigSpendingCondition(AddressHashMode.P2SH, options.numSignatures, options.publicKeys, options.nonce, options.fee);\n}\nexport function createSingleSigSpendingCondition(hashMode, pubKey, nonce, fee) {\n const signer = addressFromPublicKeys(0, hashMode, 1, [createStacksPublicKey(pubKey)]).hash160;\n const keyEncoding = publicKeyIsCompressed(pubKey)\n ? PubKeyEncoding.Compressed\n : PubKeyEncoding.Uncompressed;\n return {\n hashMode,\n signer,\n nonce: intToBigInt(nonce),\n fee: intToBigInt(fee),\n keyEncoding,\n signature: emptyMessageSignature(),\n };\n}\nexport function createMultiSigSpendingCondition(hashMode, numSigs, pubKeys, nonce, fee) {\n const stacksPublicKeys = pubKeys.map(createStacksPublicKey);\n const signer = addressFromPublicKeys(0, hashMode, numSigs, stacksPublicKeys).hash160;\n return {\n hashMode,\n signer,\n nonce: intToBigInt(nonce),\n fee: intToBigInt(fee),\n fields: [],\n signaturesRequired: numSigs,\n };\n}\nexport function isSingleSig(condition) {\n return 'signature' in condition;\n}\nexport function isSequentialMultiSig(hashMode) {\n return hashMode === AddressHashMode.P2SH \|\| hashMode === AddressHashMode.P2WSH;\n}\nexport function isNonSequentialMultiSig(hashMode) {\n return (hashMode === AddressHashMode.P2SHNonSequential \|\|\n hashMode === AddressHashMode.P2WSHNonSequential);\n}\nfunction clearCondition(condition) {\n const cloned = cloneDeep(condition);\n cloned.nonce = 0;\n cloned.fee = 0;\n if (isSingleSig(cloned)) {\n cloned.signature = emptyMessageSignature();\n }\n else {\n cloned.fields = [];\n }\n return {\n ...cloned,\n nonce: BigInt(0),\n fee: BigInt(0),\n };\n}\nexport function serializeSingleSigSpendingCondition(condition) {\n return bytesToHex(serializeSingleSigSpendingConditionBytes(condition));\n}\nexport function serializeSingleSigSpendingConditionBytes(condition) {\n const bytesArray = [\n condition.hashMode,\n hexToBytes(condition.signer),\n intToBytes(condition.nonce, 8),\n intToBytes(condition.fee, 8),\n condition.keyEncoding,\n serializeMessageSignatureBytes(condition.signature),\n ];\n return concatArray(bytesArray);\n}\nexport function serializeMultiSigSpendingCondition(condition) {\n return bytesToHex(serializeMultiSigSpendingConditionBytes(condition));\n}\nexport function serializeMultiSigSpendingConditionBytes(condition) {\n const bytesArray = [\n condition.hashMode,\n hexToBytes(condition.signer),\n intToBytes(condition.nonce, 8),\n intToBytes(condition.fee, 8),\n ];\n const fields = createLPList(condition.fields);\n bytesArray.push(serializeLPListBytes(fields));\n const numSigs = new Uint8Array(2);\n writeUInt16BE(numSigs, condition.signaturesRequired, 0);\n bytesArray.push(numSigs);\n return concatArray(bytesArray);\n}\nexport function deserializeSingleSigSpendingCondition(hashMode, bytesReader) {\n const signer = bytesToHex(bytesReader.readBytes(20));\n const nonce = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n const fee = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n const keyEncoding = bytesReader.readUInt8Enum(PubKeyEncoding, n => {\n throw new DeserializationError(`Could not parse ${n} as PubKeyEncoding`);\n });\n if (hashMode === AddressHashMode.P2WPKH && keyEncoding != PubKeyEncoding.Compressed) {\n throw new DeserializationError('Failed to parse singlesig spending condition: incomaptible hash mode and key encoding');\n }\n const signature = deserializeMessageSignature(bytesReader);\n return {\n hashMode,\n signer,\n nonce,\n fee,\n keyEncoding,\n signature,\n };\n}\nexport function deserializeMultiSigSpendingCondition(hashMode, bytesReader) {\n const signer = bytesToHex(bytesReader.readBytes(20));\n const nonce = BigInt('0x' + bytesToHex(bytesReader.readBytes(8)));\n const fee = BigInt('0x' + bytesToHex(bytesReader.readBytes(8)));\n const fields = deserializeLPList(bytesReader, StacksWireType.TransactionAuthField)\n .values;\n let haveUncompressed = false;\n let numSigs = 0;\n for (const field of fields) {\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n if (!publicKeyIsCompressed(field.contents.data))\n haveUncompressed = true;\n break;\n case StacksWireType.MessageSignature:\n if (field.pubKeyEncoding === PubKeyEncoding.Uncompressed)\n haveUncompressed = true;\n numSigs += 1;\n if (numSigs === 65536)\n throw new VerificationError('Failed to parse multisig spending condition: too many signatures');\n break;\n }\n }\n const signaturesRequired = bytesReader.readUInt16BE();\n if (haveUncompressed &&\n (hashMode === AddressHashMode.P2WSH \|\| hashMode === AddressHashMode.P2WSHNonSequential)) {\n throw new VerificationError('Uncompressed keys are not allowed in this hash mode');\n }\n return {\n hashMode,\n signer,\n nonce,\n fee,\n fields,\n signaturesRequired,\n };\n}\nexport function serializeSpendingCondition(condition) {\n return bytesToHex(serializeSpendingConditionBytes(condition));\n}\nexport function serializeSpendingConditionBytes(condition) {\n if (isSingleSig(condition))\n return serializeSingleSigSpendingConditionBytes(condition);\n return serializeMultiSigSpendingConditionBytes(condition);\n}\nexport function deserializeSpendingCondition(bytesReader) {\n const hashMode = bytesReader.readUInt8Enum(AddressHashMode, n => {\n throw new DeserializationError(`Could not parse ${n} as AddressHashMode`);\n });\n if (hashMode === AddressHashMode.P2PKH \|\| hashMode === AddressHashMode.P2WPKH) {\n return deserializeSingleSigSpendingCondition(hashMode, bytesReader);\n }\n else {\n return deserializeMultiSigSpendingCondition(hashMode, bytesReader);\n }\n}\nexport function sigHashPreSign(curSigHash, authType, fee, nonce) {\n const hashLength = 32 + 1 + 8 + 8;\n const sigHash = curSigHash +\n bytesToHex(new Uint8Array([authType])) +\n bytesToHex(intToBytes(fee, 8)) +\n bytesToHex(intToBytes(nonce, 8));\n if (hexToBytes(sigHash).byteLength !== hashLength) {\n throw Error('Invalid signature hash length');\n }\n return txidFromData(hexToBytes(sigHash));\n}\nfunction sigHashPostSign(curSigHash, pubKey, signature) {\n const hashLength = 32 + 1 + RECOVERABLE_ECDSA_SIG_LENGTH_BYTES;\n const pubKeyEncoding = publicKeyIsCompressed(pubKey.data)\n ? PubKeyEncoding.Compressed\n : PubKeyEncoding.Uncompressed;\n const sigHash = curSigHash + leftPadHex(pubKeyEncoding.toString(16)) + signature;\n const sigHashBytes = hexToBytes(sigHash);\n if (sigHashBytes.byteLength > hashLength) {\n throw Error('Invalid signature hash length');\n }\n return txidFromData(sigHashBytes);\n}\nexport function nextSignature(curSigHash, authType, fee, nonce, privateKey) {\n const sigHashPre = sigHashPreSign(curSigHash, authType, fee, nonce);\n const signature = signWithKey(privateKey, sigHashPre);\n const publicKey = createStacksPublicKey(privateKeyToPublic(privateKey));\n const nextSigHash = sigHashPostSign(sigHashPre, publicKey, signature);\n return {\n nextSig: signature,\n nextSigHash,\n };\n}\nexport function nextVerification(initialSigHash, authType, fee, nonce, pubKeyEncoding, signature) {\n const sigHashPre = sigHashPreSign(initialSigHash, authType, fee, nonce);\n const publicKey = createStacksPublicKey(publicKeyFromSignatureVrs(sigHashPre, signature, pubKeyEncoding));\n const nextSigHash = sigHashPostSign(sigHashPre, publicKey, signature);\n return {\n pubKey: publicKey,\n nextSigHash,\n };\n}\nfunction newInitialSigHash() {\n const spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, '', 0, 0);\n spendingCondition.signer = createEmptyAddress().hash160;\n spendingCondition.keyEncoding = PubKeyEncoding.Compressed;\n spendingCondition.signature = emptyMessageSignature();\n return spendingCondition;\n}\nfunction verify(condition, initialSigHash, authType) {\n if (isSingleSig(condition)) {\n return verifySingleSig(condition, initialSigHash, authType);\n }\n else {\n return verifyMultiSig(condition, initialSigHash, authType);\n }\n}\nfunction verifySingleSig(condition, initialSigHash, authType) {\n const { pubKey, nextSigHash } = nextVerification(initialSigHash, authType, condition.fee, condition.nonce, condition.keyEncoding, condition.signature.data);\n const addrBytes = addressFromPublicKeys(0, condition.hashMode, 1, [pubKey]).hash160;\n if (addrBytes !== condition.signer)\n throw new VerificationError(`Signer hash does not equal hash of public key(s): ${addrBytes} != ${condition.signer}`);\n return nextSigHash;\n}\nfunction verifyMultiSig(condition, initialSigHash, authType) {\n const publicKeys = [];\n let curSigHash = initialSigHash;\n let haveUncompressed = false;\n let numSigs = 0;\n for (const field of condition.fields) {\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n if (!publicKeyIsCompressed(field.contents.data))\n haveUncompressed = true;\n publicKeys.push(field.contents);\n break;\n case StacksWireType.MessageSignature:\n if (field.pubKeyEncoding === PubKeyEncoding.Uncompressed)\n haveUncompressed = true;\n const { pubKey, nextSigHash } = nextVerification(curSigHash, authType, condition.fee, condition.nonce, field.pubKeyEncoding, field.contents.data);\n if (isSequentialMultiSig(condition.hashMode)) {\n curSigHash = nextSigHash;\n }\n publicKeys.push(pubKey);\n numSigs += 1;\n if (numSigs === 65536)\n throw new VerificationError('Too many signatures');\n break;\n }\n }\n if ((isSequentialMultiSig(condition.hashMode) && numSigs !== condition.signaturesRequired) \|\|\n (isNonSequentialMultiSig(condition.hashMode) && numSigs < condition.signaturesRequired))\n throw new VerificationError('Incorrect number of signatures');\n if (haveUncompressed &&\n (condition.hashMode === AddressHashMode.P2WSH \|\|\n condition.hashMode === AddressHashMode.P2WSHNonSequential))\n throw new VerificationError('Uncompressed keys are not allowed in this hash mode');\n const addrBytes = addressFromPublicKeys(0, condition.hashMode, condition.signaturesRequired, publicKeys).hash160;\n if (addrBytes !== condition.signer)\n throw new VerificationError(`Signer hash does not equal hash of public key(s): ${addrBytes} != ${condition.signer}`);\n return curSigHash;\n}\nexport function createStandardAuth(spendingCondition) {\n return {\n authType: AuthType.Standard,\n spendingCondition,\n };\n}\nexport function createSponsoredAuth(spendingCondition, sponsorSpendingCondition) {\n return {\n authType: AuthType.Sponsored,\n spendingCondition,\n sponsorSpendingCondition: sponsorSpendingCondition\n ? sponsorSpendingCondition\n : createSingleSigSpendingCondition(AddressHashMode.P2PKH, '0'.repeat(66), 0, 0),\n };\n}\nexport function intoInitialSighashAuth(auth) {\n if (auth.spendingCondition) {\n switch (auth.authType) {\n case AuthType.Standard:\n return createStandardAuth(clearCondition(auth.spendingCondition));\n case AuthType.Sponsored:\n return createSponsoredAuth(clearCondition(auth.spendingCondition), newInitialSigHash());\n default:\n throw new SigningError('Unexpected authorization type for signing');\n }\n }\n throw new Error('Authorization missing SpendingCondition');\n}\nexport function verifyOrigin(auth, initialSigHash) {\n switch (auth.authType) {\n case AuthType.Standard:\n return verify(auth.spendingCondition, initialSigHash, AuthType.Standard);\n case AuthType.Sponsored:\n return verify(auth.spendingCondition, initialSigHash, AuthType.Standard);\n default:\n throw new SigningError('Invalid origin auth type');\n }\n}\nexport function setFee(auth, amount) {\n switch (auth.authType) {\n case AuthType.Standard:\n const spendingCondition = {\n ...auth.spendingCondition,\n fee: intToBigInt(amount),\n };\n return { ...auth, spendingCondition };\n case AuthType.Sponsored:\n const sponsorSpendingCondition = {\n ...auth.sponsorSpendingCondition,\n fee: intToBigInt(amount),\n };\n return { ...auth, sponsorSpendingCondition };\n }\n}\nexport function getFee(auth) {\n switch (auth.authType) {\n case AuthType.Standard:\n return auth.spendingCondition.fee;\n case AuthType.Sponsored:\n return auth.sponsorSpendingCondition.fee;\n }\n}\nexport function setNonce(auth, nonce) {\n const spendingCondition = {\n ...auth.spendingCondition,\n nonce: intToBigInt(nonce),\n };\n return {\n ...auth,\n spendingCondition,\n };\n}\nexport function setSponsorNonce(auth, nonce) {\n const sponsorSpendingCondition = {\n ...auth.sponsorSpendingCondition,\n nonce: intToBigInt(nonce),\n };\n return {\n ...auth,\n sponsorSpendingCondition,\n };\n}\nexport function setSponsor(auth, sponsorSpendingCondition) {\n const sc = {\n ...sponsorSpendingCondition,\n nonce: intToBigInt(sponsorSpendingCondition.nonce),\n fee: intToBigInt(sponsorSpendingCondition.fee),\n };\n return {\n ...auth,\n sponsorSpendingCondition: sc,\n };\n}\nexport function serializeAuthorization(auth) {\n return bytesToHex(serializeAuthorizationBytes(auth));\n}\nexport function serializeAuthorizationBytes(auth) {\n const bytesArray = [];\n bytesArray.push(auth.authType);\n switch (auth.authType) {\n case AuthType.Standard:\n bytesArray.push(serializeSpendingConditionBytes(auth.spendingCondition));\n break;\n case AuthType.Sponsored:\n bytesArray.push(serializeSpendingConditionBytes(auth.spendingCondition));\n bytesArray.push(serializeSpendingConditionBytes(auth.sponsorSpendingCondition));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function deserializeAuthorization(bytesReader) {\n const authType = bytesReader.readUInt8Enum(AuthType, n => {\n throw new DeserializationError(`Could not parse ${n} as AuthType`);\n });\n let spendingCondition;\n switch (authType) {\n case AuthType.Standard:\n spendingCondition = deserializeSpendingCondition(bytesReader);\n return createStandardAuth(spendingCondition);\n case AuthType.Sponsored:\n spendingCondition = deserializeSpendingCondition(bytesReader);\n const sponsorSpendingCondition = deserializeSpendingCondition(bytesReader);\n return createSponsoredAuth(spendingCondition, sponsorSpendingCondition);\n }\n}\n//# sourceMappingURL=authorization.js.map","import { bytesToHex, concatArray, intToBigInt, isInstance, writeUInt32BE, } from '@stacks/common';\nimport { STACKS_MAINNET, STACKS_TESTNET, TransactionVersion, networkFrom, whenTransactionVersion, } from '@stacks/network';\nimport { serializePayloadBytes } from '.';\nimport { BytesReader } from './BytesReader';\nimport { deserializeAuthorization, intoInitialSighashAuth, isSingleSig, nextSignature, serializeAuthorizationBytes, setFee, setNonce, setSponsor, setSponsorNonce, verifyOrigin, } from './authorization';\nimport { AddressHashMode, AnchorMode, AuthType, PostConditionMode, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, } from './constants';\nimport { SerializationError, SigningError } from './errors';\nimport { createStacksPublicKey, privateKeyIsCompressed, publicKeyIsCompressed } from './keys';\nimport { cloneDeep, txidFromData } from './utils';\nimport { StacksWireType, createLPList, createMessageSignature, createTransactionAuthField, deserializeLPList, deserializePayload, serializeLPListBytes, } from './wire';\nexport class StacksTransactionWire {\n constructor({ auth, payload, postConditions = createLPList([]), postConditionMode = PostConditionMode.Deny, transactionVersion, chainId, network = 'mainnet', }) {\n network = networkFrom(network);\n this.transactionVersion = transactionVersion ?? network.transactionVersion;\n this.chainId = chainId ?? network.chainId;\n this.auth = auth;\n if ('amount' in payload) {\n this.payload = {\n ...payload,\n amount: intToBigInt(payload.amount),\n };\n }\n else {\n this.payload = payload;\n }\n this.postConditionMode = postConditionMode;\n this.postConditions = postConditions;\n this.anchorMode = AnchorMode.Any;\n }\n signBegin() {\n const tx = cloneDeep(this);\n tx.auth = intoInitialSighashAuth(tx.auth);\n return tx.txid();\n }\n verifyBegin() {\n const tx = cloneDeep(this);\n tx.auth = intoInitialSighashAuth(tx.auth);\n return tx.txid();\n }\n verifyOrigin() {\n return verifyOrigin(this.auth, this.verifyBegin());\n }\n signNextOrigin(sigHash, privateKey) {\n if (this.auth.spendingCondition === undefined) {\n throw new Error('\"auth.spendingCondition\" is undefined');\n }\n if (this.auth.authType === undefined) {\n throw new Error('\"auth.authType\" is undefined');\n }\n return this.signAndAppend(this.auth.spendingCondition, sigHash, AuthType.Standard, privateKey);\n }\n signNextSponsor(sigHash, privateKey) {\n if (this.auth.authType === AuthType.Sponsored) {\n return this.signAndAppend(this.auth.sponsorSpendingCondition, sigHash, AuthType.Sponsored, privateKey);\n }\n else {\n throw new Error('\"auth.sponsorSpendingCondition\" is undefined');\n }\n }\n appendPubkey(publicKey) {\n const wire = typeof publicKey === 'object' && 'type' in publicKey\n ? publicKey\n : createStacksPublicKey(publicKey);\n const cond = this.auth.spendingCondition;\n if (cond && !isSingleSig(cond)) {\n const compressed = publicKeyIsCompressed(wire.data);\n cond.fields.push(createTransactionAuthField(compressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed, wire));\n }\n else {\n throw new Error(`Can't append public key to a singlesig condition`);\n }\n }\n signAndAppend(condition, curSigHash, authType, privateKey) {\n const { nextSig, nextSigHash } = nextSignature(curSigHash, authType, condition.fee, condition.nonce, privateKey);\n if (isSingleSig(condition)) {\n condition.signature = createMessageSignature(nextSig);\n }\n else {\n const compressed = privateKeyIsCompressed(privateKey);\n condition.fields.push(createTransactionAuthField(compressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed, createMessageSignature(nextSig)));\n }\n return nextSigHash;\n }\n txid() {\n const serialized = this.serializeBytes();\n return txidFromData(serialized);\n }\n setSponsor(sponsorSpendingCondition) {\n if (this.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot sponsor sign a non-sponsored transaction');\n }\n this.auth = setSponsor(this.auth, sponsorSpendingCondition);\n }\n setFee(amount) {\n this.auth = setFee(this.auth, amount);\n }\n setNonce(nonce) {\n this.auth = setNonce(this.auth, nonce);\n }\n setSponsorNonce(nonce) {\n if (this.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot sponsor sign a non-sponsored transaction');\n }\n this.auth = setSponsorNonce(this.auth, nonce);\n }\n serialize() {\n return bytesToHex(this.serializeBytes());\n }\n serializeBytes() {\n if (this.transactionVersion === undefined) {\n throw new SerializationError('\"transactionVersion\" is undefined');\n }\n if (this.chainId === undefined) {\n throw new SerializationError('\"chainId\" is undefined');\n }\n if (this.auth === undefined) {\n throw new SerializationError('\"auth\" is undefined');\n }\n if (this.payload === undefined) {\n throw new SerializationError('\"payload\" is undefined');\n }\n const bytesArray = [];\n bytesArray.push(this.transactionVersion);\n const chainIdBytes = new Uint8Array(4);\n writeUInt32BE(chainIdBytes, this.chainId, 0);\n bytesArray.push(chainIdBytes);\n bytesArray.push(serializeAuthorizationBytes(this.auth));\n bytesArray.push(this.anchorMode);\n bytesArray.push(this.postConditionMode);\n bytesArray.push(serializeLPListBytes(this.postConditions));\n bytesArray.push(serializePayloadBytes(this.payload));\n return concatArray(bytesArray);\n }\n}\nexport function deserializeTransaction(tx) {\n const bytesReader = isInstance(tx, BytesReader) ? tx : new BytesReader(tx);\n const transactionVersion = bytesReader.readUInt8Enum(TransactionVersion, n => {\n throw new Error(`Could not parse ${n} as TransactionVersion`);\n });\n const chainId = bytesReader.readUInt32BE();\n const auth = deserializeAuthorization(bytesReader);\n const anchorMode = bytesReader.readUInt8Enum(AnchorMode, n => {\n throw new Error(`Could not parse ${n} as AnchorMode`);\n });\n const postConditionMode = bytesReader.readUInt8Enum(PostConditionMode, n => {\n throw new Error(`Could not parse ${n} as PostConditionMode`);\n });\n const postConditions = deserializeLPList(bytesReader, StacksWireType.PostCondition);\n const payload = deserializePayload(bytesReader);\n const transaction = new StacksTransactionWire({\n transactionVersion,\n chainId,\n auth,\n payload,\n postConditions,\n postConditionMode,\n });\n transaction.anchorMode = anchorMode;\n return transaction;\n}\nexport function deriveNetworkFromTx(transaction) {\n return whenTransactionVersion(transaction.transactionVersion)({\n [TransactionVersion.Mainnet]: STACKS_MAINNET,\n [TransactionVersion.Testnet]: STACKS_TESTNET,\n });\n}\nexport function estimateTransactionByteLength(transaction) {\n const hashMode = transaction.auth.spendingCondition.hashMode;\n const multiSigHashModes = [AddressHashMode.P2SH, AddressHashMode.P2WSH];\n if (multiSigHashModes.includes(hashMode)) {\n const multiSigSpendingCondition = transaction.auth\n .spendingCondition;\n const existingSignatures = multiSigSpendingCondition.fields.filter(field => field.contents.type === StacksWireType.MessageSignature).length;\n const totalSignatureLength = (multiSigSpendingCondition.signaturesRequired - existingSignatures) \n (RECOVERABLE_ECDSA_SIG_LENGTH_BYTES + 1);\n return transaction.serializeBytes().byteLength + totalSignatureLength;\n }\n else {\n return transaction.serializeBytes().byteLength;\n }\n}\nexport function serializeTransaction(transaction) {\n return transaction.serialize();\n}\nexport function serializeTransactionBytes(transaction) {\n return transaction.serializeBytes();\n}\nexport function transactionToHex(transaction) {\n return transaction.serialize();\n}\n//# sourceMappingURL=transaction.js.map","import { bytesToHex, validateHash256, with0x } from '@stacks/common';\nimport { clientFromNetwork, networkFrom } from '@stacks/network';\nimport { deserializeCV, serializeCV } from './clarity';\nimport { NoEstimateAvailableError } from './errors';\nimport { deriveNetworkFromTx, estimateTransactionByteLength, } from './transaction';\nimport { cvToHex, parseReadOnlyResponse } from './utils';\nimport { serializePayloadBytes } from './wire';\nexport const BROADCAST_PATH = '/v2/transactions';\nexport const TRANSFER_FEE_ESTIMATE_PATH = '/v2/fees/transfer';\nexport const TRANSACTION_FEE_ESTIMATE_PATH = '/v2/fees/transaction';\nexport const ACCOUNT_PATH = '/v2/accounts';\nexport const CONTRACT_ABI_PATH = '/v2/contracts/interface';\nexport const READONLY_FUNCTION_CALL_PATH = '/v2/contracts/call-read';\nexport const MAP_ENTRY_PATH = '/v2/map_entry';\nexport async function broadcastTransaction({ transaction: txOpt, attachment: attachOpt, network: _network, client: _client, }) {\n const tx = txOpt.serialize();\n const attachment = attachOpt\n ? typeof attachOpt === 'string'\n ? attachOpt\n : bytesToHex(attachOpt)\n : undefined;\n const json = attachOpt ? { tx, attachment } : { tx };\n const options = {\n method: 'POST',\n headers: { 'Content-Type': 'application/json' },\n body: JSON.stringify(json),\n };\n const network = _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${BROADCAST_PATH}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n try {\n return (await response.json());\n }\n catch (e) {\n throw Error('Failed to broadcast transaction (unable to parse node response).', { cause: e });\n }\n }\n const text = await response.text();\n const txid = text.replace(/[\"]+/g, '');\n if (!validateHash256(txid))\n throw new Error(text);\n return { txid };\n}\nasync function _getNonceApi({ address, network = 'mainnet', client: _client, }) {\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}/extended/v1/address/${address}/nonces`;\n const response = await client.fetch(url);\n const result = await response.json();\n return BigInt(result.possible_next_nonce);\n}\nexport async function fetchNonce(opts) {\n try {\n return await _getNonceApi(opts);\n }\n catch (e) { }\n const network = networkFrom(opts.network ?? 'mainnet');\n const client = Object.assign({}, clientFromNetwork(network), opts.client);\n const url = `${client.baseUrl}${ACCOUNT_PATH}/${opts.address}?proof=0`;\n const response = await client.fetch(url);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching nonce. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const json = (await response.json());\n return BigInt(json.nonce);\n}\nexport async function fetchFeeEstimateTransfer({ transaction: txOpt, network: _network, client: _client, }) {\n const network = typeof txOpt === 'number' ? 'mainnet' : _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${TRANSFER_FEE_ESTIMATE_PATH}`;\n const response = await client.fetch(url, {\n headers: { Accept: 'application/text' },\n });\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error estimating transfer fee. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const feeRateResult = await response.text();\n const txBytes = typeof txOpt === 'number'\n ? BigInt(txOpt)\n : BigInt(Math.ceil(txOpt.serializeBytes().byteLength));\n const feeRate = BigInt(feeRateResult);\n return feeRate * txBytes;\n}\nexport async function fetchFeeEstimateTransaction({ payload, estimatedLength, network = 'mainnet', client: _client, }) {\n const json = {\n transaction_payload: payload,\n estimated_len: estimatedLength,\n };\n const options = {\n method: 'POST',\n headers: { 'Content-Type': 'application/json' },\n body: JSON.stringify(json),\n };\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${TRANSACTION_FEE_ESTIMATE_PATH}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const body = await response.text().catch(() => '');\n if (body.includes('NoEstimateAvailable')) {\n let json = {};\n try {\n json = JSON.parse(body);\n }\n catch (err) {\n }\n throw new NoEstimateAvailableError(json?.reason_data?.message ?? '');\n }\n throw new Error(`Error estimating transaction fee. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${body}\"`);\n }\n const data = await response.json();\n return data.estimations;\n}\nexport async function fetchFeeEstimate({ transaction: txOpt, network: _network, client: _client, }) {\n const network = _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n try {\n const estimatedLength = estimateTransactionByteLength(txOpt);\n return (await fetchFeeEstimateTransaction({\n payload: bytesToHex(serializePayloadBytes(txOpt.payload)),\n estimatedLength,\n network,\n client,\n }))[1].fee;\n }\n catch (error) {\n if (!(error instanceof NoEstimateAvailableError))\n throw error;\n return await fetchFeeEstimateTransfer({ transaction: txOpt, network });\n }\n}\nexport async function fetchAbi({ contractAddress: address, contractName: name, network = 'mainnet', client: _client, }) {\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${CONTRACT_ABI_PATH}/${address}/${name}`;\n const response = await client.fetch(url);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching contract ABI for contract \"${name}\" at address ${address}. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n return JSON.parse(await response.text());\n}\nexport async function fetchCallReadOnlyFunction({ contractName, contractAddress, functionName, functionArgs, senderAddress, network = 'mainnet', client: _client, }) {\n const json = {\n sender: senderAddress,\n arguments: functionArgs.map(arg => cvToHex(arg)),\n };\n const options = {\n method: 'POST',\n headers: {\n 'Content-Type': 'application/json',\n },\n body: JSON.stringify(json),\n };\n const name = encodeURIComponent(functionName);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${READONLY_FUNCTION_CALL_PATH}/${contractAddress}/${contractName}/${name}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error calling read-only function. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n return await response.json().then(parseReadOnlyResponse);\n}\nexport async function fetchContractMapEntry({ contractAddress, contractName, mapName, mapKey, network = 'mainnet', client: _client, }) {\n const keyHex = with0x(serializeCV(mapKey));\n const options = {\n method: 'POST',\n headers: {\n Accept: 'application/json',\n 'Content-Type': 'application/json',\n },\n body: JSON.stringify(keyHex),\n };\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${MAP_ENTRY_PATH}/${contractAddress}/${contractName}/${mapName}?proof=0`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching map entry for map \"${mapName}\" in contract \"${contractName}\" at address ${contractAddress}, using map key \"${keyHex}\". Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const json = await response.json();\n if (!json.data) {\n throw new Error(`Error fetching map entry for map \"${mapName}\" in contract \"${contractName}\" at address ${contractAddress}, using map key \"${keyHex}\". Response ${response.status}: ${response.statusText}. Attempted to fetch ${client.baseUrl} and failed with the response: \"${JSON.stringify(json)}\"`);\n }\n try {\n return deserializeCV(json.data);\n }\n catch (error) {\n throw new Error(`Error deserializing Clarity value \"${json.data}\": ${error}`);\n }\n}\n//# sourceMappingURL=fetch.js.map","import { ClarityType } from './constants';\nimport { asciiToBytes, bytesToAscii, hexToBytes, utf8ToBytes } from '@stacks/common';\nexport function cvToString(val, encoding = 'hex') {\n switch (val.type) {\n case ClarityType.BoolTrue:\n return 'true';\n case ClarityType.BoolFalse:\n return 'false';\n case ClarityType.Int:\n return val.value.toString();\n case ClarityType.UInt:\n return `u${val.value.toString()}`;\n case ClarityType.Buffer:\n if (encoding === 'tryAscii') {\n const str = bytesToAscii(hexToBytes(val.value));\n if (/[ -~]/.test(str)) {\n return JSON.stringify(str);\n }\n }\n return `0x${val.value}`;\n case ClarityType.OptionalNone:\n return 'none';\n case ClarityType.OptionalSome:\n return `(some ${cvToString(val.value, encoding)})`;\n case ClarityType.ResponseErr:\n return `(err ${cvToString(val.value, encoding)})`;\n case ClarityType.ResponseOk:\n return `(ok ${cvToString(val.value, encoding)})`;\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return val.value;\n case ClarityType.List:\n return `(list ${val.value.map(v => cvToString(v, encoding)).join(' ')})`;\n case ClarityType.Tuple:\n return `(tuple ${Object.keys(val.value)\n .map(key => `(${key} ${cvToString(val.value[key], encoding)})`)\n .join(' ')})`;\n case ClarityType.StringASCII:\n return `\"${val.value}\"`;\n case ClarityType.StringUTF8:\n return `u\"${val.value}\"`;\n }\n}\nexport function cvToValue(val, strictJsonCompat = false) {\n switch (val.type) {\n case ClarityType.BoolTrue:\n return true;\n case ClarityType.BoolFalse:\n return false;\n case ClarityType.Int:\n case ClarityType.UInt:\n if (strictJsonCompat) {\n return val.value.toString();\n }\n return val.value;\n case ClarityType.Buffer:\n return `0x${val.value}`;\n case ClarityType.OptionalNone:\n return null;\n case ClarityType.OptionalSome:\n return cvToJSON(val.value);\n case ClarityType.ResponseErr:\n return cvToJSON(val.value);\n case ClarityType.ResponseOk:\n return cvToJSON(val.value);\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return val.value;\n case ClarityType.List:\n return val.value.map(v => cvToJSON(v));\n case ClarityType.Tuple:\n const result = {};\n Object.keys(val.value).forEach(key => {\n result[key] = cvToJSON(val.value[key]);\n });\n return result;\n case ClarityType.StringASCII:\n return val.value;\n case ClarityType.StringUTF8:\n return val.value;\n }\n}\nexport function cvToJSON(val) {\n switch (val.type) {\n case ClarityType.ResponseErr:\n return { type: getCVTypeString(val), value: cvToValue(val, true), success: false };\n case ClarityType.ResponseOk:\n return { type: getCVTypeString(val), value: cvToValue(val, true), success: true };\n default:\n return { type: getCVTypeString(val), value: cvToValue(val, true) };\n }\n}\nexport function getCVTypeString(val) {\n switch (val.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return 'bool';\n case ClarityType.Int:\n return 'int';\n case ClarityType.UInt:\n return 'uint';\n case ClarityType.Buffer:\n return `(buff ${Math.ceil(val.value.length / 2)})`;\n case ClarityType.OptionalNone:\n return '(optional none)';\n case ClarityType.OptionalSome:\n return `(optional ${getCVTypeString(val.value)})`;\n case ClarityType.ResponseErr:\n return `(response UnknownType ${getCVTypeString(val.value)})`;\n case ClarityType.ResponseOk:\n return `(response ${getCVTypeString(val.value)} UnknownType)`;\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return 'principal';\n case ClarityType.List:\n return `(list ${val.value.length} ${val.value.length ? getCVTypeString(val.value[0]) : 'UnknownType'})`;\n case ClarityType.Tuple:\n return `(tuple ${Object.keys(val.value)\n .map(key => `(${key} ${getCVTypeString(val.value[key])})`)\n .join(' ')})`;\n case ClarityType.StringASCII:\n return `(string-ascii ${asciiToBytes(val.value).length})`;\n case ClarityType.StringUTF8:\n return `(string-utf8 ${utf8ToBytes(val.value).length})`;\n }\n}\nexport function isClarityType(input, withType) {\n return input.type === withType;\n}\n//# sourceMappingURL=clarityValue.js.map","import { hexToBytes, utf8ToBytes } from '@stacks/common';\nimport { ClarityType, bufferCV, bufferCVFromString, contractPrincipalCV, falseCV, getCVTypeString, intCV, noneCV, someCV, standardPrincipalCV, stringAsciiCV, stringUtf8CV, trueCV, uintCV, } from './clarity';\nimport { NotImplementedError } from './errors';\nimport { cloneDeep } from './utils';\nexport var ClarityAbiTypeId;\n(function (ClarityAbiTypeId) {\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeUInt128\"] = 1] = \"ClarityAbiTypeUInt128\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeInt128\"] = 2] = \"ClarityAbiTypeInt128\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeBool\"] = 3] = \"ClarityAbiTypeBool\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypePrincipal\"] = 4] = \"ClarityAbiTypePrincipal\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeNone\"] = 5] = \"ClarityAbiTypeNone\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeBuffer\"] = 6] = \"ClarityAbiTypeBuffer\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeResponse\"] = 7] = \"ClarityAbiTypeResponse\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeOptional\"] = 8] = \"ClarityAbiTypeOptional\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeTuple\"] = 9] = \"ClarityAbiTypeTuple\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeList\"] = 10] = \"ClarityAbiTypeList\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeStringAscii\"] = 11] = \"ClarityAbiTypeStringAscii\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeStringUtf8\"] = 12] = \"ClarityAbiTypeStringUtf8\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeTraitReference\"] = 13] = \"ClarityAbiTypeTraitReference\";\n})(ClarityAbiTypeId \|\| (ClarityAbiTypeId = {}));\nexport const isClarityAbiPrimitive = (val) => typeof val === 'string';\nexport const isClarityAbiBuffer = (val) => val.buffer !== undefined;\nexport const isClarityAbiStringAscii = (val) => val['string-ascii'] !== undefined;\nexport const isClarityAbiStringUtf8 = (val) => val['string-utf8'] !== undefined;\nexport const isClarityAbiResponse = (val) => val.response !== undefined;\nexport const isClarityAbiOptional = (val) => val.optional !== undefined;\nexport const isClarityAbiTuple = (val) => val.tuple !== undefined;\nexport const isClarityAbiList = (val) => val.list !== undefined;\nexport function getTypeUnion(val) {\n if (isClarityAbiPrimitive(val)) {\n if (val === 'uint128') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeUInt128, type: val };\n }\n else if (val === 'int128') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeInt128, type: val };\n }\n else if (val === 'bool') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeBool, type: val };\n }\n else if (val === 'principal') {\n return { id: ClarityAbiTypeId.ClarityAbiTypePrincipal, type: val };\n }\n else if (val === 'trait_reference') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeTraitReference, type: val };\n }\n else if (val === 'none') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeNone, type: val };\n }\n else {\n throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);\n }\n }\n else if (isClarityAbiBuffer(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeBuffer, type: val };\n }\n else if (isClarityAbiResponse(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeResponse, type: val };\n }\n else if (isClarityAbiOptional(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeOptional, type: val };\n }\n else if (isClarityAbiTuple(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeTuple, type: val };\n }\n else if (isClarityAbiList(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeList, type: val };\n }\n else if (isClarityAbiStringAscii(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeStringAscii, type: val };\n }\n else if (isClarityAbiStringUtf8(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeStringUtf8, type: val };\n }\n else {\n throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);\n }\n}\nexport function encodeAbiClarityValue(value, type) {\n const union = type.id\n ? type\n : getTypeUnion(type);\n switch (union.id) {\n case ClarityAbiTypeId.ClarityAbiTypeUInt128:\n return uintCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeInt128:\n return intCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeBool:\n if (value === 'false' \|\| value === '0')\n return falseCV();\n else if (value === 'true' \|\| value === '1')\n return trueCV();\n else\n throw new Error(`Unexpected Clarity bool value: ${JSON.stringify(value)}`);\n case ClarityAbiTypeId.ClarityAbiTypePrincipal:\n if (value.includes('.')) {\n const [addr, name] = value.split('.');\n return contractPrincipalCV(addr, name);\n }\n else {\n return standardPrincipalCV(value);\n }\n case ClarityAbiTypeId.ClarityAbiTypeTraitReference:\n const [addr, name] = value.split('.');\n return contractPrincipalCV(addr, name);\n case ClarityAbiTypeId.ClarityAbiTypeNone:\n return noneCV();\n case ClarityAbiTypeId.ClarityAbiTypeBuffer:\n return bufferCV(hexToBytes(value));\n case ClarityAbiTypeId.ClarityAbiTypeStringAscii:\n return stringAsciiCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeStringUtf8:\n return stringUtf8CV(value);\n case ClarityAbiTypeId.ClarityAbiTypeOptional:\n return someCV(encodeAbiClarityValue(value, union.type.optional));\n case ClarityAbiTypeId.ClarityAbiTypeResponse:\n case ClarityAbiTypeId.ClarityAbiTypeTuple:\n case ClarityAbiTypeId.ClarityAbiTypeList:\n throw new NotImplementedError(`Unsupported encoding for Clarity type: ${union.id}`);\n default:\n throw new Error(`Unexpected Clarity type ID: ${JSON.stringify(union)}`);\n }\n}\nexport function encodeClarityValue(type, value) {\n const union = type.id\n ? type\n : getTypeUnion(type);\n if (union.id === ClarityAbiTypeId.ClarityAbiTypeBuffer) {\n return bufferCV(utf8ToBytes(value));\n }\n return encodeAbiClarityValue(value, union);\n}\nexport function getTypeString(val) {\n if (isClarityAbiPrimitive(val)) {\n if (val === 'int128') {\n return 'int';\n }\n else if (val === 'uint128') {\n return 'uint';\n }\n return val;\n }\n else if (isClarityAbiBuffer(val)) {\n return `(buff ${val.buffer.length})`;\n }\n else if (isClarityAbiStringAscii(val)) {\n return `(string-ascii ${val['string-ascii'].length})`;\n }\n else if (isClarityAbiStringUtf8(val)) {\n return `(string-utf8 ${val['string-utf8'].length})`;\n }\n else if (isClarityAbiResponse(val)) {\n return `(response ${getTypeString(val.response.ok)} ${getTypeString(val.response.error)})`;\n }\n else if (isClarityAbiOptional(val)) {\n return `(optional ${getTypeString(val.optional)})`;\n }\n else if (isClarityAbiTuple(val)) {\n return `(tuple ${val.tuple.map(t => `(${t.name} ${getTypeString(t.type)})`).join(' ')})`;\n }\n else if (isClarityAbiList(val)) {\n return `(list ${val.list.length} ${getTypeString(val.list.type)})`;\n }\n else {\n throw new Error(`Type string unsupported for Clarity type: ${JSON.stringify(val)}`);\n }\n}\nexport function abiFunctionToString(func) {\n const access = func.access === 'read_only' ? 'read-only' : func.access;\n return `(define-${access} (${func.name} ${func.args\n .map(arg => `(${arg.name} ${getTypeString(arg.type)})`)\n .join(' ')}))`;\n}\nfunction matchType(cv, abiType) {\n const union = getTypeUnion(abiType);\n switch (cv.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeBool;\n case ClarityType.Int:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeInt128;\n case ClarityType.UInt:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeUInt128;\n case ClarityType.Buffer:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeBuffer &&\n union.type.buffer.length >= Math.ceil(cv.value.length / 2));\n case ClarityType.StringASCII:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeStringAscii &&\n union.type['string-ascii'].length >= cv.value.length);\n case ClarityType.StringUTF8:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeStringUtf8 &&\n union.type['string-utf8'].length >= cv.value.length);\n case ClarityType.OptionalNone:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeNone \|\|\n union.id === ClarityAbiTypeId.ClarityAbiTypeOptional);\n case ClarityType.OptionalSome:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeOptional &&\n matchType(cv.value, union.type.optional));\n case ClarityType.ResponseErr:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeResponse &&\n matchType(cv.value, union.type.response.error));\n case ClarityType.ResponseOk:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeResponse &&\n matchType(cv.value, union.type.response.ok));\n case ClarityType.PrincipalContract:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypePrincipal \|\|\n union.id === ClarityAbiTypeId.ClarityAbiTypeTraitReference);\n case ClarityType.PrincipalStandard:\n return union.id === ClarityAbiTypeId.ClarityAbiTypePrincipal;\n case ClarityType.List:\n return (union.id == ClarityAbiTypeId.ClarityAbiTypeList &&\n union.type.list.length >= cv.value.length &&\n cv.value.every(val => matchType(val, union.type.list.type)));\n case ClarityType.Tuple:\n if (union.id == ClarityAbiTypeId.ClarityAbiTypeTuple) {\n const tuple = cloneDeep(cv.value);\n for (let i = 0; i < union.type.tuple.length; i++) {\n const abiTupleEntry = union.type.tuple[i];\n const key = abiTupleEntry.name;\n const val = tuple[key];\n if (val) {\n if (!matchType(val, abiTupleEntry.type)) {\n return false;\n }\n delete tuple[key];\n }\n else {\n return false;\n }\n }\n return true;\n }\n else {\n return false;\n }\n default:\n return false;\n }\n}\nexport function validateContractCall(payload, abi) {\n const filtered = abi.functions.filter(fn => fn.name === payload.functionName.content);\n if (filtered.length === 1) {\n const abiFunc = filtered[0];\n const abiArgs = abiFunc.args;\n if (payload.functionArgs.length !== abiArgs.length) {\n throw new Error(`Clarity function expects ${abiArgs.length} argument(s) but received ${payload.functionArgs.length}`);\n }\n for (let i = 0; i < payload.functionArgs.length; i++) {\n const payloadArg = payload.functionArgs[i];\n const abiArg = abiArgs[i];\n if (!matchType(payloadArg, abiArg.type)) {\n const argNum = i + 1;\n throw new Error(`Clarity function \\`${payload.functionName.content}\\` expects argument ${argNum} to be of type ${getTypeString(abiArg.type)}, not ${getCVTypeString(payloadArg)}`);\n }\n }\n return true;\n }\n else if (filtered.length === 0) {\n throw new Error(`ABI doesn't contain a function with the name ${payload.functionName.content}`);\n }\n else {\n throw new Error(`Malformed ABI. Contains multiple functions with the name ${payload.functionName.content}`);\n }\n}\nexport function parseToCV(input, type) {\n const typeString = getTypeString(type);\n if (isClarityAbiPrimitive(type)) {\n if (type === 'uint128') {\n return uintCV(input);\n }\n else if (type === 'int128') {\n return intCV(input);\n }\n else if (type === 'bool') {\n if (input.toLowerCase() === 'true') {\n return trueCV();\n }\n else if (input.toLowerCase() === 'false') {\n return falseCV();\n }\n else {\n throw new Error(`Invalid bool value: ${input}`);\n }\n }\n else if (type === 'principal') {\n if (input.includes('.')) {\n const [address, contractName] = input.split('.');\n return contractPrincipalCV(address, contractName);\n }\n else {\n return standardPrincipalCV(input);\n }\n }\n else {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n }\n else if (isClarityAbiBuffer(type)) {\n const inputLength = utf8ToBytes(input).byteLength;\n if (inputLength > type.buffer.length) {\n throw new Error(`Input exceeds specified buffer length limit of ${type.buffer.length}`);\n }\n return bufferCVFromString(input);\n }\n else if (isClarityAbiResponse(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiOptional(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiTuple(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiList(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n}\n//# sourceMappingURL=contract-abi.js.map","import { PostConditionMode, PostConditionPrincipalId, PostConditionType, } from './constants';\nimport { StacksWireType, addressToString, parseAssetString, parsePrincipalString, serializePostConditionWire, } from './wire';\nvar PostConditionCodeWireType;\n(function (PostConditionCodeWireType) {\n PostConditionCodeWireType[PostConditionCodeWireType[\"eq\"] = 1] = \"eq\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"gt\"] = 2] = \"gt\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"lt\"] = 4] = \"lt\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"gte\"] = 3] = \"gte\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"lte\"] = 5] = \"lte\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"sent\"] = 16] = \"sent\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"not-sent\"] = 17] = \"not-sent\";\n})(PostConditionCodeWireType \|\| (PostConditionCodeWireType = {}));\nexport function postConditionToWire(postcondition) {\n switch (postcondition.type) {\n case 'stx-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.STX,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n amount: BigInt(postcondition.amount),\n };\n case 'ft-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.Fungible,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n amount: BigInt(postcondition.amount),\n asset: parseAssetString(postcondition.asset),\n };\n case 'nft-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.NonFungible,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n asset: parseAssetString(postcondition.asset),\n assetName: postcondition.assetId,\n };\n default:\n throw new Error('Invalid post condition type');\n }\n}\nexport function wireToPostCondition(wire) {\n switch (wire.conditionType) {\n case PostConditionType.STX:\n return {\n type: 'stx-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n amount: wire.amount.toString(),\n };\n case PostConditionType.Fungible:\n return {\n type: 'ft-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n amount: wire.amount.toString(),\n asset: assetWireToString(wire.asset),\n };\n case PostConditionType.NonFungible:\n return {\n type: 'nft-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n asset: assetWireToString(wire.asset),\n assetId: wire.assetName,\n };\n default: {\n const _exhaustiveCheck = wire;\n throw new Error(`Invalid post condition type: ${_exhaustiveCheck}`);\n }\n }\n}\nexport function conditionTypeToByte(condition) {\n return PostConditionCodeWireType[condition];\n}\nexport function conditionByteToType(wireType) {\n return PostConditionCodeWireType[wireType];\n}\nexport function postConditionToHex(postcondition) {\n const wire = postConditionToWire(postcondition);\n return serializePostConditionWire(wire);\n}\nexport function postConditionModeFrom(mode) {\n if (typeof mode === 'number')\n return mode;\n if (mode === 'allow')\n return PostConditionMode.Allow;\n if (mode === 'deny')\n return PostConditionMode.Deny;\n throw new Error(`Invalid post condition mode: ${mode}`);\n}\nfunction assetWireToString(asset) {\n const address = addressToString(asset.address);\n const contractId = `${address}.${asset.contractName.content}`;\n return `${contractId}::${asset.assetName.content}`;\n}\nfunction principalWireToString(principal) {\n switch (principal.prefix) {\n case PostConditionPrincipalId.Origin:\n return 'origin';\n case PostConditionPrincipalId.Standard:\n return addressToString(principal.address);\n case PostConditionPrincipalId.Contract:\n const address = addressToString(principal.address);\n return `${address}.${principal.contractName.content}`;\n default:\n const _exhaustiveCheck = principal;\n throw new Error(`Invalid principal type: ${_exhaustiveCheck}`);\n }\n}\n//# sourceMappingURL=postcondition.js.map","import { isNonSequentialMultiSig, isSequentialMultiSig, isSingleSig, nextVerification, } from './authorization';\nimport { AddressHashMode, AuthType, PubKeyEncoding } from './constants';\nimport { SigningError } from './errors';\nimport { cloneDeep } from './utils';\nimport { StacksWireType } from './wire';\nimport { createStacksPublicKey } from './keys';\nexport class TransactionSigner {\n constructor(transaction) {\n this.transaction = transaction;\n this.sigHash = transaction.signBegin();\n this.originDone = false;\n this.checkOversign = true;\n this.checkOverlap = true;\n const spendingCondition = transaction.auth.spendingCondition;\n if (spendingCondition && !isSingleSig(spendingCondition)) {\n if (spendingCondition.fields.filter(field => field.contents.type === StacksWireType.MessageSignature).length >= spendingCondition.signaturesRequired) {\n throw new Error('SpendingCondition has more signatures than are expected');\n }\n spendingCondition.fields.forEach(field => {\n if (field.contents.type !== StacksWireType.MessageSignature)\n return;\n const signature = field.contents;\n const nextVerify = nextVerification(this.sigHash, transaction.auth.authType, spendingCondition.fee, spendingCondition.nonce, PubKeyEncoding.Compressed, signature.data);\n if (!isNonSequentialMultiSig(spendingCondition.hashMode)) {\n this.sigHash = nextVerify.nextSigHash;\n }\n });\n }\n }\n static createSponsorSigner(transaction, spendingCondition) {\n if (transaction.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot add sponsor to non-sponsored transaction');\n }\n const tx = cloneDeep(transaction);\n tx.setSponsor(spendingCondition);\n const originSigHash = tx.verifyOrigin();\n const signer = new this(tx);\n signer.originDone = true;\n signer.sigHash = originSigHash;\n signer.checkOversign = true;\n signer.checkOverlap = true;\n return signer;\n }\n signOrigin(privateKey) {\n if (this.checkOverlap && this.originDone) {\n throw new SigningError('Cannot sign origin after sponsor key');\n }\n if (this.transaction.auth === undefined) {\n throw new SigningError('\"transaction.auth\" is undefined');\n }\n if (this.transaction.auth.spendingCondition === undefined) {\n throw new SigningError('\"transaction.auth.spendingCondition\" is undefined');\n }\n const spendingCondition = this.transaction.auth.spendingCondition;\n if (spendingCondition.hashMode === AddressHashMode.P2SH \|\|\n spendingCondition.hashMode === AddressHashMode.P2WSH) {\n if (this.checkOversign &&\n spendingCondition.fields.filter(field => field.contents.type === StacksWireType.MessageSignature).length >= spendingCondition.signaturesRequired) {\n throw new Error('Origin would have too many signatures');\n }\n }\n const nextSighash = this.transaction.signNextOrigin(this.sigHash, privateKey);\n if (isSingleSig(this.transaction.auth.spendingCondition) \|\|\n isSequentialMultiSig(this.transaction.auth.spendingCondition.hashMode)) {\n this.sigHash = nextSighash;\n }\n }\n appendOrigin(publicKey) {\n const wire = typeof publicKey === 'object' && 'type' in publicKey\n ? publicKey\n : createStacksPublicKey(publicKey);\n if (this.checkOverlap && this.originDone) {\n throw Error('Cannot append public key to origin after sponsor key');\n }\n if (this.transaction.auth === undefined) {\n throw new Error('\"transaction.auth\" is undefined');\n }\n if (this.transaction.auth.spendingCondition === undefined) {\n throw new Error('\"transaction.auth.spendingCondition\" is undefined');\n }\n this.transaction.appendPubkey(wire);\n }\n signSponsor(privateKey) {\n if (this.transaction.auth === undefined) {\n throw new SigningError('\"transaction.auth\" is undefined');\n }\n if (this.transaction.auth.authType !== AuthType.Sponsored) {\n throw new SigningError('\"transaction.auth.authType\" is not AuthType.Sponsored');\n }\n const nextSighash = this.transaction.signNextSponsor(this.sigHash, privateKey);\n this.sigHash = nextSighash;\n this.originDone = true;\n }\n getTxInComplete() {\n return cloneDeep(this.transaction);\n }\n resume(transaction) {\n this.transaction = cloneDeep(transaction);\n this.sigHash = transaction.signBegin();\n }\n}\n//# sourceMappingURL=signer.js.map","import { STACKS_MAINNET, clientFromNetwork, networkFrom, } from '@stacks/network';\nimport { c32address } from 'c32check';\nimport { createMultiSigSpendingCondition, createSingleSigSpendingCondition, createSponsoredAuth, createStandardAuth, isSingleSig, } from './authorization';\nimport { AddressHashMode, ClarityVersion, PayloadType, PostConditionMode, } from './constants';\nimport { validateContractCall } from './contract-abi';\nimport { fetchAbi, fetchFeeEstimate, fetchNonce } from './fetch';\nimport { createStacksPublicKey, privateKeyToHex, privateKeyToPublic, publicKeyToAddress, publicKeyToHex, } from './keys';\nimport { postConditionModeFrom, postConditionToWire } from './postcondition';\nimport { TransactionSigner } from './signer';\nimport { StacksTransactionWire, deriveNetworkFromTx } from './transaction';\nimport { omit } from './utils';\nimport { addressFromPublicKeys, createAddress, createContractCallPayload, createLPList, createSmartContractPayload, createTokenTransferPayload, deserializePostConditionWire, } from './wire';\nexport async function makeUnsignedSTXTokenTransfer(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n memo: '',\n sponsored: false,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), txOptions.client);\n const payload = createTokenTransferPayload(options.recipient, options.amount, options.memo);\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n });\n if (txOptions.fee == null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce == null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeSTXTokenTransfer(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedSTXTokenTransfer({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedSTXTokenTransfer(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function makeContractDeploy(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedContractDeploy({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedContractDeploy(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function makeUnsignedContractDeploy(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n postConditionMode: PostConditionMode.Deny,\n sponsored: false,\n clarityVersion: ClarityVersion.Clarity3,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), txOptions.client);\n options.postConditionMode = postConditionModeFrom(options.postConditionMode);\n const payload = createSmartContractPayload(options.contractName, options.codeBody, options.clarityVersion);\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const postConditions = (options.postConditions ?? []).map(pc => {\n if (typeof pc === 'string')\n return deserializePostConditionWire(pc);\n if (typeof pc.type === 'string')\n return postConditionToWire(pc);\n return pc;\n });\n const lpPostConditions = createLPList(postConditions);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n postConditions: lpPostConditions,\n postConditionMode: options.postConditionMode,\n });\n if (txOptions.fee === undefined \|\| txOptions.fee === null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce === undefined \|\| txOptions.nonce === null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeUnsignedContractCall(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n postConditionMode: PostConditionMode.Deny,\n sponsored: false,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), options.client);\n options.postConditionMode = postConditionModeFrom(options.postConditionMode);\n const payload = createContractCallPayload(options.contractAddress, options.contractName, options.functionName, options.functionArgs);\n if (options?.validateWithAbi) {\n let abi;\n if (typeof options.validateWithAbi === 'boolean') {\n if (options?.network) {\n abi = await fetchAbi({ ...options });\n }\n else {\n throw new Error('Network option must be provided in order to validate with ABI');\n }\n }\n else {\n abi = options.validateWithAbi;\n }\n validateContractCall(payload, abi);\n }\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const postConditions = (options.postConditions ?? []).map(pc => {\n if (typeof pc === 'string')\n return deserializePostConditionWire(pc);\n if (typeof pc.type === 'string')\n return postConditionToWire(pc);\n return pc;\n });\n const lpPostConditions = createLPList(postConditions);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n postConditions: lpPostConditions,\n postConditionMode: options.postConditionMode,\n });\n if (txOptions.fee === undefined \|\| txOptions.fee === null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce === undefined \|\| txOptions.nonce === null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeContractCall(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedContractCall({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedContractCall(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function sponsorTransaction(sponsorOptions) {\n const defaultOptions = {\n fee: 0,\n sponsorNonce: 0,\n sponsorAddressHashmode: AddressHashMode.P2PKH,\n network: deriveNetworkFromTx(sponsorOptions.transaction),\n };\n const options = Object.assign(defaultOptions, sponsorOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), options.client);\n const sponsorPubKey = privateKeyToPublic(options.sponsorPrivateKey);\n if (sponsorOptions.fee == null) {\n let txFee = 0;\n switch (options.transaction.payload.payloadType) {\n case PayloadType.TokenTransfer:\n case PayloadType.SmartContract:\n case PayloadType.VersionedSmartContract:\n case PayloadType.ContractCall:\n txFee = BigInt(await fetchFeeEstimate({ ...options }));\n break;\n default:\n throw new Error(`Sponsored transactions not supported for transaction type ${PayloadType[options.transaction.payload.payloadType]}`);\n }\n options.transaction.setFee(txFee);\n options.fee = txFee;\n }\n if (sponsorOptions.sponsorNonce == null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = publicKeyToAddress(addressVersion, sponsorPubKey);\n const sponsorNonce = await fetchNonce({ address, ...options });\n options.sponsorNonce = sponsorNonce;\n }\n const sponsorSpendingCondition = createSingleSigSpendingCondition(options.sponsorAddressHashmode, sponsorPubKey, options.sponsorNonce, options.fee);\n options.transaction.setSponsor(sponsorSpendingCondition);\n const privKey = options.sponsorPrivateKey;\n const signer = TransactionSigner.createSponsorSigner(options.transaction, sponsorSpendingCondition);\n signer.signSponsor(privKey);\n return signer.transaction;\n}\nfunction mutatingSignAppendMultiSig(transaction, publicKeys, signerKeys, address) {\n if (isSingleSig(transaction.auth.spendingCondition)) {\n throw new Error('Transaction is not a multi-sig transaction');\n }\n const signer = new TransactionSigner(transaction);\n const pubs = address\n ? sortPublicKeysForAddress(publicKeys, transaction.auth.spendingCondition.signaturesRequired, transaction.auth.spendingCondition.hashMode, createAddress(address).hash160)\n : publicKeys;\n for (const publicKey of pubs) {\n const signerKey = signerKeys.find(key => privateKeyToPublic(key) === publicKey);\n if (signerKey) {\n signer.signOrigin(signerKey);\n }\n else {\n signer.appendOrigin(publicKey);\n }\n }\n}\nfunction sortPublicKeysForAddress(publicKeys, numSigs, hashMode, hash) {\n const hashUnsorted = addressFromPublicKeys(0, hashMode, numSigs, publicKeys.map(createStacksPublicKey)).hash160;\n if (hashUnsorted === hash)\n return publicKeys;\n const publicKeysSorted = publicKeys.slice().sort();\n const hashSorted = addressFromPublicKeys(0, hashMode, numSigs, publicKeysSorted.map(createStacksPublicKey)).hash160;\n if (hashSorted === hash)\n return publicKeysSorted;\n throw new Error('Failed to find matching multi-sig address given public-keys.');\n}\n//# sourceMappingURL=builders.js.map","/** Address versions corresponding to pox.clar, pox-2.clar /\nexport enum PoXAddressVersion {\n /* (b58/legacy) p2pkh address, and `hashbytes` is the 20-byte hash160 of a single public key /\n P2PKH = 0x00,\n /* (b58/legacy) p2sh address, and `hashbytes` is the 20-byte hash160 of a redeemScript script /\n P2SH = 0x01,\n /* (b58/legacy) p2wpkh-p2sh address, and `hashbytes` is the 20-byte hash160 of a p2wpkh witness script /\n P2SHP2WPKH = 0x02, // likely unused, as indistinguishable from P2SH\n /* (b58/legacy) p2wsh-p2sh address, and `hashbytes` is the 20-byte hash160 of a p2wsh witness script /\n P2SHP2WSH = 0x03, // likely unused, as indistinguishable from P2SH\n /* (bech32/segwit) p2wpkh address, and `hashbytes` is the 20-byte hash160 of the witness script /\n P2WPKH = 0x04,\n /* (bech32/segwit) p2wsh address, and `hashbytes` is the 32-byte sha256 of the witness script /\n P2WSH = 0x05,\n /* (bech32/segwit) p2tr address, and `hashbytes` is the 32-byte sha256 of the witness script /\n P2TR = 0x06,\n}\n\n/* @ignore /\nexport const BitcoinNetworkVersion = {\n mainnet: {\n P2PKH: 0x00, // 0\n P2SH: 0x05, // 5\n },\n testnet: {\n P2PKH: 0x6f, // 111\n P2SH: 0xc4, // 196\n },\n devnet: {\n // equivalent to testnet for our purposes\n P2PKH: 0x6f, // 111\n P2SH: 0xc4, // 196\n },\n mocknet: {\n // equivalent to testnet for our purposes\n P2PKH: 0x6f, // 111\n P2SH: 0xc4, // 196\n },\n} as const;\n\n/\n Valid prefix chars for mainnet and testnet P2PKH and P2SH addresses\n * mainnet P2PKH: 1\n * testnet P2PKH: m or n\n * mainnet P2SH: 3\n * testnet P2SH: 2\n * @ignore\n /\nexport const B58_ADDR_PREFIXES = /^(1\|3\|m\|n\|2)/;\n\n/\n Valid prefixes for supported segwit address, structure is:\n * HRP PREFIX + SEPARATOR (always '1') + C32_ENCODED SEGWIT_VERSION_BYTE ('q' for 0, 'p' for 1) + HASHDATA\n * @ignore\n /\nexport const SEGWIT_V0_ADDR_PREFIX = /^(bc1q\|tb1q\|bcrt1q)/i;\nexport const SEGWIT_V1_ADDR_PREFIX = /^(bc1p\|tb1p\|bcrt1p)/i;\n\n/\n Segwit Human-Readable Parts\n * Valid prefixs for mainnet and testnet bech32/segwit addresses\n * @ignore\n /\nexport const SegwitPrefix = {\n mainnet: 'bc',\n testnet: 'tb',\n devnet: 'bcrt',\n mocknet: 'bcrt',\n} as const;\n/* @ignore /\nexport const SEGWIT_ADDR_PREFIXES = /^(bc\|tb)/i;\n\n/* @ignore /\nexport const SEGWIT_V0 = 0;\n/* @ignore /\nexport const SEGWIT_V1 = 1;\n\n// Segwit/taproot address examples:\n// mainnet P2WPKH: bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4\n// testnet P2WPKH: tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx\n// mainnet P2WSH: bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3\n// testnet P2WSH: tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7\n// mainnet P2TR: bc1p5d7rjq7g6rdk2yhzks9smlaqtedr4dekq08ge8ztwac72sfr9rusxg3297\n// testnet P2TR: tb1p6h5fuzmnvpdthf5shf0qqjzwy7wsqc5rhmgq2ks9xrak4ry6mtrscsqvzp\n\n/\n Transitional periods from the 2.1 launch\n * @see SIP-015\n /\nexport enum PoxOperationPeriod {\n /* Period 1: This is before the 2.1 fork. /\n Period1 = 'Period1',\n /* Period 2a: This is after the 2.1 fork, but before v1_unlock_height. /\n Period2a = 'Period2a', //\n /* Period 2b: This is after the 2.1 fork, after v1_unlock_height, but before the first PoX-2 reward cycle. /\n Period2b = 'Period2b',\n /* Period 3: This is after the first PoX-2 reward cycle has begun. The original PoX contract state will no longer have any impact on reward sets. /\n Period3 = 'Period3',\n}\n\nexport enum StackingErrors {\n // taken from https://github.com/stacks-network/stacks-blockchain/blob/088ff00761b27a12bfaf19dab5743e77e8ca4d0c/src/chainstate/stacks/boot/pox-3.clar\n ERR_STACKING_UNREACHABLE = 255,\n ERR_STACKING_CORRUPTED_STATE = 254,\n ERR_STACKING_INSUFFICIENT_FUNDS = 1,\n ERR_STACKING_INVALID_LOCK_PERIOD = 2,\n ERR_STACKING_ALREADY_STACKED = 3,\n ERR_STACKING_NO_SUCH_PRINCIPAL = 4,\n ERR_STACKING_EXPIRED = 5,\n ERR_STACKING_STX_LOCKED = 6,\n ERR_STACKING_PERMISSION_DENIED = 9,\n ERR_STACKING_THRESHOLD_NOT_MET = 11,\n ERR_STACKING_POX_ADDRESS_IN_USE = 12,\n ERR_STACKING_INVALID_POX_ADDRESS = 13,\n ERR_STACKING_ALREADY_REJECTED = 17,\n ERR_STACKING_INVALID_AMOUNT = 18,\n ERR_NOT_ALLOWED = 19,\n ERR_STACKING_ALREADY_DELEGATED = 20,\n ERR_DELEGATION_EXPIRES_DURING_LOCK = 21,\n ERR_DELEGATION_TOO_MUCH_LOCKED = 22,\n ERR_DELEGATION_POX_ADDR_REQUIRED = 23,\n ERR_INVALID_START_BURN_HEIGHT = 24,\n ERR_NOT_CURRENT_STACKER = 25,\n ERR_STACK_EXTEND_NOT_LOCKED = 26,\n ERR_STACK_INCREASE_NOT_LOCKED = 27,\n ERR_DELEGATION_NO_REWARD_SLOT = 28,\n ERR_DELEGATION_WRONG_REWARD_SLOT = 29,\n ERR_STACKING_IS_DELEGATED = 30,\n ERR_STACKING_NOT_DELEGATED = 31,\n}\n","/! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) /\nexport function assertNumber(n) {\n if (!Number.isSafeInteger(n))\n throw new Error(`Wrong integer: ${n}`);\n}\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}\nexport const utils = { alphabet, chain, checksum, radix, radix2, join, padding };\nexport const base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));\nexport const base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));\nexport const base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));\nexport const base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));\nexport const base64 = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));\nexport const base64url = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));\nconst genBase58 = (abc) => chain(radix(58), alphabet(abc), join(''));\nexport const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');\nexport const base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');\nexport const base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz');\nconst XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11];\nexport const 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 += 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 = 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};\nexport const base58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);\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}\nexport const bech32 = genBech32('bech32');\nexport const bech32m = genBech32('bech32m');\nexport const utf8 = {\n encode: (data) => new TextDecoder().decode(data),\n decode: (str) => new TextEncoder().encode(str),\n};\nexport const 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, hex, base16, base32, base64, base64url, base58, base58xmr\n};\nconst coderTypeError = `Invalid encoding type. Available types: ${Object.keys(CODERS).join(', ')}`;\nexport const 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};\nexport const str = bytesToString;\nexport const 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};\nexport const bytes = stringToBytes;\n","import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { getPublicKey as nobleGetPublicKey, signSync, utils } from '@noble/secp256k1';\nimport { bytesToHex, concatBytes, hexToBytes, privateKeyToBytes, readUInt8, } from '@stacks/common';\nimport base58 from 'bs58';\nimport { hashRipemd160 } from './hashRipemd160';\nimport { hashSha256Sync } from './sha2Hash';\nconst BITCOIN_PUBKEYHASH = 0x00;\nutils.hmacSha256Sync = (key, ...msgs) => {\n const h = hmac.create(sha256, key);\n msgs.forEach(msg => h.update(msg));\n return h.digest();\n};\nexport function makeECPrivateKey() {\n return bytesToHex(utils.randomPrivateKey());\n}\nexport function base58CheckDecode(btcAddress) {\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 if ((checksum[0] ^ newChecksum[0]) \|\n (checksum[1] ^ newChecksum[1]) \|\n (checksum[2] ^ newChecksum[2]) \|\n (checksum[3] ^ newChecksum[3])) {\n throw new Error('Invalid checksum');\n }\n if (payload.length !== 21)\n throw new TypeError('Invalid address length');\n const version = readUInt8(payload, 0);\n const hash = payload.slice(1);\n return { version, hash };\n}\nexport function base58Encode(hash) {\n const checksum = sha256(sha256(hash));\n return base58.encode(concatBytes(hash, checksum).slice(0, hash.length + 4));\n}\nexport function base58CheckEncode(version, hash) {\n return base58Encode(concatBytes(new Uint8Array([version]), hash.slice(0, 20)));\n}\nexport function publicKeyToBtcAddress(publicKey, version = BITCOIN_PUBKEYHASH) {\n const publicKeyBytes = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n const publicKeyHash160 = hashRipemd160(hashSha256Sync(publicKeyBytes));\n return base58CheckEncode(version, publicKeyHash160);\n}\nexport function getPublicKeyFromPrivate(privateKey) {\n const privateKeyBytes = privateKeyToBytes(privateKey);\n return bytesToHex(nobleGetPublicKey(privateKeyBytes.slice(0, 32), true));\n}\nexport function ecSign(messageHash, privateKey) {\n return signSync(messageHash, privateKeyToBytes(privateKey).slice(0, 32), {\n der: false,\n });\n}\n//# sourceMappingURL=keys.js.map","import { readUInt16LE, readUInt32LE, readUInt8, writeUInt16LE, writeUInt32LE, writeUInt8, } from '@stacks/common';\nconst MAX_SAFE_INTEGER = 9007199254740991;\nfunction ensureUInt53(n) {\n if (n < 0 \|\| n > MAX_SAFE_INTEGER \|\| n % 1 !== 0)\n throw new RangeError('value out of range');\n}\nexport function encode(number, bytes, offset = 0) {\n ensureUInt53(number);\n if (!bytes)\n bytes = new Uint8Array(encodingLength(number));\n if (number < 0xfd) {\n writeUInt8(bytes, number, offset);\n }\n else if (number <= 65535) {\n writeUInt8(bytes, 0xfd, offset);\n writeUInt16LE(bytes, number, offset + 1);\n }\n else if (number <= 4294967295) {\n writeUInt8(bytes, 0xfe, offset);\n writeUInt32LE(bytes, number, offset + 1);\n }\n else {\n writeUInt8(bytes, 0xff, offset);\n writeUInt32LE(bytes, number >>> 0, offset + 1);\n writeUInt32LE(bytes, (number / 4294967296) \| 0, offset + 5);\n }\n return bytes;\n}\nexport function decode(bytes, offset = 0) {\n const first = readUInt8(bytes, offset);\n if (first < 0xfd) {\n return first;\n }\n else if (first === 0xfd) {\n return readUInt16LE(bytes, offset + 1);\n }\n else if (first === 0xfe) {\n return readUInt32LE(bytes, offset + 1);\n }\n else {\n const lo = readUInt32LE(bytes, offset + 1);\n const hi = readUInt32LE(bytes, offset + 5);\n const number = hi * 4294967296 + lo;\n ensureUInt53(number);\n return number;\n }\n}\nexport function encodingLength(number) {\n ensureUInt53(number);\n return number < 0xfd ? 1 : number <= 65535 ? 3 : number <= 4294967295 ? 5 : 9;\n}\n//# sourceMappingURL=varuint.js.map","import { sha256 } from '@noble/hashes/sha256';\nimport { concatBytes, utf8ToBytes } from '@stacks/common';\nimport { decode, encode, encodingLength } from './varuint';\nconst chainPrefix = '\\x17Stacks Signed Message:\\n';\nexport function hashMessage(message, prefix = chainPrefix) {\n return sha256(encodeMessage(message, prefix));\n}\nexport function encodeMessage(message, prefix = chainPrefix) {\n const messageBytes = typeof message == 'string' ? utf8ToBytes(message) : message;\n const encodedLength = encode(messageBytes.length);\n return concatBytes(utf8ToBytes(prefix), encodedLength, messageBytes);\n}\nexport function decodeMessage(encodedMessage, prefix = chainPrefix) {\n const prefixByteLength = utf8ToBytes(prefix).byteLength;\n const messageWithoutChainPrefix = encodedMessage.subarray(prefixByteLength);\n const decoded = decode(messageWithoutChainPrefix);\n const varIntLength = encodingLength(decoded);\n return messageWithoutChainPrefix.slice(varIntLength);\n}\n//# sourceMappingURL=messageSignature.js.map","import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { getPublicKey, getSharedSecret, Point, Signature, signSync, utils, verify, } from '@noble/secp256k1';\nimport { bigIntToBytes, bytesToHex, bytesToUtf8, concatBytes, FailedDecryptionError, hexToBigInt, hexToBytes, parseRecoverableSignatureVrs, signatureRsvToVrs, utf8ToBytes, } 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';\nutils.hmacSha256Sync = (key, ...msgs) => {\n const h = hmac.create(sha256, key);\n msgs.forEach(msg => h.update(msg));\n return h.digest();\n};\nexport var InvalidPublicKeyReason;\n(function (InvalidPublicKeyReason) {\n InvalidPublicKeyReason[\"InvalidFormat\"] = \"InvalidFormat\";\n InvalidPublicKeyReason[\"IsNotPoint\"] = \"IsNotPoint\";\n})(InvalidPublicKeyReason \|\| (InvalidPublicKeyReason = {}));\nexport async function aes256CbcEncrypt(iv, key, plaintext) {\n const cipher = await createCipher();\n return await cipher.encrypt('aes-256-cbc', key, iv, plaintext);\n}\nasync function aes256CbcDecrypt(iv, key, ciphertext) {\n const cipher = await createCipher();\n return await cipher.decrypt('aes-256-cbc', key, iv, ciphertext);\n}\nexport function hmacSha256(key, content) {\n return hmac(sha256, key, content);\n}\nfunction equalsConstTime(a, b) {\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}\nfunction sharedSecretToKeys(sharedSecret) {\n const hashedSecret = hashSha512Sync(sharedSecret);\n return {\n encryptionKey: hashedSecret.slice(0, 32),\n hmacKey: hashedSecret.slice(32),\n };\n}\nfunction allHexChars(maybe) {\n return maybe.match(/^[0-9a-f]+$/i) !== null;\n}\nfunction isValidPublicKey(pub) {\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)\n return invalidFormat;\n const firstByte = pub.slice(0, 2);\n if (pub.length === 130 && firstByte !== '04')\n return invalidFormat;\n if (pub.length === 66 && firstByte !== '02' && firstByte !== '03')\n return invalidFormat;\n if (!allHexChars(pub))\n return invalidFormat;\n try {\n const point = Point.fromHex(pub);\n point.assertValidity();\n return {\n result: true,\n reason_data: null,\n reason: null,\n };\n }\n catch (e) {\n return invalidPoint;\n }\n}\nexport function getHexFromBN(bnInput) {\n const hexOut = bnInput.toString(16);\n if (hexOut.length === 64) {\n return hexOut;\n }\n else if (hexOut.length < 64) {\n const padding = '0'.repeat(64 - hexOut.length);\n return `${padding}${hexOut}`;\n }\n else {\n throw new Error('Generated a > 32-byte bigint for encryption. Failing.');\n }\n}\nexport function getBytesFromBN(bnInput) {\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}\nexport function getCipherObjectWrapper(opts) {\n const shell = {\n iv: '',\n ephemeralPK: '',\n mac: '',\n cipherText: '',\n wasString: !!opts.wasString,\n };\n if (opts.cipherTextEncoding === 'base64') {\n shell.cipherTextEncoding = 'base64';\n }\n const ivLength = 32;\n const ephemeralPKLength = 66;\n const macLength = 64;\n return {\n payloadValuesLength: ivLength + ephemeralPKLength + macLength,\n payloadShell: JSON.stringify(shell),\n };\n}\nexport function getSignedCipherObjectWrapper(payloadShell) {\n const shell = {\n signature: '',\n publicKey: '',\n cipherText: payloadShell,\n };\n const signatureLength = 144;\n const publicKeyLength = 66;\n return {\n signedPayloadValuesLength: signatureLength + publicKeyLength,\n signedPayloadShell: JSON.stringify(shell),\n };\n}\nexport function eciesGetJsonStringLength(opts) {\n const { payloadShell, payloadValuesLength } = getCipherObjectWrapper(opts);\n const cipherTextLength = getAesCbcOutputLength(opts.contentLength);\n let encodedCipherTextLength;\n if (!opts.cipherTextEncoding \|\| opts.cipherTextEncoding === 'hex') {\n encodedCipherTextLength = cipherTextLength * 2;\n }\n else if (opts.cipherTextEncoding === 'base64') {\n encodedCipherTextLength = getBase64OutputLength(cipherTextLength);\n }\n else {\n throw new Error(`Unexpected cipherTextEncoding \"${opts.cipherTextEncoding}\"`);\n }\n if (!opts.sign) {\n return payloadShell.length + payloadValuesLength + encodedCipherTextLength;\n }\n else {\n const { signedPayloadShell, signedPayloadValuesLength } = getSignedCipherObjectWrapper(payloadShell);\n return (signedPayloadShell.length +\n signedPayloadValuesLength +\n payloadValuesLength +\n encodedCipherTextLength);\n }\n}\nexport async function encryptECIES(publicKey, content, wasString, cipherTextEncoding) {\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 sharedSecret = sharedSecret.slice(1);\n const sharedKeys = sharedSecretToKeys(sharedSecret);\n const initializationVector = utils.randomBytes(16);\n const cipherText = await aes256CbcEncrypt(initializationVector, sharedKeys.encryptionKey, content);\n const macData = concatBytes(initializationVector, ephemeralPublicKey, cipherText);\n const mac = hmacSha256(sharedKeys.hmacKey, macData);\n let cipherTextString;\n if (!cipherTextEncoding \|\| cipherTextEncoding === 'hex') {\n cipherTextString = bytesToHex(cipherText);\n }\n else if (cipherTextEncoding === 'base64') {\n cipherTextString = fromByteArray(cipherText);\n }\n else {\n throw new Error(`Unexpected cipherTextEncoding \"${cipherTextEncoding}\"`);\n }\n const result = {\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}\nexport async function decryptECIES(privateKey, cipherObject) {\n if (!cipherObject.ephemeralPK) {\n throw new FailedDecryptionError('Unable to get public key from cipher object. ' +\n 'You might be trying to decrypt an unencrypted object.');\n }\n const ephemeralPK = cipherObject.ephemeralPK;\n let sharedSecret = getSharedSecret(privateKey, ephemeralPK, true);\n sharedSecret = sharedSecret.slice(1);\n const sharedKeys = sharedSecretToKeys(sharedSecret);\n const ivBytes = hexToBytes(cipherObject.iv);\n let cipherTextBytes;\n if (!cipherObject.cipherTextEncoding \|\| cipherObject.cipherTextEncoding === 'hex') {\n cipherTextBytes = hexToBytes(cipherObject.cipherText);\n }\n else if (cipherObject.cipherTextEncoding === 'base64') {\n cipherTextBytes = toByteArray(cipherObject.cipherText);\n }\n else {\n throw new Error(`Unexpected cipherTextEncoding \"${cipherObject.cipherText}\"`);\n }\n const macData = concatBytes(ivBytes, hexToBytes(ephemeralPK), cipherTextBytes);\n const actualMac = hmacSha256(sharedKeys.hmacKey, macData);\n const expectedMac = hexToBytes(cipherObject.mac);\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 if (cipherObject.wasString) {\n return bytesToUtf8(plainText);\n }\n return plainText;\n}\nexport function signECDSA(privateKey, content) {\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 return {\n signature: bytesToHex(signature),\n publicKey,\n };\n}\nexport function verifyECDSA(content, publicKey, signature) {\n const contentBytes = typeof content === 'string' ? utf8ToBytes(content) : content;\n const contentHash = hashSha256Sync(contentBytes);\n return verify(signature, contentHash, publicKey, { strict: false });\n}\nexport function verifyMessageSignature({ signature, message, publicKey, }) {\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 const verificationResult = verify(sig, hashedMsg, publicKey, { strict: false });\n if (verificationResult \|\| typeof message !== 'string')\n return verificationResult;\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}\nexport function verifyMessageSignatureRsv({ signature, message, publicKey, }) {\n return verifyMessageSignature({\n signature: signatureRsvToVrs(signature),\n message,\n publicKey,\n });\n}\n//# sourceMappingURL=ec.js.map","import { sha256 } from '@noble/hashes/sha256';\nimport { bytesToHex, concatBytes, hexToBytes } from '@stacks/common';\nimport { ClarityType, serializeCVBytes } from './clarity';\nimport { signMessageHashRsv } from './keys';\nexport const STRUCTURED_DATA_PREFIX = new Uint8Array([0x53, 0x49, 0x50, 0x30, 0x31, 0x38]);\nexport function hashStructuredData(structuredData) {\n return bytesToHex(sha256(serializeCVBytes(structuredData)));\n}\nexport function hashStructuredDataBytes(structuredData) {\n return sha256(serializeCVBytes(structuredData));\n}\nconst hash256BytesLength = 32;\nfunction isDomain(value) {\n if (value.type !== ClarityType.Tuple)\n return false;\n if (!['name', 'version', 'chain-id'].every(key => key in value.value))\n return false;\n if (!['name', 'version'].every(key => value.value[key].type === ClarityType.StringASCII))\n return false;\n if (value.value['chain-id'].type !== ClarityType.UInt)\n return false;\n return true;\n}\nexport function encodeStructuredData(opts) {\n const bytes = encodeStructuredDataBytes(opts);\n return bytesToHex(bytes);\n}\nexport function encodeStructuredDataBytes({ message, domain, }) {\n const structuredDataHash = hashStructuredDataBytes(message);\n if (!isDomain(domain)) {\n throw new Error(\"domain parameter must be a valid domain of type TupleCV with keys 'name', 'version', 'chain-id' with respective types StringASCII, StringASCII, UInt\");\n }\n const domainHash = hashStructuredDataBytes(domain);\n return concatBytes(STRUCTURED_DATA_PREFIX, domainHash, structuredDataHash);\n}\nexport function decodeStructuredDataSignature(signature) {\n const bytes = decodeStructuredDataSignatureBytes(signature);\n return {\n domainHash: bytesToHex(bytes.domainHash),\n messageHash: bytesToHex(bytes.messageHash),\n };\n}\nexport function decodeStructuredDataSignatureBytes(signature) {\n const encodedMessageBytes = typeof signature === 'string' ? hexToBytes(signature) : signature;\n const domainHash = encodedMessageBytes.slice(STRUCTURED_DATA_PREFIX.length, STRUCTURED_DATA_PREFIX.length + hash256BytesLength);\n const messageHash = encodedMessageBytes.slice(STRUCTURED_DATA_PREFIX.length + hash256BytesLength);\n return {\n domainHash,\n messageHash,\n };\n}\nexport function signStructuredData({ message, domain, privateKey, }) {\n const structuredDataHash = bytesToHex(sha256(encodeStructuredDataBytes({ message, domain })));\n return signMessageHashRsv({\n messageHash: structuredDataHash,\n privateKey,\n });\n}\n//# sourceMappingURL=structuredDataSignature.js.map","import { sha256 } from '@noble/hashes/sha256';\nimport { bech32, bech32m } from '@scure/base';\nimport { IntegerType, PrivateKey, bigIntToBytes, bytesToHex, hexToBytes } from '@stacks/common';\nimport {\n base58CheckDecode,\n base58CheckEncode,\n verifyMessageSignatureRsv,\n} from '@stacks/encryption';\nimport { StacksNetwork, StacksNetworkName, StacksNetworks, networkFrom } from '@stacks/network';\nimport {\n BufferCV,\n ClarityType,\n ClarityValue,\n OptionalCV,\n TupleCV,\n bufferCV,\n encodeStructuredDataBytes,\n signStructuredData,\n stringAsciiCV,\n tupleCV,\n uintCV,\n} from '@stacks/transactions';\nimport { PoxOperationInfo } from '.';\nimport {\n B58_ADDR_PREFIXES,\n BitcoinNetworkVersion,\n PoXAddressVersion,\n PoxOperationPeriod,\n SEGWIT_ADDR_PREFIXES,\n SEGWIT_V0,\n SEGWIT_V0_ADDR_PREFIX,\n SEGWIT_V1,\n SEGWIT_V1_ADDR_PREFIX,\n SegwitPrefix,\n StackingErrors,\n} from './constants';\n\nexport class InvalidAddressError extends Error {\n innerError?: Error;\n constructor(address: string, innerError?: Error) {\n const msg = `'${address}' is not a valid P2PKH/P2SH/P2WPKH/P2WSH/P2TR address`;\n super(msg);\n this.message = msg;\n this.name = this.constructor.name;\n this.innerError = innerError;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, this.constructor);\n }\n }\n}\n\n/** @ignore /\nexport function btcAddressVersionToLegacyHashMode(btcAddressVersion: number): PoXAddressVersion {\n switch (btcAddressVersion) {\n case BitcoinNetworkVersion.mainnet.P2PKH:\n return PoXAddressVersion.P2PKH;\n case BitcoinNetworkVersion.testnet.P2PKH:\n return PoXAddressVersion.P2PKH;\n case BitcoinNetworkVersion.mainnet.P2SH:\n return PoXAddressVersion.P2SH;\n case BitcoinNetworkVersion.testnet.P2SH:\n return PoXAddressVersion.P2SH;\n default:\n throw new Error('Invalid pox address version');\n }\n}\n\n/* @ignore /\nfunction nativeAddressToSegwitVersion(\n witnessVersion: number,\n dataLength: number\n): PoXAddressVersion {\n if (witnessVersion === SEGWIT_V0 && dataLength === 20) return PoXAddressVersion.P2WPKH;\n if (witnessVersion === SEGWIT_V0 && dataLength === 32) return PoXAddressVersion.P2WSH;\n if (witnessVersion === SEGWIT_V1 && dataLength === 32) return PoXAddressVersion.P2TR;\n\n throw new Error(\n 'Invalid native segwit witness version and byte length. Currently, only P2WPKH, P2WSH, and P2TR are supported.'\n );\n}\n\n/* @ignore /\nfunction bech32Decode(btcAddress: string) {\n const { words: bech32Words } = bech32.decode(btcAddress);\n const witnessVersion = bech32Words[0];\n\n if (witnessVersion > 0)\n throw new Error('Addresses with a witness version >= 1 should be encoded in bech32m');\n\n return {\n witnessVersion,\n data: bech32.fromWords(bech32Words.slice(1)),\n };\n}\n\n/* @ignore /\nfunction bech32MDecode(btcAddress: string) {\n const { words: bech32MWords } = bech32m.decode(btcAddress);\n const witnessVersion = bech32MWords[0];\n\n if (witnessVersion == 0)\n throw new Error('Addresses with witness version 1 should be encoded in bech32');\n\n return {\n witnessVersion,\n data: bech32m.fromWords(bech32MWords.slice(1)),\n };\n}\n\n/* @ignore /\nfunction decodeNativeSegwitBtcAddress(btcAddress: string): {\n witnessVersion: number;\n data: Uint8Array;\n} {\n if (SEGWIT_V0_ADDR_PREFIX.test(btcAddress)) return bech32Decode(btcAddress);\n if (SEGWIT_V1_ADDR_PREFIX.test(btcAddress)) return bech32MDecode(btcAddress);\n throw new Error(\n `Native segwit address ${btcAddress} does not match valid prefix ${SEGWIT_V0_ADDR_PREFIX} or ${SEGWIT_V1_ADDR_PREFIX}`\n );\n}\n\nexport function decodeBtcAddress(btcAddress: string): {\n version: PoXAddressVersion;\n data: string;\n} {\n const { version, data } = decodeBtcAddressBytes(btcAddress);\n return { version, data: bytesToHex(data) };\n}\n\nexport function decodeBtcAddressBytes(btcAddress: string): {\n version: PoXAddressVersion;\n data: Uint8Array;\n} {\n try {\n if (B58_ADDR_PREFIXES.test(btcAddress)) {\n const b58 = base58CheckDecode(btcAddress);\n const addressVersion = btcAddressVersionToLegacyHashMode(b58.version);\n return {\n version: addressVersion,\n data: b58.hash,\n };\n } else if (SEGWIT_ADDR_PREFIXES.test(btcAddress)) {\n const b32 = decodeNativeSegwitBtcAddress(btcAddress);\n const addressVersion = nativeAddressToSegwitVersion(b32.witnessVersion, b32.data.length);\n return {\n version: addressVersion,\n data: b32.data,\n };\n }\n throw new Error('Unknown BTC address prefix.');\n } catch (error) {\n throw new InvalidAddressError(btcAddress, error as Error);\n }\n}\n\nexport function extractPoxAddressFromClarityValue(poxAddrClarityValue: ClarityValue): {\n version: number;\n hashBytes: Uint8Array;\n} {\n const clarityValue = poxAddrClarityValue as TupleCV;\n if (clarityValue.type !== ClarityType.Tuple \|\| !clarityValue.value) {\n throw new Error('Invalid argument, expected ClarityValue to be a TupleCV');\n }\n if (!('version' in clarityValue.value) \|\| !('hashbytes' in clarityValue.value)) {\n throw new Error(\n 'Invalid argument, expected Clarity tuple value to contain `version` and `hashbytes` keys'\n );\n }\n const versionCV = clarityValue.value['version'] as BufferCV;\n const hashBytesCV = clarityValue.value['hashbytes'] as BufferCV;\n if (versionCV.type !== ClarityType.Buffer \|\| hashBytesCV.type !== ClarityType.Buffer) {\n throw new Error(\n 'Invalid argument, expected Clarity tuple value to contain `version` and `hashbytes` buffers'\n );\n }\n return {\n version: hexToBytes(versionCV.value)[0],\n hashBytes: hexToBytes(hashBytesCV.value),\n };\n}\n\nexport function getErrorString(error: StackingErrors): string {\n switch (error) {\n case StackingErrors.ERR_STACKING_UNREACHABLE:\n return 'Stacking unreachable';\n case StackingErrors.ERR_STACKING_CORRUPTED_STATE:\n return 'Stacking state is corrupted';\n case StackingErrors.ERR_STACKING_INSUFFICIENT_FUNDS:\n return 'Insufficient funds';\n case StackingErrors.ERR_STACKING_INVALID_LOCK_PERIOD:\n return 'Invalid lock period';\n case StackingErrors.ERR_STACKING_ALREADY_STACKED:\n return 'Account already stacked. Concurrent stacking not allowed.';\n case StackingErrors.ERR_STACKING_NO_SUCH_PRINCIPAL:\n return 'Principal does not exist';\n case StackingErrors.ERR_STACKING_EXPIRED:\n return 'Stacking expired';\n case StackingErrors.ERR_STACKING_STX_LOCKED:\n return 'STX balance is locked';\n case StackingErrors.ERR_STACKING_PERMISSION_DENIED:\n return 'Permission denied';\n case StackingErrors.ERR_STACKING_THRESHOLD_NOT_MET:\n return 'Stacking threshold not met';\n case StackingErrors.ERR_STACKING_POX_ADDRESS_IN_USE:\n return 'PoX address already in use';\n case StackingErrors.ERR_STACKING_INVALID_POX_ADDRESS:\n return 'Invalid PoX address';\n case StackingErrors.ERR_STACKING_ALREADY_REJECTED:\n return 'Stacking already rejected';\n case StackingErrors.ERR_STACKING_INVALID_AMOUNT:\n return 'Invalid amount';\n case StackingErrors.ERR_NOT_ALLOWED:\n return 'Stacking not allowed';\n case StackingErrors.ERR_STACKING_ALREADY_DELEGATED:\n return 'Already delegated';\n case StackingErrors.ERR_DELEGATION_EXPIRES_DURING_LOCK:\n return 'Delegation expires during lock period';\n case StackingErrors.ERR_DELEGATION_TOO_MUCH_LOCKED:\n return 'Delegation too much locked';\n case StackingErrors.ERR_DELEGATION_POX_ADDR_REQUIRED:\n return 'PoX address required for delegation';\n case StackingErrors.ERR_INVALID_START_BURN_HEIGHT:\n return 'Invalid start burn height';\n case StackingErrors.ERR_NOT_CURRENT_STACKER: // not used in pox contract\n return 'ERR_NOT_CURRENT_STACKER';\n case StackingErrors.ERR_STACK_EXTEND_NOT_LOCKED:\n return 'Stacker must be currently locked';\n case StackingErrors.ERR_STACK_INCREASE_NOT_LOCKED:\n return 'Stacker must be currently locked';\n case StackingErrors.ERR_DELEGATION_NO_REWARD_SLOT:\n return 'Invalid reward-cycle and reward-cycle-index';\n case StackingErrors.ERR_DELEGATION_WRONG_REWARD_SLOT:\n return 'PoX address must match the one on record';\n case StackingErrors.ERR_STACKING_IS_DELEGATED:\n return 'Stacker must be directly stacking and not delegating';\n case StackingErrors.ERR_STACKING_NOT_DELEGATED:\n return 'Stacker must be delegating and not be directly stacking';\n }\n}\n/\n Converts a PoX address to a tuple (e.g. to be used in a Clarity contract call).\n \n @param poxAddress - The PoX bitcoin address to be converted.\n * @returns The converted PoX address as a tuple of version and hashbytes.\n /\nexport function poxAddressToTuple(poxAddress: string) {\n const { version, data } = decodeBtcAddressBytes(poxAddress);\n const versionBuff = bufferCV(bigIntToBytes(BigInt(version), 1));\n const hashBuff = bufferCV(data);\n return tupleCV({\n version: versionBuff,\n hashbytes: hashBuff,\n });\n}\n\nfunction legacyHashModeToBtcAddressVersion(\n hashMode: PoXAddressVersion,\n network: StacksNetworkName\n): number {\n switch (hashMode) {\n case PoXAddressVersion.P2PKH:\n return BitcoinNetworkVersion[network].P2PKH;\n case PoXAddressVersion.P2SH:\n case PoXAddressVersion.P2SHP2WPKH:\n case PoXAddressVersion.P2SHP2WSH:\n // P2SHP2WPKH and P2SHP2WSH are treated as P2SH for the sender\n return BitcoinNetworkVersion[network].P2SH;\n default:\n throw new Error('Invalid pox address version');\n }\n}\n\nfunction _poxAddressToBtcAddress_Values(\n version: number,\n hash: string \| Uint8Array,\n network: StacksNetworkName\n): string {\n if (!StacksNetworks.includes(network)) throw new Error('Invalid network.');\n\n if (typeof hash === 'string') hash = hexToBytes(hash);\n\n switch (version) {\n case PoXAddressVersion.P2PKH:\n case PoXAddressVersion.P2SH:\n case PoXAddressVersion.P2SHP2WPKH:\n case PoXAddressVersion.P2SHP2WSH: {\n const btcAddrVersion = legacyHashModeToBtcAddressVersion(version, network);\n return base58CheckEncode(btcAddrVersion, hash);\n }\n case PoXAddressVersion.P2WPKH:\n case PoXAddressVersion.P2WSH: {\n const words = bech32.toWords(hash);\n return bech32.encode(SegwitPrefix[network], [SEGWIT_V0, ...words]);\n }\n case PoXAddressVersion.P2TR: {\n const words = bech32m.toWords(hash);\n return bech32m.encode(SegwitPrefix[network], [SEGWIT_V1, ...words]);\n }\n }\n throw new Error(`Unexpected address version: ${version}`);\n}\n\nfunction _poxAddressToBtcAddress_ClarityValue(\n poxAddrClarityValue: ClarityValue,\n network: StacksNetworkName\n): string {\n const poxAddr = extractPoxAddressFromClarityValue(poxAddrClarityValue);\n return _poxAddressToBtcAddress_Values(poxAddr.version, poxAddr.hashBytes, network);\n}\n\n/\n Converts a PoX address to a Bitcoin address.\n \n @param version - The version of the PoX address (as a single number, not a Uint8array).\n * @param hash - The hash bytes of the PoX address.\n * @param network - The network the PoX address is on.\n * @returns The corresponding Bitcoin address.\n /\nexport function poxAddressToBtcAddress(\n version: number,\n hash: string \| Uint8Array,\n network: StacksNetworkName // todo: allow NetworkParam in the future (minor)\n): string;\n/\n Converts a PoX address to a Bitcoin address.\n \n @param poxAddrClarityValue - The clarity tuple of the PoX address (version and hashbytes).\n * @param network - The network the PoX address is on.\n * @returns The corresponding Bitcoin address.\n /\nexport function poxAddressToBtcAddress(\n poxAddrClarityValue: ClarityValue,\n network: StacksNetworkName\n): string;\nexport function poxAddressToBtcAddress(...args: any[]): string {\n // todo: allow these helpers to take a bitcoin network instead of a stacks network, once we have a concept of bitcoin networks in the codebase\n if (typeof args[0] === 'number') return _poxAddressToBtcAddress_Values(args[0], args[1], args[2]);\n return _poxAddressToBtcAddress_ClarityValue(args[0], args[1]);\n}\n\n// todo: move unwrap to tx package and document\nexport function unwrap<T extends ClarityValue>(optional: OptionalCV<T>) {\n if (optional.type === ClarityType.OptionalSome) return optional.value;\n if (optional.type === ClarityType.OptionalNone) return undefined;\n throw new Error(\"Object is not an 'Optional'\");\n}\n\nexport function unwrapMap<T extends ClarityValue, U>(optional: OptionalCV<T>, map: (t: T) => U) {\n if (optional.type === ClarityType.OptionalSome) return map(optional.value);\n if (optional.type === ClarityType.OptionalNone) return undefined;\n throw new Error(\"Object is not an 'Optional'\");\n}\n\n/* @internal /\nexport function ensurePox2Activated(operationInfo: PoxOperationInfo) {\n if (operationInfo.period === PoxOperationPeriod.Period1)\n throw new Error(\n `PoX-2 has not activated yet (currently in period ${operationInfo.period} of PoX-2 operation)`\n );\n}\n\n/\n @internal\n * Throws if the given PoX address is not a legacy address for PoX-1.\n /\nexport function ensureLegacyBtcAddressForPox1({\n contract,\n poxAddress,\n}: {\n contract: string;\n poxAddress?: string;\n}) {\n if (!poxAddress) return;\n if (contract.endsWith('.pox') && !B58_ADDR_PREFIXES.test(poxAddress)) {\n throw new Error('PoX-1 requires P2PKH/P2SH/P2SH-P2WPKH/P2SH-P2WSH bitcoin addresses');\n }\n}\n\n/\n @internal\n * Throws if signer args are given for <= PoX-3 or the signer args are missing otherwise.\n /\nexport function ensureSignerArgsReadiness({\n contract,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n}: {\n contract: string;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n}) {\n const hasMaxAmount = typeof maxAmount !== 'undefined';\n const hasAuthId = typeof authId !== 'undefined';\n if (/\\.pox(-[2-3])?$/.test(contract)) {\n // .pox, .pox-2 or .pox-3\n if (signerKey \|\| signerSignature \|\| hasMaxAmount \|\| hasAuthId) {\n throw new Error(\n 'PoX-1, PoX-2 and PoX-3 do not accept a `signerKey`, `signerSignature`, `maxAmount` or `authId`'\n );\n }\n } else {\n // .pox-4 or later\n if (!signerKey \|\| !hasMaxAmount \|\| typeof authId === 'undefined') {\n throw new Error(\n 'PoX-4 requires a `signerKey` (buff 33), `maxAmount` (uint), and `authId` (uint)'\n );\n }\n }\n}\n\nexport enum Pox4SignatureTopic {\n StackStx = 'stack-stx',\n AggregateCommit = 'agg-commit',\n AggregateIncrease = 'agg-increase',\n StackExtend = 'stack-extend',\n StackIncrease = 'stack-increase',\n}\n\nexport interface Pox4SignatureOptions {\n /* topic of the signature (i.e. which stacking operation the signature is used for) /\n topic: `${Pox4SignatureTopic}` \| Pox4SignatureTopic;\n poxAddress: string;\n /* current reward cycle /\n rewardCycle: number;\n /* lock period (in cycles) /\n period: number;\n network: StacksNetworkName \| StacksNetwork;\n /* Maximum amount of uSTX that can be locked during this function call /\n maxAmount: IntegerType;\n /* Random integer to prevent signature re-use /\n authId: IntegerType;\n}\n\n/\n Generate a signature (`signer-sig` in PoX-4 stacking operations).\n /\nexport function signPox4SignatureHash({\n topic,\n poxAddress,\n rewardCycle,\n period,\n network,\n privateKey,\n maxAmount,\n authId,\n}: Pox4SignatureOptions & { privateKey: PrivateKey }) {\n return signStructuredData({\n ...pox4SignatureMessage({ topic, poxAddress, rewardCycle, period, network, maxAmount, authId }),\n privateKey,\n });\n}\n\n/\n Verify a signature (`signer-sig` in PoX-4 stacking operations) matches the given\n * public key (`signer-key`) and the structured data of the operation.\n /\nexport function verifyPox4SignatureHash({\n topic,\n poxAddress,\n rewardCycle,\n period,\n network,\n publicKey,\n signature,\n maxAmount,\n authId,\n}: Pox4SignatureOptions & { publicKey: string; signature: string }) {\n return verifyMessageSignatureRsv({\n message: sha256(\n encodeStructuredDataBytes(\n pox4SignatureMessage({ topic, poxAddress, rewardCycle, period, network, maxAmount, authId })\n )\n ),\n publicKey,\n signature,\n });\n}\n\n/\n Helper method used to generate SIP018 `message` and `domain` in\n * {@link signPox4SignatureHash} and {@link verifyPox4SignatureHash}.\n /\nexport function pox4SignatureMessage({\n topic,\n poxAddress,\n rewardCycle,\n period: lockPeriod,\n network: networkOrName,\n maxAmount,\n authId,\n}: Pox4SignatureOptions) {\n const network = networkFrom(networkOrName);\n const message = tupleCV({\n 'pox-addr': poxAddressToTuple(poxAddress),\n 'reward-cycle': uintCV(rewardCycle),\n topic: stringAsciiCV(topic),\n period: uintCV(lockPeriod),\n 'max-amount': uintCV(maxAmount),\n 'auth-id': uintCV(authId),\n });\n const domain = tupleCV({\n name: stringAsciiCV('pox-4-signer'),\n version: stringAsciiCV('1.0.0'),\n 'chain-id': uintCV(network.chainId),\n });\n return { message, domain };\n}\n","import { ClientOpts, IntegerType, PrivateKey, hexToBytes, intToBigInt } from '@stacks/common';\nimport {\n ChainId,\n NetworkClientParam,\n StacksNetwork,\n clientFromNetwork,\n networkFrom,\n} from '@stacks/network';\nimport {\n BurnchainRewardListResponse,\n BurnchainRewardSlotHolderListResponse,\n BurnchainRewardsTotal,\n} from '@stacks/stacks-blockchain-api-types';\nimport type { ContractIdString } from '@stacks/transactions';\nimport {\n BufferCV,\n ClarityType,\n ClarityValue,\n ContractCallOptions,\n ContractCallPayload,\n OptionalCV,\n PrincipalCV,\n ResponseErrorCV,\n StacksTransactionWire,\n TupleCV,\n TxBroadcastResult,\n UIntCV,\n broadcastTransaction,\n bufferCV,\n cvToString,\n fetchCallReadOnlyFunction,\n getFee,\n makeContractCall,\n noneCV,\n principalCV,\n someCV,\n stringAsciiCV,\n uintCV,\n validateStacksAddress,\n} from '@stacks/transactions';\nimport { PoxOperationPeriod, StackingErrors } from './constants';\nimport {\n Pox4SignatureTopic,\n ensureLegacyBtcAddressForPox1,\n ensurePox2Activated,\n ensureSignerArgsReadiness,\n poxAddressToTuple,\n signPox4SignatureHash,\n unwrap,\n unwrapMap,\n} from './utils';\n\nexport from './utils';\n\n/** @internal /\ninterface BaseTxOptions {\n /* the fee for the transaction /\n fee?: IntegerType;\n /* the nonce for the transaction /\n nonce?: IntegerType;\n /* the private key (aka `senderkey`) for the transaction /\n privateKey: string;\n}\n\nexport interface CycleInfo {\n id: number;\n min_threshold_ustx: number;\n stacked_ustx: number;\n is_pox_active: boolean;\n}\n\nexport interface ContractVersion {\n contract_id: string;\n activation_burnchain_block_height: number;\n first_reward_cycle_id: number;\n}\n\nexport interface PoxInfo {\n contract_id: string;\n contract_versions: ContractVersion[];\n current_burnchain_block_height?: number;\n first_burnchain_block_height: number;\n min_amount_ustx: string;\n next_reward_cycle_in: number;\n prepare_cycle_length: number;\n prepare_phase_block_length: number;\n reward_cycle_id: number;\n reward_cycle_length: number;\n reward_phase_block_length: number;\n reward_slots: number;\n current_cycle: CycleInfo;\n next_cycle: CycleInfo & {\n min_increment_ustx: number;\n prepare_phase_start_block_height: number;\n blocks_until_prepare_phase: number;\n reward_phase_start_block_height: number;\n blocks_until_reward_phase: number;\n ustx_until_pox_rejection: number;\n };\n}\n\nexport type PoxOperationInfo = {\n /* @deprecated Period isn't needed anymore after 2.1 fork went live /\n period: PoxOperationPeriod;\n pox1: { contract_id: string };\n pox2: ContractVersion;\n pox3: ContractVersion;\n pox4: ContractVersion;\n current: ContractVersion;\n};\n\nexport type StackerInfo =\n \| {\n stacked: false;\n }\n \| {\n stacked: true;\n details: {\n first_reward_cycle: number;\n lock_period: number;\n unlock_height: number;\n pox_address: {\n version: Uint8Array;\n hashbytes: Uint8Array;\n };\n };\n };\n\nexport type DelegationInfo =\n \| {\n delegated: false;\n }\n \| {\n delegated: true;\n details: {\n amount_micro_stx: bigint;\n delegated_to: string;\n pox_address?: {\n version: number;\n hashbytes: Uint8Array;\n };\n until_burn_ht?: number;\n };\n };\n\nexport interface RewardSetOptions {\n contractId: string;\n rewardCyleId: number;\n rewardSetIndex: number;\n}\n\nexport interface RewardSetInfo {\n pox_address: {\n version: Uint8Array;\n hashbytes: Uint8Array;\n };\n total_ustx: bigint;\n}\n\nexport interface StackingEligibility {\n eligible: boolean;\n reason?: string;\n}\n\n/\n Lock stx check options\n /\nexport interface CanLockStxOptions {\n /* the reward Bitcoin address /\n poxAddress: string;\n /* number of cycles to lock /\n cycles: number;\n}\n\n/\n Lock stx options\n /\nexport interface LockStxOptions {\n /* private key to sign transaction /\n privateKey: string;\n /* number of cycles to lock /\n cycles: number;\n /* the reward Bitcoin address /\n poxAddress: string;\n /* number of microstacks to lock /\n amountMicroStx: IntegerType;\n /* the burnchain block height to begin lock /\n burnBlockHeight: number;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\n/\n Stack extend stx options\n /\nexport interface StackExtendOptions {\n /* private key to sign transaction /\n privateKey: string;\n /* number of cycles to extend by /\n extendCycles: number;\n /* the reward Bitcoin address /\n poxAddress: string;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\n/\n Stack increase stx options\n /\nexport interface StackIncreaseOptions {\n /* private key to sign transaction /\n privateKey: string;\n /* number of ustx to increase by /\n increaseBy: IntegerType;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\n/\n Delegate stx options\n /\nexport interface DelegateStxOptions {\n /* number of microstacks to delegate /\n amountMicroStx: IntegerType;\n /* the STX address of the delegatee /\n delegateTo: string;\n /* the burnchain block height after which delegation is revoked /\n untilBurnBlockHeight?: number;\n /* the reward Bitcoin address of the delegator /\n poxAddress?: string;\n /* private key to sign transaction /\n privateKey: string;\n}\n\n/\n Delegate stack stx options\n /\nexport interface DelegateStackStxOptions {\n /* private key to sign transaction /\n privateKey: string;\n /* the STX address of the delegator /\n stacker: string;\n /* number of microstacks to lock /\n amountMicroStx: IntegerType;\n /* the reward Bitcoin address of the delegator /\n poxAddress: string;\n /* the burnchain block height to begin lock /\n burnBlockHeight: number;\n /* number of cycles to lock /\n cycles: number;\n}\n\n/\n Delegate stack extend options\n /\nexport interface DelegateStackExtendOptions {\n /* the STX address of the delegator /\n stacker: string;\n /* the reward Bitcoin address of the delegator /\n poxAddress: string;\n /* number of cycles to extend by /\n extendCount: number;\n /* private key to sign transaction /\n privateKey: string;\n}\n\n/\n Delegate stack increase options\n /\nexport interface DelegateStackIncreaseOptions {\n /* the STX address of the delegator /\n stacker: string;\n /* the reward Bitcoin address of the delegator /\n poxAddress: string;\n /* number of ustx to increase by /\n increaseBy: IntegerType;\n /* private key to sign transaction /\n privateKey: string;\n /* nonce for the transaction /\n nonce?: IntegerType;\n}\n\nexport interface StackAggregationCommitOptions {\n poxAddress: string;\n rewardCycle: number;\n privateKey: string;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\nexport interface StackAggregationIncreaseOptions {\n poxAddress: string;\n rewardCycle: number;\n rewardIndex: number;\n privateKey: string;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\nexport class StackingClient {\n public address: string;\n public network: StacksNetwork;\n\n public client: Required<ClientOpts>;\n\n // todo: make more constructor opts optional\n constructor(opts: { address: string } & NetworkClientParam) {\n this.address = opts.address;\n this.network = networkFrom(opts.network ?? 'mainnet');\n this.client = Object.assign({}, clientFromNetwork(this.network), opts.client);\n }\n\n get baseUrl() {\n return this.client.baseUrl;\n }\n\n get fetch() {\n return this.client.fetch;\n }\n\n /* @deprecated Kept for backwards compatibility, may be removed in the future /\n getCoreInfo(): Promise<V2CoreInfoResponse> {\n return this.client.fetch(`${this.client.baseUrl}/v2/info`).then(res => res.json());\n }\n\n /* @deprecated Kept for backwards compatibility, may be removed in the future /\n getPoxInfo(): Promise<V2PoxInfoResponse> {\n return this.client.fetch(`${this.client.baseUrl}/v2/pox`).then(res => res.json());\n }\n\n /* @deprecated Kept for backwards compatibility, may be removed in the future /\n async getTargetBlockTime(): Promise<number> {\n const res = await this.client\n .fetch(`${this.client.baseUrl}/extended/v1/info/network_block_times`)\n .then((res: any): V1InfoBlockTimesResponse => res.json());\n\n if (this.network.chainId === ChainId.Mainnet) return res.mainnet.target_block_time;\n return res.testnet.target_block_time;\n }\n\n /* Get account status /\n async getAccountStatus(): Promise<any> {\n // todo: add types for response\n return this.client\n .fetch(`${this.client.baseUrl}/v2/accounts/${this.address}?proof=0`)\n .then(res => res.json())\n .then(json => {\n json.balance = BigInt(json.balance);\n json.locked = BigInt(json.locked);\n return json;\n });\n }\n\n /* Get account balance /\n async getAccountBalance(): Promise<bigint> {\n return this.getAccountStatus().then(a => a.balance);\n }\n\n /* Get extended account balances /\n async getAccountExtendedBalances(): Promise<ExtendedAccountBalances> {\n return this.client\n .fetch(`${this.client.baseUrl}/extended/v1/address/${this.address}/balances`)\n .then(res => res.json())\n .then(json => {\n json.stx.balance = BigInt(json.stx.balance);\n json.stx.total_sent = BigInt(json.stx.total_sent);\n json.stx.total_received = BigInt(json.stx.total_received);\n json.stx.locked = BigInt(json.stx.locked);\n return json;\n });\n }\n\n /* Get account balance of locked tokens /\n async getAccountBalanceLocked(): Promise<bigint> {\n return this.getAccountStatus().then(a => a.locked);\n }\n\n /* Get reward cycle duration in seconds /\n async getCycleDuration(): Promise<number> {\n const poxInfoPromise = this.getPoxInfo();\n const targetBlockTimePromise = await this.getTargetBlockTime();\n\n return Promise.all([poxInfoPromise, targetBlockTimePromise]).then(\n ([poxInfo, targetBlockTime]) => {\n return poxInfo.reward_cycle_length targetBlockTime;\n }\n );\n }\n\n /** Get the total burnchain rewards total for the set address /\n async getRewardsTotalForBtcAddress(): Promise<BurnchainRewardsTotal \| BaseErrorResponse> {\n return this.client\n .fetch(`${this.client.baseUrl}/extended/v1/burnchain/rewards/${this.address}/total`)\n .then(res => res.json())\n .then(json => {\n json.reward_amount = BigInt(json.reward_amount);\n return json;\n });\n }\n\n /* Get burnchain rewards for the set address /\n async getRewardsForBtcAddress(\n options?: PaginationOptions\n ): Promise<BurnchainRewardListResponse \| BaseErrorResponse> {\n let url = `${this.client.baseUrl}/extended/v1/burnchain/rewards/${this.address}`;\n if (options) url += `?limit=${options.limit}&offset=${options.offset}`;\n\n return this.client.fetch(url).then(res => res.json());\n }\n\n /* Get burnchain rewards holders for the set address /\n async getRewardHoldersForBtcAddress(\n options?: PaginationOptions\n ): Promise<BurnchainRewardSlotHolderListResponse \| BaseErrorResponse> {\n let url = `${this.client.baseUrl}/extended/v1/burnchain/reward_slot_holders/${this.address}`;\n if (options) url += `?limit=${options.limit}&offset=${options.offset}`;\n\n return this.client.fetch(url).then(res => res.json());\n }\n\n /* Get PoX address from reward set by index (if it exists) /\n async getRewardSet(options: RewardSetOptions): Promise<RewardSetInfo \| undefined> {\n const [contractAddress, contractName] = this.parseContractId(options?.contractId);\n const result = await fetchCallReadOnlyFunction({\n client: this.client,\n senderAddress: this.address,\n contractAddress,\n contractName,\n functionArgs: [uintCV(options.rewardCyleId), uintCV(options.rewardSetIndex)],\n functionName: 'get-reward-set-pox-address',\n });\n\n return unwrapMap(result as OptionalCV<TupleCV>, tuple => ({\n pox_address: {\n version: hexToBytes(\n ((tuple.value['pox-addr'] as TupleCV).value['version'] as BufferCV).value\n ),\n hashbytes: hexToBytes(\n ((tuple.value['pox-addr'] as TupleCV).value['hashbytes'] as BufferCV).value\n ),\n },\n total_ustx: BigInt((tuple.value['total-ustx'] as UIntCV).value),\n }));\n }\n\n /\n Get number of seconds until next reward cycle\n * @see {@link getSecondsUntilStackingDeadline}\n /\n async getSecondsUntilNextCycle(): Promise<number> {\n const poxInfoPromise = this.getPoxInfo();\n const targetBlockTimePromise = this.getTargetBlockTime();\n const coreInfoPromise = this.getCoreInfo();\n\n return Promise.all([poxInfoPromise, targetBlockTimePromise, coreInfoPromise]).then(\n ([poxInfo, targetBlockTime, coreInfo]) => {\n const blocksToNextCycle =\n poxInfo.reward_cycle_length -\n ((coreInfo.burn_block_height - poxInfo.first_burnchain_block_height) %\n poxInfo.reward_cycle_length);\n return blocksToNextCycle targetBlockTime;\n }\n );\n }\n\n /*\n Get number of seconds until the end of the stacking deadline.\n * This is the estimated time stackers have to submit their stacking\n * transactions to be included in the upcoming reward cycle.\n * @returns number of seconds\n * ⚠️ Attention: The returned number of seconds can be negative if the deadline has passed and the prepare phase has started.\n * @see {@link getSecondsUntilNextCycle}\n /\n async getSecondsUntilStackingDeadline(): Promise<number> {\n const poxInfoPromise = this.getPoxInfo();\n const targetBlockTimePromise = this.getTargetBlockTime();\n\n return Promise.all([poxInfoPromise, targetBlockTimePromise]).then(\n ([poxInfo, targetBlockTime]) =>\n poxInfo.next_cycle.blocks_until_prepare_phase targetBlockTime\n );\n }\n\n /*\n Get information on current PoX operation\n \n Periods:\n * - Period 1: This is before the 2.1 fork.\n * - Period 2: This is after the 2.1 fork, but before cycle (N+1).\n * - Period 3: This is after cycle (N+1) has begun. Original PoX contract state will no longer have any impact on reward sets, account lock status, etc.\n /\n async getPoxOperationInfo(poxInfo?: V2PoxInfoResponse): Promise<PoxOperationInfo> {\n poxInfo = poxInfo ?? (await this.getPoxInfo());\n\n const poxContractVersions = [...poxInfo.contract_versions].sort(\n (a, b) => a.activation_burnchain_block_height - b.activation_burnchain_block_height\n ); // by activation height ASC (earliest first)\n const [pox1, pox2, pox3, pox4] = poxContractVersions;\n\n const activatedPoxs = poxContractVersions.filter(\n (c: ContractVersionResponse) =>\n (poxInfo?.current_burnchain_block_height as number) >= c.activation_burnchain_block_height\n );\n const current = activatedPoxs[activatedPoxs.length - 1];\n\n return { period: PoxOperationPeriod.Period3, pox1, pox2, pox3, pox4, current };\n }\n\n /\n Check if account has minimum require amount of Stacks for stacking\n * @returns {Promise<boolean>} that resolves to a bool if the operation succeeds\n /\n async hasMinimumStx(): Promise<boolean> {\n const balance = await this.getAccountBalance();\n const min = BigInt((await this.getPoxInfo()).min_amount_ustx);\n return balance >= min;\n }\n\n /\n readonly `can-stack-stx`\n \n Check if account can lock stx\n * @param {CanLockStxOptions} options - a required lock STX options object\n * @returns {Promise<StackingEligibility>} that resolves to a StackingEligibility object if the operation succeeds\n /\n async canStack({ poxAddress, cycles }: CanLockStxOptions): Promise<StackingEligibility> {\n const balancePromise: Promise<bigint> = this.getAccountBalance();\n const poxInfoPromise = this.getPoxInfo();\n\n return Promise.all([balancePromise, poxInfoPromise])\n .then(([balance, poxInfo]) => {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(poxInfo.contract_id);\n\n return fetchCallReadOnlyFunction({\n client: this.client,\n contractName,\n contractAddress,\n functionName: 'can-stack-stx',\n senderAddress: this.address,\n functionArgs: [\n address,\n uintCV(balance.toString()),\n uintCV(poxInfo.reward_cycle_id),\n uintCV(cycles.toString()),\n ],\n });\n })\n .then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.ResponseOk) {\n return {\n eligible: true,\n };\n } else {\n const errorCV = responseCV as ResponseErrorCV;\n return {\n eligible: false,\n reason: StackingErrors[+cvToString(errorCV.value)],\n };\n }\n });\n }\n\n /\n `stack-stx`\n \n Generate and broadcast a stacking transaction to lock STX\n * @param {LockStxOptions} options - a required lock STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async stack({\n amountMicroStx,\n poxAddress,\n cycles,\n burnBlockHeight,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: LockStxOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n\n const contract = await this.getStackingContract(poxOperationInfo);\n\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n ensureSignerArgsReadiness({ contract, signerKey, signerSignature, maxAmount, authId });\n\n const callOptions = this.getStackOptions({\n contract,\n amountMicroStx,\n cycles,\n poxAddress,\n burnBlockHeight,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n `stack-extend`\n \n Generate and broadcast a stacking transaction to extend locked STX (`pox-2.stack-extend`)\n * @category PoX-2\n * @param {StackExtendOptions} - a required extend STX options object\n * @returns a broadcasted txid if the operation succeeds\n /\n async stackExtend({\n extendCycles,\n poxAddress,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackExtendOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n\n ensurePox2Activated(poxOperationInfo);\n ensureSignerArgsReadiness({\n contract: poxInfo.contract_id,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n\n const callOptions = this.getStackExtendOptions({\n contract: poxInfo.contract_id,\n extendCycles,\n poxAddress,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n Generate and broadcast a stacking transaction to increase locked STX (`pox-2.stack-increase`)\n * @category PoX-2\n * @param {StackIncreaseOptions} - a required increase STX options object\n * @returns a broadcasted txid if the operation succeeds\n /\n async stackIncrease({\n increaseBy,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackIncreaseOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n ensurePox2Activated(poxOperationInfo);\n ensureSignerArgsReadiness({\n contract: poxInfo.contract_id,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n\n const callOptions = this.getStackIncreaseOptions({\n contract: poxInfo.contract_id,\n increaseBy,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n `delegate-stx`\n \n As a delegatee, generate and broadcast a transaction to create a delegation relationship\n * @param {DelegateStxOptions} options - a required delegate STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async delegateStx({\n amountMicroStx,\n delegateTo,\n untilBurnBlockHeight,\n poxAddress,\n ...txOptions\n }: // todo: should we provide manual contract definitions? (for users to choose which contract to use)\n DelegateStxOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n\n const contract = await this.getStackingContract(poxOperationInfo);\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n\n const callOptions = this.getDelegateOptions({\n contract,\n amountMicroStx,\n delegateTo,\n untilBurnBlockHeight,\n poxAddress,\n });\n\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n `delegate-stack-stx`\n \n As a delegator, generate and broadcast transactions to stack for multiple delegatees. This will lock up tokens owned by the delegatees.\n * @param {DelegateStackStxOptions} options - a required delegate stack STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async delegateStackStx({\n stacker,\n amountMicroStx,\n poxAddress,\n burnBlockHeight,\n cycles,\n ...txOptions\n }: DelegateStackStxOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n\n const contract = await this.getStackingContract(poxOperationInfo);\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n\n const callOptions = this.getDelegateStackOptions({\n contract,\n stacker,\n amountMicroStx,\n poxAddress,\n burnBlockHeight,\n cycles,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n `delegate-stack-extend`\n \n As a delegator, generate and broadcast transactions to extend stack for multiple delegatees.\n * @category PoX-2\n * @param {DelegateStackExtendOptions} options - a required delegate stack extend STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async delegateStackExtend({\n stacker,\n poxAddress,\n extendCount,\n ...txOptions\n }: DelegateStackExtendOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const contract = poxInfo.contract_id;\n\n const callOptions = this.getDelegateStackExtendOptions({\n contract,\n stacker,\n poxAddress,\n extendCount,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegator, generate and broadcast transactions to stack increase for multiple delegatees.\n * @category PoX-2\n * @param {DelegateStackIncreaseOptions} - a required delegate stack increase STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async delegateStackIncrease({\n stacker,\n poxAddress,\n increaseBy,\n ...txOptions\n }: DelegateStackIncreaseOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n ensurePox2Activated(poxOperationInfo);\n\n const callOptions = this.getDelegateStackIncreaseOptions({\n contract: poxInfo.contract_id,\n stacker,\n poxAddress,\n increaseBy,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegator, generate and broadcast a transaction to commit partially committed delegatee tokens\n * @param {StackAggregationCommitOptions} options - a required stack aggregation commit options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async stackAggregationCommit({\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackAggregationCommitOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const contract = await this.getStackingContract();\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n ensureSignerArgsReadiness({ contract, signerKey, signerSignature, maxAmount, authId });\n\n const callOptions = this.getStackAggregationCommitOptions({\n contract,\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegator, generate and broadcast a transaction to commit partially committed delegatee tokens\n \n Commit partially stacked STX and allocate a new PoX reward address slot.\n * This allows a stacker/delegate to lock fewer STX than the minimal threshold in multiple transactions,\n * so long as: 1. The pox-addr is the same.\n * 2. This \"commit\" transaction is called _before_ the PoX anchor block.\n * This ensures that each entry in the reward set returned to the stacks-node is greater than the threshold,\n * but does not require it be all locked up within a single transaction\n \n `stack-aggregation-commit-indexed` returns (ok uint) on success, where the given uint is the reward address's index in the list of reward\n * addresses allocated in this reward cycle. This index can then be passed to `stack-aggregation-increase`\n * to later increment the STX this PoX address represents, in amounts less than the stacking minimum.\n \n @category PoX-2\n * @param {StackAggregationCommitOptions} options - a required stack aggregation commit options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async stackAggregationCommitIndexed({\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackAggregationCommitOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const contract = await this.getStackingContract();\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n ensureSignerArgsReadiness({ contract, signerKey, signerSignature, maxAmount, authId });\n\n const callOptions = this.getStackAggregationCommitOptionsIndexed({\n contract,\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegator, generate and broadcast a transaction to increase partial commitment committed delegatee tokens\n * @param {StackAggregationIncreaseOptions} options - a required stack aggregation increase options object\n * @category PoX-2\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async stackAggregationIncrease({\n poxAddress,\n rewardCycle,\n rewardIndex,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackAggregationIncreaseOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n // todo: deprecate this method in favor of Indexed as soon as PoX-2 is live\n const contract = await this.getStackingContract();\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n ensureSignerArgsReadiness({ contract, signerKey, signerSignature, maxAmount, authId });\n\n const callOptions = this.getStackAggregationIncreaseOptions({\n contract,\n poxAddress,\n rewardCycle,\n rewardCycleIndex: rewardIndex,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegatee, generate and broadcast a transaction to terminate the delegation relationship\n * @param {string} privateKey - the private key to be used for the revoke call\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async revokeDelegateStx(privateKey: string): Promise<TxBroadcastResult>;\n /\n As a delegatee, generate and broadcast a transaction to terminate the delegation relationship\n * @param {BaseTxOptions} txOptions - the private key, fee, and nonce to be used for the revoke call\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async revokeDelegateStx(txOptions: BaseTxOptions): Promise<TxBroadcastResult>;\n async revokeDelegateStx(arg: string \| BaseTxOptions): Promise<TxBroadcastResult> {\n if (typeof arg === 'string') arg = { privateKey: arg };\n\n const poxInfo = await this.getPoxInfo();\n const contract = poxInfo.contract_id;\n\n const callOptions = this.getRevokeDelegateStxOptions(contract);\n\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(arg),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n getStackOptions({\n amountMicroStx,\n poxAddress,\n cycles,\n contract,\n burnBlockHeight,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n cycles: number;\n poxAddress: string;\n amountMicroStx: IntegerType;\n contract: string;\n burnBlockHeight: number;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [\n uintCV(amountMicroStx),\n address,\n uintCV(burnBlockHeight),\n uintCV(cycles),\n ] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-stx',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getStackExtendOptions({\n extendCycles,\n poxAddress,\n contract,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n extendCycles: number;\n poxAddress: string;\n contract: string;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [uintCV(extendCycles), address] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-extend',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getStackIncreaseOptions({\n increaseBy,\n contract,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n increaseBy: IntegerType;\n contract: string;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [uintCV(increaseBy)] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-increase',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getDelegateOptions({\n contract,\n amountMicroStx,\n delegateTo,\n untilBurnBlockHeight,\n poxAddress,\n }: {\n contract: string;\n amountMicroStx: IntegerType;\n delegateTo: string;\n untilBurnBlockHeight?: number;\n poxAddress?: string;\n }) {\n const address = poxAddress ? someCV(poxAddressToTuple(poxAddress)) : noneCV();\n const [contractAddress, contractName] = this.parseContractId(contract);\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'delegate-stx',\n functionArgs: [\n uintCV(amountMicroStx),\n principalCV(delegateTo),\n untilBurnBlockHeight ? someCV(uintCV(untilBurnBlockHeight)) : noneCV(),\n address,\n ],\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getDelegateStackOptions({\n contract,\n stacker,\n amountMicroStx,\n poxAddress,\n burnBlockHeight,\n cycles,\n }: {\n contract: string;\n stacker: string;\n amountMicroStx: IntegerType;\n poxAddress: string;\n burnBlockHeight: number;\n cycles: number;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'delegate-stack-stx',\n functionArgs: [\n principalCV(stacker),\n uintCV(amountMicroStx),\n address,\n uintCV(burnBlockHeight),\n uintCV(cycles),\n ],\n validateWithAbi: true,\n network: this.network,\n };\n\n return callOptions;\n }\n\n getDelegateStackExtendOptions({\n contract,\n stacker,\n poxAddress,\n extendCount,\n }: {\n contract: string;\n stacker: string;\n poxAddress: string;\n extendCount: number;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'delegate-stack-extend',\n functionArgs: [principalCV(stacker), address, uintCV(extendCount)],\n validateWithAbi: true,\n network: this.network,\n };\n\n return callOptions;\n }\n\n getDelegateStackIncreaseOptions({\n contract,\n stacker,\n poxAddress,\n increaseBy,\n }: {\n contract: string;\n stacker: string;\n poxAddress: string;\n increaseBy: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'delegate-stack-increase',\n functionArgs: [principalCV(stacker), address, uintCV(increaseBy)],\n validateWithAbi: true,\n network: this.network,\n };\n\n return callOptions;\n }\n\n getStackAggregationCommitOptions({\n contract,\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n contract: string;\n poxAddress: string;\n rewardCycle: number;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [address, uintCV(rewardCycle)] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-aggregation-commit',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getStackAggregationIncreaseOptions({\n contract,\n poxAddress,\n rewardCycle,\n rewardCycleIndex,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n contract: string;\n poxAddress: string;\n rewardCycle: number;\n rewardCycleIndex: number;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [address, uintCV(rewardCycle), uintCV(rewardCycleIndex)] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-aggregation-increase',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getStackAggregationCommitOptionsIndexed({\n contract,\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n contract: string;\n poxAddress: string;\n rewardCycle: number;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [address, uintCV(rewardCycle)] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-aggregation-commit-indexed',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getRevokeDelegateStxOptions(contract: string) {\n const [contractAddress, contractName] = this.parseContractId(contract);\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'revoke-delegate-stx',\n functionArgs: [],\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n /\n Check stacking status\n \n @returns {Promise<StackerInfo>} that resolves to a StackerInfo object if the operation succeeds\n /\n async getStatus(): Promise<StackerInfo> {\n const poxInfo = await this.getPoxInfo();\n const [contractAddress, contractName] = this.parseContractId(poxInfo.contract_id);\n const account = await this.getAccountStatus();\n const functionName = 'get-stacker-info';\n\n return fetchCallReadOnlyFunction({\n contractAddress,\n contractName,\n functionName,\n senderAddress: this.address,\n functionArgs: [principalCV(this.address)],\n client: this.client,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.OptionalSome) {\n const someCV = responseCV;\n const tupleCV: TupleCV = someCV.value as TupleCV;\n const poxAddress: TupleCV = tupleCV.value['pox-addr'] as TupleCV;\n const firstRewardCycle: UIntCV = tupleCV.value['first-reward-cycle'] as UIntCV;\n const lockPeriod: UIntCV = tupleCV.value['lock-period'] as UIntCV;\n const version: BufferCV = poxAddress.value['version'] as BufferCV;\n const hashbytes: BufferCV = poxAddress.value['hashbytes'] as BufferCV;\n\n return {\n stacked: true,\n details: {\n first_reward_cycle: Number(firstRewardCycle.value),\n lock_period: Number(lockPeriod.value),\n unlock_height: account.unlock_height,\n pox_address: {\n version: hexToBytes(version.value),\n hashbytes: hexToBytes(hashbytes.value),\n },\n },\n };\n } else if (responseCV.type === ClarityType.OptionalNone) {\n return {\n stacked: false,\n };\n } else {\n throw new Error(`Error fetching stacker info`);\n }\n });\n }\n\n /\n Check delegation status\n \n @returns {Promise<DelegationInfo>} that resolves to a DelegationInfo object if the operation succeeds\n /\n async getDelegationStatus(): Promise<DelegationInfo> {\n const poxInfo = await this.getPoxInfo();\n const [contractAddress, contractName] = this.parseContractId(poxInfo.contract_id);\n const functionName = 'get-delegation-info';\n\n return fetchCallReadOnlyFunction({\n contractAddress,\n contractName,\n functionName,\n functionArgs: [principalCV(this.address)],\n senderAddress: this.address,\n client: this.client,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.OptionalSome) {\n const tupleCV = responseCV.value as TupleCV;\n const amountMicroStx = tupleCV.value['amount-ustx'] as UIntCV;\n const delegatedTo = tupleCV.value['delegated-to'] as PrincipalCV;\n\n const poxAddress = unwrapMap(tupleCV.value['pox-addr'] as OptionalCV<TupleCV>, tuple => ({\n version: hexToBytes((tuple.value['version'] as BufferCV).value)[0],\n hashbytes: hexToBytes((tuple.value['hashbytes'] as BufferCV).value),\n }));\n const untilBurnBlockHeight = unwrap(tupleCV.value['until-burn-ht'] as OptionalCV<UIntCV>);\n\n return {\n delegated: true,\n details: {\n amount_micro_stx: BigInt(amountMicroStx.value),\n delegated_to: delegatedTo.value,\n pox_address: poxAddress,\n until_burn_ht: untilBurnBlockHeight ? Number(untilBurnBlockHeight.value) : undefined,\n },\n };\n } else if (responseCV.type === ClarityType.OptionalNone) {\n return {\n delegated: false,\n };\n } else {\n throw new Error(`Error fetching delegation info`);\n }\n });\n }\n\n /\n Call the `verify-signer-key-sig` read-only function on the PoX contract.\n * @returns (async) a boolean indicating if the signature is valid\n /\n async verifySignerKeySignature({\n topic,\n poxAddress,\n rewardCycle,\n period,\n signerSignature,\n signerKey,\n amount,\n maxAmount,\n authId,\n }: {\n topic: string;\n poxAddress: string;\n rewardCycle: number;\n period: number;\n signerSignature?: string;\n signerKey: string;\n amount: IntegerType;\n maxAmount: IntegerType;\n authId: IntegerType;\n }): Promise<boolean> {\n const poxInfo = await this.getPoxInfo();\n\n const [contractAddress, contractName] = this.parseContractId(poxInfo.contract_id);\n const functionName = 'verify-signer-key-sig';\n\n const functionArgs = [\n poxAddressToTuple(poxAddress),\n uintCV(rewardCycle),\n stringAsciiCV(topic),\n uintCV(period),\n signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV(),\n bufferCV(hexToBytes(signerKey)),\n uintCV(amount),\n uintCV(maxAmount),\n uintCV(authId),\n ];\n\n return fetchCallReadOnlyFunction({\n contractAddress,\n contractName,\n functionName,\n functionArgs,\n senderAddress: this.address,\n client: this.client,\n }).then(responseCV => responseCV.type === ClarityType.ResponseOk);\n }\n\n /\n @returns {Promise<string>} that resolves to the contract id (address and name) to use for stacking\n /\n async getStackingContract(poxOperationInfo?: PoxOperationInfo): Promise<string> {\n poxOperationInfo = poxOperationInfo ?? (await this.getPoxOperationInfo());\n switch (poxOperationInfo.period) {\n case PoxOperationPeriod.Period1:\n return poxOperationInfo.pox1.contract_id;\n case PoxOperationPeriod.Period2a:\n case PoxOperationPeriod.Period2b:\n // in the 2.1 fork we can always stack to PoX-2\n return poxOperationInfo.pox2.contract_id;\n case PoxOperationPeriod.Period3:\n default:\n return poxOperationInfo.current.contract_id;\n }\n }\n\n /\n Adjust microstacks amount for locking after taking into account transaction fees\n \n @returns {StacksTransactionWire} that resolves to a transaction object if the operation succeeds\n /\n modifyLockTxFee({\n tx,\n amountMicroStx,\n }: {\n tx: StacksTransactionWire;\n amountMicroStx: IntegerType;\n }) {\n const fee = getFee(tx.auth);\n (tx.payload as ContractCallPayload).functionArgs[0] = uintCV(intToBigInt(amountMicroStx) - fee);\n return tx;\n }\n\n /\n Parses a contract identifier and ensures it is formatted correctly\n \n @returns {Array<string>} a contract address and name\n /\n parseContractId(contract: string): string[] {\n // todo: move this function to a standalone utility, and @ignore deprecate it here\n const parts = contract.split('.');\n\n if (parts.length === 2 && validateStacksAddress(parts[0]) && parts[1].startsWith('pox')) {\n return parts;\n }\n\n throw new Error('Stacking contract ID is malformed');\n }\n\n /\n Generates a `signer-sig` string for the current PoX contract.\n /\n signPoxSignature({\n topic,\n poxAddress,\n rewardCycle,\n period,\n signerPrivateKey,\n authId,\n maxAmount,\n }: {\n topic: `${Pox4SignatureTopic}`;\n poxAddress: string;\n rewardCycle: number;\n period: number;\n signerPrivateKey: PrivateKey;\n maxAmount: IntegerType;\n authId: IntegerType;\n }) {\n // todo: in the future add logic to determine if a later version of pox\n // needs a different domain and thus use a different `signPox4SignatureHash`\n return signPox4SignatureHash({\n topic,\n poxAddress,\n rewardCycle,\n period,\n network: this.network,\n privateKey: signerPrivateKey,\n maxAmount,\n authId,\n });\n }\n}\n\n/* @ignore Rename `privateKey` to `senderKey`, for backwards compatibility /\nfunction renamePrivateKey(txOptions: BaseTxOptions) {\n // @ts-ignore\n txOptions.senderKey = txOptions.privateKey;\n // @ts-ignore\n delete txOptions.privateKey;\n return txOptions as any as {\n fee?: IntegerType;\n nonce?: IntegerType;\n senderKey: string;\n };\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface V2CoreInfoResponse {\n burn_block_height: number;\n stable_pox_consensus: string;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface CycleInfoResponse {\n id: number;\n min_threshold_ustx: number;\n stacked_ustx: number;\n is_pox_active: boolean;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface ContractVersionResponse {\n contract_id: ContractIdString;\n activation_burnchain_block_height: number;\n first_reward_cycle_id: number;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface V2PoxInfoResponse {\n contract_id: string;\n contract_versions: ContractVersionResponse[];\n current_burnchain_block_height?: number;\n first_burnchain_block_height: number;\n min_amount_ustx: string;\n next_reward_cycle_in: number;\n prepare_cycle_length: number;\n prepare_phase_block_length: number;\n rejection_fraction: number;\n rejection_votes_left_required: number;\n reward_cycle_id: number;\n reward_cycle_length: number;\n reward_phase_block_length: number;\n reward_slots: number;\n current_cycle: CycleInfoResponse;\n next_cycle: CycleInfoResponse & {\n min_increment_ustx: number;\n prepare_phase_start_block_height: number;\n blocks_until_prepare_phase: number;\n reward_phase_start_block_height: number;\n blocks_until_reward_phase: number;\n ustx_until_pox_rejection: number;\n };\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface V1InfoBlockTimesResponse {\n mainnet: {\n target_block_time: number;\n };\n testnet: {\n target_block_time: number;\n };\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface ExtendedAccountBalancesResponse {\n stx: {\n balance: string;\n total_sent: string;\n total_received: string;\n locked: string;\n lock_tx_id: string;\n lock_height: number;\n burnchain_lock_height: number;\n burnchain_unlock_height: number;\n };\n fungible_tokens: any;\n non_fungible_tokens: any;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface ExtendedAccountBalances {\n stx: {\n balance: bigint;\n total_sent: bigint;\n total_received: bigint;\n locked: bigint;\n lock_tx_id: string;\n lock_height: number;\n burnchain_lock_height: number;\n burnchain_unlock_height: number;\n };\n fungible_tokens: any;\n non_fungible_tokens: any;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface PaginationOptions {\n limit: number;\n offset: number;\n}\n\n/* @beta @ignore Type export subject to change*/\nexport interface BaseErrorResponse {\n error: string;\n}\n"],"names":["root","factory","exports","module","define","amd","this","leafPrototypes","getProto","number","n","Number","isSafeInteger","Error","bool","b","bytes","lengths","Uint8Array","TypeError","length","includes","hash","create","outputLen","blockLen","exists","instance","checkFinished","destroyed","finished","output","out","min","Object","defineProperty","value","assert","SHA2","_assert_js_1","utils_js_1","Hash","constructor","padOffset","isLE","super","pos","buffer","view","createView","update","data","default","len","toBytes","take","Math","set","subarray","process","dataView","roundClean","digestInto","fill","i","byteOffset","setBigUint64","_32n","BigInt","_u32_max","wh","wl","h","l","setUint32","oview","outLen","state","get","digest","res","slice","destroy","_cloneInto","to","crypto","node","undefined","web","self","sha224","sha256","_sha2_js_1","Maj","a","c","SHA256_K","Uint32Array","IV","SHA256_W","SHA256","A","B","C","D","E","F","G","H","offset","getUint32","W15","W2","s0","rotr","s1","T1","T2","SHA224","wrapConstructor","randomBytes","wrapConstructorWithOpts","checkOpts","concatBytes","utf8ToBytes","asyncLoop","nextTick","hexToBytes","bytesToHex","u32","u8","crypto_1","arr","byteLength","floor","DataView","word","shift","hexes","Array","from","v","toString","padStart","str","TextEncoder","encode","uint8a","hex","array","j","hexByte","byte","parseInt","isNaN","async","iters","tick","cb","ts","Date","now","diff","arrays","every","reduce","result","pad","clone","defaults","opts","obj","prototype","call","assign","hashConstructor","hashC","message","tmp","hashCons","msg","bytesLength","getRandomValues","ALPHABET","BASE_MAP","x","charAt","xc","charCodeAt","BASE","LEADER","FACTOR","log","iFACTOR","decodeUnsafe","source","psz","zeroes","size","b256","carry","it3","it4","vch","ArrayBuffer","isView","isArray","pbegin","pend","b58","it1","it2","repeat","decode","string","lookup","revLookup","code","basex","c32ToB58","b58ToC32","c32addressDecode","c32address","versions","checksum_1","base58check","utils_1","mainnet","p2pkh","p2sh","testnet","ADDR_BITCOIN_TO_STACKS","ADDR_STACKS_TO_BITCOIN","version","hash160hex","match","c32checkEncode","c32addr","c32checkDecode","b58check","addrInfo","hash160String","addrVersion","prefix","stacksVersion","c32string","bitcoinVersion","sha256_1","dataBytes","prefixBytes","checksum","forEach","check","index","encoding_1","c32checksum","dataHex","dataHash","toLowerCase","versionHex","checksumHex","c32str","c32encode","c32","c32data","c32normalize","c32decode","versionChar","indexOf","substring","c32input","toUpperCase","replace","inputHex","minLength","currentCode","nextCode","nextBits","nextLowBits","curC32Digit","unshift","C32leadingZeros","zeroPrefix","TextDecoder","numLeadingZeroBytesInHex","count","join","numLeadingZeroBytes","carryBits","currentValue","currentHexDigit","hexLeadingZeros","hexStr","address_1","enumerable","HASH_UNDEFINED","MAX_SAFE_INTEGER","argsTag","boolTag","dateTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reFlags","reIsHostCtor","reIsUint","cloneableTags","freeGlobal","g","freeSelf","Function","freeExports","nodeType","freeModule","moduleExports","addMapEntry","map","pair","addSetEntry","add","arrayReduce","iteratee","accumulator","initAccum","isHostObject","e","mapToArray","key","overArg","func","transform","arg","setToArray","uid","arrayProto","funcProto","objectProto","coreJsData","maskSrcKey","exec","keys","IE_PROTO","funcToString","hasOwnProperty","objectToString","reIsNative","RegExp","Buffer","Symbol","getPrototype","getPrototypeOf","objectCreate","propertyIsEnumerable","splice","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeKeys","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","entries","clear","entry","ListCache","MapCache","Stack","__data__","assignValue","object","objValue","eq","assocIndexOf","baseClone","isDeep","isFull","customizer","stack","isObject","isArr","input","initCloneArray","copyArray","tag","getTag","isFunc","copy","cloneBuffer","isPrototype","proto","initCloneObject","copyObject","getSymbols","copySymbols","baseAssign","cloneFunc","symbol","Ctor","cloneArrayBuffer","cloneDataView","typedArray","cloneTypedArray","cloneMap","regexp","lastIndex","cloneRegExp","cloneSet","initCloneByTag","stacked","props","keysFunc","symbolsFunc","values","arrayPush","baseGetAllKeys","getAllKeys","arrayEach","subValue","arrayBuffer","newValue","getMapData","type","getValue","isFunction","test","baseIsNative","has","pop","push","cache","pairs","LARGE_ARRAY_SIZE","isIndex","other","resolve","ctorString","isArrayLike","isLength","inherited","isObjectLike","isArrayLikeObject","isArguments","baseTimes","String","skipIndexes","arrayLikeKeys","baseKeys","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","getter","__esModule","d","t","mode","then","ns","r","def","current","getOwnPropertyNames","definition","o","globalThis","window","prop","toStringTag","nmd","paths","children","intToBytes","isInteger","RangeError","without0x","hexToBigInt","intToHex","integer","bytesToTwosBigInt","width","nthBit","_","u","asciiToBytes","byteArray","bytesToAscii","fromCharCode","apply","isNotOctet","octet","octetsToBytes","numbers","some","elements","clazz","name","defaultFetchOpts","referrerPolicy","headers","fetchWrapper","init","fetchOpts","fetch","args","fetchLib","middlewares","argsForCreateFetchFn","url","fetchParams","middleware","pre","response","post","ChainId","PeerNetworkId","AddressVersion","TransactionVersion","Mainnet","chainId","transactionVersion","peerNetworkId","magicBytes","bootAddress","addressVersion","singleSig","MainnetSingleSig","multiSig","MainnetMultiSig","client","baseUrl","STACKS_TESTNET","Testnet","TestnetSingleSig","TestnetMultiSig","STACKS_DEVNET","STACKS_MOCKNET","StacksNetworks","network","networkFromName","TransactionError","captureStackTrace","SerializationError","NoEstimateAvailableError","SigningError","writeUInt8","destination","writeUInt32BE","writeUInt32LE","enumCheckFunctions","isEnum","enumVariable","checker","newChecker","enumValues","filter","enumValueSet","createEnumChecker","consumed","readBytes","readUInt32BE","readUInt8","readUInt16BE","readBigUIntLE","reverse","readBigUIntBE","readOffset","val","internalBytes","readUInt8Enum","invalidEnumErrorFormatter","num","MAX_STRING_LENGTH_BYTES","CLARITY_INT_SIZE","CLARITY_INT_BYTE_SIZE","AnchorMode","ClarityVersion","PayloadType","FungibleConditionCode","NonFungibleConditionCode","AssetType","TxRejectedReason","AuthFieldType","TenureChangeCause","PostConditionPrincipalId","PubKeyEncoding","AddressHashMode","AuthType","PostConditionType","PostConditionMode","OnChainOnly","OffChainOnly","Any","Rho","Id","Pi","idxL","idxR","k","shifts","shiftsL","idx","shiftsR","Kl","Kr","rotl","f","group","y","z","BUF","RIPEMD160","h0","h1","h2","h3","h4","al","ar","bl","br","cl","cr","dl","dr","el","er","rGroup","hbl","hbr","rl","rr","sl","sr","tl","tr","ripemd160","U32_MASK64","fromBig","le","lst","Ah","Al","s","Bh","Bl","Cl","low","Ch","Dl","Dh","Eh","El","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","s0l","W2h","W2l","s1h","s1l","SUMl","SUMh","sigma1h","sigma1l","CHIh","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","All","SHA512_224","SHA512_256","SHA384","sha512_256","_0n","_1n","_2n","_3n","_8n","CURVE","freeze","P","Gx","Gy","beta","divNearest","endo","splitScalar","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","JacobianPoint","fromAffine","p","equals","ZERO","toAffineBatch","points","toInv","nums","scratch","inverted","invert","acc","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","windowSize","mask","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","_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","sum","sliceDER","parseDERInt","Signature","fromCompact","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","hmac","hmacSha256","hmacSync","checkSync","incr","reseed","seed","reseedSync","generate","generateSync","kmdToSig","kBytes","lowS","kinv","sig","error","bits2int","bits2octets","z1","z2","int2octets","vopts","strict","publicKey","normalizePublicKey","sinv","TAGGED_HASH_PREFIXES","isValidPrivateKey","_bigintTo32Bytes","_normalizePrivateKey","hashToPrivateKey","minLen","randomPrivateKey","precompute","cached","messages","subtle","createHash","ckey","importKey","sign","createHmac","sha256Sync","hmacSha256Sync","taggedHash","tagP","tagH","taggedHashSync","_JacobianPoint","defineProperties","configurable","ClarityWireType","ClarityType","clarityTypeToByte","MAX_U128","MIN_U128","MAX_I128","MIN_I128","startsWith","bigInt","Int","UInt","BoolTrue","BoolFalse","StacksWireType","lengthPrefixBytes","LengthPrefixedList","MessageSignature","createLPString","content","maxLengthBytes","prefixLength","maxLength","LengthPrefixedString","c32AddressString","addressData","Address","hash160","pubKeyEncoding","contents","TransactionAuthField","HMAC","_key","iHash","oHash","buf","COORDINATE_BYTES","parseRecoverableSignatureVrs","recoveryIdHex","recoveryId","privateKeyBuffer","PublicKey","msgs","privateKeyIsCompressed","signWithKey","messageHash","rawSignature","privKey","extraEntropy","seedArgs","initSigArgs","drbg","canonical","recSig","der","recovered","hashed","finalizeSig","addressFromPublicKeys","hashMode","numSigs","publicKeys","P2PKH","P2WPKH","P2WSH","P2WSHNonSequential","hashP2WPKH","P2SH","P2SHNonSequential","hashP2SH","serializePublicKeyBytes","hashP2WSH","address","parseAssetString","assetAddress","assetContractName","assetTokenName","split","addressString","contractName","assetName","Asset","parsePrincipalString","principalString","addr","Principal","Contract","createContractPrincipal","Standard","createStandardPrincipal","principal","contractPrincipalCVFromAddress","PrincipalStandard","PrincipalContract","OptionalNone","OptionalSome","tupleCV","Tuple","StringASCII","StringUTF8","serializedClarityValue","bytesReader","hasHexPrefix","int","uint","bufferLength","true","false","deserializeAddress","contract","deserializeLPString","ok","ResponseOk","err","ResponseErr","responseErrorCV","none","list","listLength","listContents","List","tuple","tupleLength","tupleContents","clarityName","ascii","asciiStrLen","asciiStr","utf8","utf8StrLen","utf8Str","leftPadHex","hexString","rightPadHexToLength","padEnd","cloneDeep","txidFromData","keyHash","redeemScript","pubKeys","bytesArray","pubKey","scriptArray","script","parseReadOnlyResponse","okay","cause","bytesWithTypeID","typeId","serializeStringCV","cv","encoding","serializeBoolCV","ceil","serializeBufferCV","serializeUIntCV","toTwos","serializeIntCV","serializeAddressBytes","serializeStandardPrincipalCV","contractId","parseContractId","serializeLPStringBytes","serializeContractPrincipalCV","serializeResponseCV","serializedValue","serializeListCV","lexicographicOrder","sort","localeCompare","nameWithLength","serializeTupleCV","serializeStringAsciiCV","serializeStringUtf8CV","serializeStacksWireBytes","wire","serializePrincipalBytes","MemoString","memoString","contentBytes","paddedContent","serializeMemoStringBytes","serializeAssetBytes","PostCondition","postCondition","conditionType","Fungible","NonFungible","asset","conditionCode","STX","amount","serializePostConditionWireBytes","serializeLPListBytes","Payload","serializePayloadBytes","field","Compressed","PublicKeyCompressed","PublicKeyUncompressed","SignatureCompressed","SignatureUncompressed","serializeMessageSignatureBytes","serializeTransactionAuthFieldBytes","serialized","lps","info","deserializeAsset","lpList","postConditionType","Origin","deserializePrincipal","payload","payloadType","TokenTransfer","recipient","memo","ContractCall","contractAddress","functionName","numArgs","functionArgs","SmartContract","codeBody","VersionedSmartContract","clarityVersion","PoisonMicroblock","Coinbase","coinbaseBytes","CoinbaseToAltRecipient","NakamotoCoinbase","vrfProof","TenureChange","tenureHash","previousTenureHash","burnViewHash","previousTenureEnd","previousTenureBlocks","publicKeyHash","messageSignature","emptyMessageSignature","nonce","fee","signer","keyEncoding","Uncompressed","isSingleSig","isSequentialMultiSig","isNonSequentialMultiSig","clearCondition","cloned","fields","serializeSpendingConditionBytes","serializeSingleSigSpendingConditionBytes","writeUInt16BE","signaturesRequired","serializeMultiSigSpendingConditionBytes","sigHashPreSign","curSigHash","authType","sigHash","sigHashPostSign","hashLength","sigHashBytes","nextVerification","initialSigHash","sigHashPre","parsedSignature","compressed","publicKeyFromSignatureVrs","nextSigHash","spendingCondition","sponsorSpendingCondition","Sponsored","intoInitialSighashAuth","auth","newInitialSigHash","postConditions","postConditionMode","Deny","anchorMode","signBegin","tx","txid","verifyBegin","verifyOrigin","addrBytes","verifySingleSig","haveUncompressed","verifyMultiSig","signNextOrigin","signAndAppend","signNextSponsor","appendPubkey","cond","nextSig","nextSignature","serializeBytes","setSponsor","setFee","setNonce","setSponsorNonce","serialize","chainIdBytes","serializeAuthorizationBytes","transaction","TRANSFER_FEE_ESTIMATE_PATH","TRANSACTION_FEE_ESTIMATE_PATH","ACCOUNT_PATH","CONTRACT_ABI_PATH","broadcastTransaction","txOpt","attachment","attachOpt","_network","_client","json","options","method","body","JSON","stringify","text","fetchCallReadOnlyFunction","senderAddress","sender","arguments","encodeURIComponent","catch","status","statusText","cvToString","getCVTypeString","ClarityAbiTypeId","isClarityAbiPrimitive","isClarityAbiBuffer","isClarityAbiStringAscii","isClarityAbiStringUtf8","isClarityAbiResponse","isClarityAbiOptional","optional","isClarityAbiTuple","isClarityAbiList","getTypeString","matchType","abiType","union","ClarityAbiTypeUInt128","ClarityAbiTypeInt128","ClarityAbiTypeBool","ClarityAbiTypePrincipal","ClarityAbiTypeTraitReference","ClarityAbiTypeNone","ClarityAbiTypeBuffer","ClarityAbiTypeResponse","ClarityAbiTypeOptional","ClarityAbiTypeTuple","ClarityAbiTypeList","ClarityAbiTypeStringAscii","ClarityAbiTypeStringUtf8","getTypeUnion","abiTupleEntry","PostConditionCodeWireType","conditionTypeToByte","originDone","checkOversign","checkOverlap","nextVerify","createSponsorSigner","originSigHash","signOrigin","nextSighash","appendOrigin","signSponsor","getTxInComplete","resume","makeUnsignedContractCall","txOptions","defaultOptions","sponsored","Allow","validateWithAbi","abi","parse","fetchAbi","filtered","functions","fn","abiArgs","payloadArg","abiArg","argNum","validateContractCall","useNonSequentialMultiSig","sortPublicKeysForAddress","numSignatures","authorization","lpPostConditions","pc","postcondition","assetId","estimatedLength","multiSigSpendingCondition","existingSignatures","totalSignatureLength","estimateTransactionByteLength","transaction_payload","estimated_len","reason_data","estimations","fetchFeeEstimateTransaction","Accept","feeRateResult","txBytes","fetchFeeEstimateTransfer","txNonce","possible_next_nonce","_getNonceApi","makeContractCall","senderKey","signerKeys","pubs","signerKey","find","mutatingSignAppendMultiSig","publicKeysSorted","PoXAddressVersion","BitcoinNetworkVersion","devnet","mocknet","B58_ADDR_PREFIXES","SEGWIT_V0_ADDR_PREFIX","SEGWIT_V1_ADDR_PREFIX","SegwitPrefix","SEGWIT_ADDR_PREFIXES","SEGWIT_V0","SEGWIT_V1","PoxOperationPeriod","StackingErrors","assertNumber","chain","wrap","alphabet","digits","letter","separator","padding","bits","chr","end","normalize","convertRadix","done","digit","digitBase","gcd","radix2carry","convertRadix2","radix2","revPadding","unsafeWrapper","genBase58","abc","BECH_ALPHABET","POLYMOD_GENERATORS","bech32Polymod","chk","bechChecksum","words","encodingConst","genBech32","ENCODING_CONST","_words","fromWords","toWords","fromWordsUnsafe","limit","lowered","sepIndex","lastIndexOf","endsWith","actualLength","decodeToBytes","bech32","bech32m","ensureUInt53","chainPrefix","encodeMessage","messageBytes","encodedLength","writeUInt16LE","InvalidPublicKeyReason","STRUCTURED_DATA_PREFIX","hashStructuredDataBytes","structuredData","encodeStructuredDataBytes","domain","structuredDataHash","domainHash","InvalidAddressError","innerError","btcAddressVersionToLegacyHashMode","btcAddressVersion","decodeBtcAddress","btcAddress","decodeBtcAddressBytes","newChecksum","base58CheckDecode","b32","bech32Words","witnessVersion","bech32Decode","bech32MWords","bech32MDecode","decodeNativeSegwitBtcAddress","dataLength","P2TR","nativeAddressToSegwitVersion","extractPoxAddressFromClarityValue","poxAddrClarityValue","clarityValue","versionCV","hashBytesCV","hashBytes","getErrorString","ERR_STACKING_UNREACHABLE","ERR_STACKING_CORRUPTED_STATE","ERR_STACKING_INSUFFICIENT_FUNDS","ERR_STACKING_INVALID_LOCK_PERIOD","ERR_STACKING_ALREADY_STACKED","ERR_STACKING_NO_SUCH_PRINCIPAL","ERR_STACKING_EXPIRED","ERR_STACKING_STX_LOCKED","ERR_STACKING_PERMISSION_DENIED","ERR_STACKING_THRESHOLD_NOT_MET","ERR_STACKING_POX_ADDRESS_IN_USE","ERR_STACKING_INVALID_POX_ADDRESS","ERR_STACKING_ALREADY_REJECTED","ERR_STACKING_INVALID_AMOUNT","ERR_NOT_ALLOWED","ERR_STACKING_ALREADY_DELEGATED","ERR_DELEGATION_EXPIRES_DURING_LOCK","ERR_DELEGATION_TOO_MUCH_LOCKED","ERR_DELEGATION_POX_ADDR_REQUIRED","ERR_INVALID_START_BURN_HEIGHT","ERR_NOT_CURRENT_STACKER","ERR_STACK_EXTEND_NOT_LOCKED","ERR_STACK_INCREASE_NOT_LOCKED","ERR_DELEGATION_NO_REWARD_SLOT","ERR_DELEGATION_WRONG_REWARD_SLOT","ERR_STACKING_IS_DELEGATED","ERR_STACKING_NOT_DELEGATED","poxAddressToTuple","poxAddress","hashbytes","_poxAddressToBtcAddress_Values","P2SHP2WPKH","P2SHP2WSH","btcAddrVersion","legacyHashModeToBtcAddressVersion","base58Encode","base58CheckEncode","poxAddressToBtcAddress","poxAddr","_poxAddressToBtcAddress_ClarityValue","unwrap","unwrapMap","ensurePox2Activated","operationInfo","period","Period1","ensureLegacyBtcAddressForPox1","ensureSignerArgsReadiness","signerSignature","maxAmount","authId","hasMaxAmount","hasAuthId","Pox4SignatureTopic","signPox4SignatureHash","topic","rewardCycle","signMessageHashRsv","signStructuredData","pox4SignatureMessage","verifyPox4SignatureHash","verificationResult","hashMessage","verifyMessageSignature","verifyMessageSignatureRsv","lockPeriod","networkOrName","StackingClient","getCoreInfo","getPoxInfo","getTargetBlockTime","target_block_time","getAccountStatus","balance","locked","getAccountBalance","getAccountExtendedBalances","stx","total_sent","total_received","getAccountBalanceLocked","getCycleDuration","poxInfoPromise","targetBlockTimePromise","all","poxInfo","targetBlockTime","reward_cycle_length","getRewardsTotalForBtcAddress","reward_amount","getRewardsForBtcAddress","getRewardHoldersForBtcAddress","getRewardSet","rewardCyleId","rewardSetIndex","pox_address","total_ustx","getSecondsUntilNextCycle","coreInfoPromise","coreInfo","burn_block_height","first_burnchain_block_height","getSecondsUntilStackingDeadline","next_cycle","blocks_until_prepare_phase","getPoxOperationInfo","poxContractVersions","contract_versions","activation_burnchain_block_height","pox1","pox2","pox3","pox4","activatedPoxs","current_burnchain_block_height","Period3","hasMinimumStx","min_amount_ustx","canStack","cycles","balancePromise","contract_id","reward_cycle_id","responseCV","eligible","reason","amountMicroStx","burnBlockHeight","poxOperationInfo","getStackingContract","callOptions","getStackOptions","renamePrivateKey","stackExtend","extendCycles","getStackExtendOptions","stackIncrease","increaseBy","getStackIncreaseOptions","delegateStx","delegateTo","untilBurnBlockHeight","getDelegateOptions","delegateStackStx","stacker","getDelegateStackOptions","delegateStackExtend","extendCount","getDelegateStackExtendOptions","delegateStackIncrease","getDelegateStackIncreaseOptions","stackAggregationCommit","getStackAggregationCommitOptions","stackAggregationCommitIndexed","getStackAggregationCommitOptionsIndexed","stackAggregationIncrease","rewardIndex","getStackAggregationIncreaseOptions","rewardCycleIndex","revokeDelegateStx","getRevokeDelegateStxOptions","getStatus","account","firstRewardCycle","details","first_reward_cycle","lock_period","unlock_height","getDelegationStatus","delegatedTo","delegated","amount_micro_stx","delegated_to","until_burn_ht","verifySignerKeySignature","Period2a","Period2b","modifyLockTxFee","getFee","parts","validateStacksAddress","signPoxSignature","signerPrivateKey"],"sourceRoot":""}
1	+ {"version":3,"file":"index.js","mappings":"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","sources":["webpack://StacksStacking/webpack/universalModuleDefinition","webpack://StacksStacking/webpack/runtime/create fake namespace object","webpack://StacksStacking/../../node_modules/@noble/hashes/utils.js","webpack://StacksStacking/../../node_modules/bs58/index.js","webpack://StacksStacking/../../node_modules/c32check/lib/index.js","webpack://StacksStacking/../../node_modules/lodash.clonedeep/index.js","webpack://StacksStacking/../../node_modules/base-x/src/index.js","webpack://StacksStacking/../../node_modules/c32check/lib/base58check.js","webpack://StacksStacking/../../node_modules/@noble/hashes/cryptoBrowser.js","webpack://StacksStacking/../../node_modules/@noble/hashes/_assert.js","webpack://StacksStacking/../../node_modules/@noble/hashes/_sha2.js","webpack://StacksStacking/../../node_modules/c32check/lib/checksum.js","webpack://StacksStacking/../../node_modules/c32check/lib/encoding.js","webpack://StacksStacking/../../node_modules/@noble/hashes/sha256.js","webpack://StacksStacking/../../node_modules/c32check/lib/address.js","webpack://StacksStacking/../../node_modules/base64-js/index.js","webpack://StacksStacking/webpack/bootstrap","webpack://StacksStacking/webpack/runtime/compat get default export","webpack://StacksStacking/webpack/runtime/define property getters","webpack://StacksStacking/webpack/runtime/global","webpack://StacksStacking/webpack/runtime/hasOwnProperty shorthand","webpack://StacksStacking/webpack/runtime/make namespace object","webpack://StacksStacking/webpack/runtime/node module decorator","webpack://StacksStacking/../common/dist/esm/utils.js","webpack://StacksStacking/../common/dist/esm/constants.js","webpack://StacksStacking/../common/dist/esm/fetch.js","webpack://StacksStacking/../network/dist/esm/constants.js","webpack://StacksStacking/../network/dist/esm/network.js","webpack://StacksStacking/../transactions/dist/esm/errors.js","webpack://StacksStacking/../common/dist/esm/buffer.js","webpack://StacksStacking/../transactions/dist/esm/BytesReader.js","webpack://StacksStacking/../transactions/dist/esm/constants.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/_assert.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/utils.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/cryptoBrowser.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/_sha2.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/ripemd160.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/sha256.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/_u64.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/sha512.js","webpack://StacksStacking/../../node_modules/@noble/secp256k1/lib/esm/index.js","webpack://StacksStacking/../transactions/dist/esm/clarity/constants.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/intCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/bufferCV.js","webpack://StacksStacking/../transactions/dist/esm/wire/types.js","webpack://StacksStacking/../transactions/dist/esm/wire/create.js","webpack://StacksStacking/../../node_modules/@noble/hashes/esm/hmac.js","webpack://StacksStacking/../common/dist/esm/signatures.js","webpack://StacksStacking/../common/dist/esm/keys.js","webpack://StacksStacking/../transactions/dist/esm/keys.js","webpack://StacksStacking/../transactions/dist/esm/wire/helpers.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/principalCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/optionalCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/tupleCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/stringCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/deserialize.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/booleanCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/responseCV.js","webpack://StacksStacking/../transactions/dist/esm/clarity/values/listCV.js","webpack://StacksStacking/../transactions/dist/esm/utils.js","webpack://StacksStacking/../transactions/dist/esm/clarity/serialize.js","webpack://StacksStacking/../transactions/dist/esm/wire/serialization.js","webpack://StacksStacking/../transactions/dist/esm/authorization.js","webpack://StacksStacking/../transactions/dist/esm/transaction.js","webpack://StacksStacking/../transactions/dist/esm/fetch.js","webpack://StacksStacking/../transactions/dist/esm/clarity/clarityValue.js","webpack://StacksStacking/../transactions/dist/esm/contract-abi.js","webpack://StacksStacking/../transactions/dist/esm/postcondition.js","webpack://StacksStacking/../transactions/dist/esm/signer.js","webpack://StacksStacking/../transactions/dist/esm/builders.js","webpack://StacksStacking/./src/constants.ts","webpack://StacksStacking/../../node_modules/@scure/base/lib/esm/index.js","webpack://StacksStacking/../encryption/dist/esm/keys.js","webpack://StacksStacking/../encryption/dist/esm/varuint.js","webpack://StacksStacking/../encryption/dist/esm/messageSignature.js","webpack://StacksStacking/../encryption/dist/esm/ec.js","webpack://StacksStacking/../transactions/dist/esm/structuredDataSignature.js","webpack://StacksStacking/./src/utils.ts","webpack://StacksStacking/./src/index.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[\"StacksStacking\"] = factory();\n\telse\n\t\troot[\"StacksStacking\"] = 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","const basex = require('base-x')\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nmodule.exports = basex(ALPHABET)\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.b58ToC32 = exports.c32ToB58 = exports.versions = exports.c32normalize = exports.c32addressDecode = exports.c32address = exports.c32checkDecode = exports.c32checkEncode = exports.c32decode = exports.c32encode = void 0;\nconst encoding_1 = require(\"./encoding\");\nObject.defineProperty(exports, \"c32encode\", { enumerable: true, get: function () { return encoding_1.c32encode; } });\nObject.defineProperty(exports, \"c32decode\", { enumerable: true, get: function () { return encoding_1.c32decode; } });\nObject.defineProperty(exports, \"c32normalize\", { enumerable: true, get: function () { return encoding_1.c32normalize; } });\nconst checksum_1 = require(\"./checksum\");\nObject.defineProperty(exports, \"c32checkEncode\", { enumerable: true, get: function () { return checksum_1.c32checkEncode; } });\nObject.defineProperty(exports, \"c32checkDecode\", { enumerable: true, get: function () { return checksum_1.c32checkDecode; } });\nconst address_1 = require(\"./address\");\nObject.defineProperty(exports, \"c32address\", { enumerable: true, get: function () { return address_1.c32address; } });\nObject.defineProperty(exports, \"c32addressDecode\", { enumerable: true, get: function () { return address_1.c32addressDecode; } });\nObject.defineProperty(exports, \"c32ToB58\", { enumerable: true, get: function () { return address_1.c32ToB58; } });\nObject.defineProperty(exports, \"b58ToC32\", { enumerable: true, get: function () { return address_1.b58ToC32; } });\nObject.defineProperty(exports, \"versions\", { enumerable: true, get: function () { return address_1.versions; } });\n","/\n lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n /\n\n/* Used as the size to enable large array optimizations. /\nvar LARGE_ARRAY_SIZE = 200;\n\n/* Used to stand-in for `undefined` hash values. /\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/* Used as references for various `Number` constants. /\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/* `Object#toString` result references. /\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/\n Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n /\nvar reRegExpChar = /[\\\\^$.+?()[\\]{}\|]/g;\n\n/** Used to match `RegExp` flags from their coerced string values. /\nvar reFlags = /\\w$/;\n\n/** Used to detect host constructors (Safari). /\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/* Used to detect unsigned integer values. /\nvar reIsUint = /^(?:0\|[1-9]\\d)$/;\n\n/** Used to identify `toStringTag` values supported by `_.clone`. /\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/* Detect free variable `global` from Node.js. /\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/* Detect free variable `self`. /\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/* Used as a reference to the global object. /\nvar root = freeGlobal \|\| freeSelf \|\| Function('return this')();\n\n/* Detect free variable `exports`. /\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/* Detect free variable `module`. /\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/* Detect the popular CommonJS extension `module.exports`. /\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/\n Adds the key-value `pair` to `map`.\n \n @private\n * @param {Object} map The map to modify.\n * @param {Array} pair The key-value pair to add.\n * @returns {Object} Returns `map`.\n /\nfunction addMapEntry(map, pair) {\n // Don't return `map.set` because it's not chainable in IE 11.\n map.set(pair[0], pair[1]);\n return map;\n}\n\n/\n Adds `value` to `set`.\n \n @private\n * @param {Object} set The set to modify.\n * @param {} value The value to add.\n @returns {Object} Returns `set`.\n /\nfunction addSetEntry(set, value) {\n // Don't return `set.add` because it's not chainable in IE 11.\n set.add(value);\n return set;\n}\n\n/\n A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n \n @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n /\nfunction arrayEach(array, iteratee) {\n var index = -1,\n length = array ? array.length : 0;\n\n while (++index < length) {\n if (iteratee(array[index], index, array) === false) {\n break;\n }\n }\n return array;\n}\n\n/\n Appends the elements of `values` to `array`.\n \n @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n /\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\n/\n A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n \n @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {} [accumulator] The initial value.\n @param {boolean} [initAccum] Specify using the first element of `array` as\n * the initial value.\n * @returns {} Returns the accumulated value.\n /\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n var index = -1,\n length = array ? array.length : 0;\n\n if (initAccum && length) {\n accumulator = array[++index];\n }\n while (++index < length) {\n accumulator = iteratee(accumulator, array[index], index, array);\n }\n return accumulator;\n}\n\n/*\n The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n \n @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n /\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\n/\n Gets the value at `key` of `object`.\n \n @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {} Returns the property value.\n /\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\n/*\n Checks if `value` is a host object in IE < 9.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n /\nfunction isHostObject(value) {\n // Many host objects are `Object` objects that can coerce to strings\n // despite having improperly defined `toString` methods.\n var result = false;\n if (value != null && typeof value.toString != 'function') {\n try {\n result = !!(value + '');\n } catch (e) {}\n }\n return result;\n}\n\n/\n Converts `map` to its key-value pairs.\n \n @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n /\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\n/\n Creates a unary function that invokes `func` with its argument transformed.\n \n @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n /\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\n/\n Converts `set` to an array of its values.\n \n @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n /\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\n/* Used for built-in method references. /\nvar arrayProto = Array.prototype,\n funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/* Used to detect overreaching core-js shims. /\nvar coreJsData = root['__core-js_shared__'];\n\n/* Used to detect methods masquerading as native. /\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO \|\| '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/* Used to resolve the decompiled source of functions. /\nvar funcToString = funcProto.toString;\n\n/* Used to check objects for own properties. /\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/\n Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n /\nvar objectToString = objectProto.toString;\n\n/* Used to detect if a method is native. /\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty\|(function).?(?=\\\\\\()\| for .+?(?=\\\\\\])/g, '$1.?') + '$'\n);\n\n/* Built-in value references. /\nvar Buffer = moduleExports ? root.Buffer : undefined,\n Symbol = root.Symbol,\n Uint8Array = root.Uint8Array,\n getPrototype = overArg(Object.getPrototypeOf, Object),\n objectCreate = Object.create,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n splice = arrayProto.splice;\n\n/ Built-in method references for those with the same name as other `lodash` methods. /\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n nativeKeys = overArg(Object.keys, Object);\n\n/ Built-in method references that are verified to be native. /\nvar DataView = getNative(root, 'DataView'),\n Map = getNative(root, 'Map'),\n Promise = getNative(root, 'Promise'),\n Set = getNative(root, 'Set'),\n WeakMap = getNative(root, 'WeakMap'),\n nativeCreate = getNative(Object, 'create');\n\n/* Used to detect maps, sets, and weakmaps. /\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/* Used to convert symbols to primitives and strings. /\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/\n Creates a hash object.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction Hash(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the hash.\n \n @private\n * @name clear\n * @memberOf Hash\n /\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n\n/\n Removes `key` and its value from the hash.\n \n @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction hashDelete(key) {\n return this.has(key) && delete this.__data__[key];\n}\n\n/\n Gets the hash value for `key`.\n \n @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/*\n Checks if a hash value for `key` exists.\n \n @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/\n Sets the hash `key` to `value`.\n \n @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the hash instance.\n /\nfunction hashSet(key, value) {\n var data = this.__data__;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/\n Creates an list cache object.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction ListCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the list cache.\n \n @private\n * @name clear\n * @memberOf ListCache\n /\nfunction listCacheClear() {\n this.__data__ = [];\n}\n\n/\n Removes `key` and its value from the list cache.\n \n @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n return true;\n}\n\n/\n Gets the list cache value for `key`.\n \n @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\n/*\n Checks if a list cache value for `key` exists.\n \n @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\n/\n Sets the list cache `key` to `value`.\n \n @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the list cache instance.\n /\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/\n Creates a map cache object to store key-value pairs.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction MapCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the map.\n \n @private\n * @name clear\n * @memberOf MapCache\n /\nfunction mapCacheClear() {\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map \|\| ListCache),\n 'string': new Hash\n };\n}\n\n/\n Removes `key` and its value from the map.\n \n @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction mapCacheDelete(key) {\n return getMapData(this, key)['delete'](key);\n}\n\n/\n Gets the map value for `key`.\n \n @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\n/*\n Checks if a map value for `key` exists.\n \n @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\n/\n Sets the map `key` to `value`.\n \n @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the map cache instance.\n /\nfunction mapCacheSet(key, value) {\n getMapData(this, key).set(key, value);\n return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/\n Creates a stack cache object to store key-value pairs.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction Stack(entries) {\n this.__data__ = new ListCache(entries);\n}\n\n/\n Removes all key-value entries from the stack.\n \n @private\n * @name clear\n * @memberOf Stack\n /\nfunction stackClear() {\n this.__data__ = new ListCache;\n}\n\n/\n Removes `key` and its value from the stack.\n \n @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction stackDelete(key) {\n return this.__data__['delete'](key);\n}\n\n/\n Gets the stack value for `key`.\n \n @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\n/*\n Checks if a stack value for `key` exists.\n \n @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\n/\n Sets the stack `key` to `value`.\n \n @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the stack cache instance.\n /\nfunction stackSet(key, value) {\n var cache = this.__data__;\n if (cache instanceof ListCache) {\n var pairs = cache.__data__;\n if (!Map \|\| (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n return this;\n }\n cache = this.__data__ = new MapCache(pairs);\n }\n cache.set(key, value);\n return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/\n Creates an array of the enumerable property names of the array-like `value`.\n \n @private\n * @param {} value The value to query.\n @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n /\nfunction arrayLikeKeys(value, inherited) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n // Safari 9 makes `arguments.length` enumerable in strict mode.\n var result = (isArray(value) \|\| isArguments(value))\n ? baseTimes(value.length, String)\n : [];\n\n var length = result.length,\n skipIndexes = !!length;\n\n for (var key in value) {\n if ((inherited \|\| hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (key == 'length' \|\| isIndex(key, length)))) {\n result.push(key);\n }\n }\n return result;\n}\n\n/\n Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n \n @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {} value The value to assign.\n /\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) \|\|\n (value === undefined && !(key in object))) {\n object[key] = value;\n }\n}\n\n/*\n Gets the index at which the `key` is found in `array` of key-value pairs.\n \n @private\n * @param {Array} array The array to inspect.\n * @param {} key The key to search for.\n @returns {number} Returns the index of the matched value, else `-1`.\n /\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\n/\n The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n \n @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n /\nfunction baseAssign(object, source) {\n return object && copyObject(source, keys(source), object);\n}\n\n/\n The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n \n @private\n * @param {} value The value to clone.\n @param {boolean} [isDeep] Specify a deep clone.\n * @param {boolean} [isFull] Specify a clone including symbols.\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {} Returns the cloned value.\n /\nfunction baseClone(value, isDeep, isFull, customizer, key, object, stack) {\n var result;\n if (customizer) {\n result = object ? customizer(value, key, object, stack) : customizer(value);\n }\n if (result !== undefined) {\n return result;\n }\n if (!isObject(value)) {\n return value;\n }\n var isArr = isArray(value);\n if (isArr) {\n result = initCloneArray(value);\n if (!isDeep) {\n return copyArray(value, result);\n }\n } else {\n var tag = getTag(value),\n isFunc = tag == funcTag \|\| tag == genTag;\n\n if (isBuffer(value)) {\n return cloneBuffer(value, isDeep);\n }\n if (tag == objectTag \|\| tag == argsTag \|\| (isFunc && !object)) {\n if (isHostObject(value)) {\n return object ? value : {};\n }\n result = initCloneObject(isFunc ? {} : value);\n if (!isDeep) {\n return copySymbols(value, baseAssign(result, value));\n }\n } else {\n if (!cloneableTags[tag]) {\n return object ? value : {};\n }\n result = initCloneByTag(value, tag, baseClone, isDeep);\n }\n }\n // Check for circular references and return its corresponding clone.\n stack \|\| (stack = new Stack);\n var stacked = stack.get(value);\n if (stacked) {\n return stacked;\n }\n stack.set(value, result);\n\n if (!isArr) {\n var props = isFull ? getAllKeys(value) : keys(value);\n }\n arrayEach(props \|\| value, function(subValue, key) {\n if (props) {\n key = subValue;\n subValue = value[key];\n }\n // Recursively populate clone (susceptible to call stack limits).\n assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));\n });\n return result;\n}\n\n/*\n The base implementation of `_.create` without support for assigning\n * properties to the created object.\n \n @private\n * @param {Object} prototype The object to inherit from.\n * @returns {Object} Returns the new object.\n /\nfunction baseCreate(proto) {\n return isObject(proto) ? objectCreate(proto) : {};\n}\n\n/\n The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n /\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/\n The base implementation of `getTag`.\n \n @private\n * @param {} value The value to query.\n @returns {string} Returns the `toStringTag`.\n /\nfunction baseGetTag(value) {\n return objectToString.call(value);\n}\n\n/\n The base implementation of `_.isNative` without bad shim checks.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n /\nfunction baseIsNative(value) {\n if (!isObject(value) \|\| isMasked(value)) {\n return false;\n }\n var pattern = (isFunction(value) \|\| isHostObject(value)) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\n/\n The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n /\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\n/\n Creates a clone of `buffer`.\n \n @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n /\nfunction cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var result = new buffer.constructor(buffer.length);\n buffer.copy(result);\n return result;\n}\n\n/\n Creates a clone of `arrayBuffer`.\n \n @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n /\nfunction cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n}\n\n/\n Creates a clone of `dataView`.\n \n @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n /\nfunction cloneDataView(dataView, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\n/\n Creates a clone of `map`.\n \n @private\n * @param {Object} map The map to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned map.\n /\nfunction cloneMap(map, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);\n return arrayReduce(array, addMapEntry, new map.constructor);\n}\n\n/\n Creates a clone of `regexp`.\n \n @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n /\nfunction cloneRegExp(regexp) {\n var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n result.lastIndex = regexp.lastIndex;\n return result;\n}\n\n/\n Creates a clone of `set`.\n \n @private\n * @param {Object} set The set to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned set.\n /\nfunction cloneSet(set, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);\n return arrayReduce(array, addSetEntry, new set.constructor);\n}\n\n/\n Creates a clone of the `symbol` object.\n \n @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n /\nfunction cloneSymbol(symbol) {\n return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\n/\n Creates a clone of `typedArray`.\n \n @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n /\nfunction cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/\n Copies the values of `source` to `array`.\n \n @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n /\nfunction copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array \|\| (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n}\n\n/\n Copies properties of `source` to `object`.\n \n @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n /\nfunction copyObject(source, props, object, customizer) {\n object \|\| (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n assignValue(object, key, newValue === undefined ? source[key] : newValue);\n }\n return object;\n}\n\n/\n Copies own symbol properties of `source` to `object`.\n \n @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n /\nfunction copySymbols(source, object) {\n return copyObject(source, getSymbols(source), object);\n}\n\n/\n Creates an array of own enumerable property names and symbols of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n /\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/\n Gets the data for `map`.\n \n @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {} Returns the map data.\n /\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\n/*\n Gets the native function at `key` of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {} Returns the function if it's native, else `undefined`.\n /\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\n/*\n Creates an array of the own enumerable symbol properties of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n /\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/\n Gets the `toStringTag` of `value`.\n \n @private\n * @param {} value The value to query.\n @returns {string} Returns the `toStringTag`.\n /\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11,\n// for data views in Edge < 14, and promises in Node.js.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) \|\|\n (Map && getTag(new Map) != mapTag) \|\|\n (Promise && getTag(Promise.resolve()) != promiseTag) \|\|\n (Set && getTag(new Set) != setTag) \|\|\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = objectToString.call(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : undefined;\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\n/\n Initializes an array clone.\n \n @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n /\nfunction initCloneArray(array) {\n var length = array.length,\n result = array.constructor(length);\n\n // Add properties assigned by `RegExp#exec`.\n if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n result.index = array.index;\n result.input = array.input;\n }\n return result;\n}\n\n/\n Initializes an object clone.\n \n @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n /\nfunction initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n}\n\n/\n Initializes an object clone based on its `toStringTag`.\n \n Note: This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n \n @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n /\nfunction initCloneByTag(object, tag, cloneFunc, isDeep) {\n var Ctor = object.constructor;\n switch (tag) {\n case arrayBufferTag:\n return cloneArrayBuffer(object);\n\n case boolTag:\n case dateTag:\n return new Ctor(+object);\n\n case dataViewTag:\n return cloneDataView(object, isDeep);\n\n case float32Tag: case float64Tag:\n case int8Tag: case int16Tag: case int32Tag:\n case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n return cloneTypedArray(object, isDeep);\n\n case mapTag:\n return cloneMap(object, isDeep, cloneFunc);\n\n case numberTag:\n case stringTag:\n return new Ctor(object);\n\n case regexpTag:\n return cloneRegExp(object);\n\n case setTag:\n return cloneSet(object, isDeep, cloneFunc);\n\n case symbolTag:\n return cloneSymbol(object);\n }\n}\n\n/\n Checks if `value` is a valid array-like index.\n \n @private\n * @param {} value The value to check.\n @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n /\nfunction isIndex(value, length) {\n length = length == null ? MAX_SAFE_INTEGER : length;\n return !!length &&\n (typeof value == 'number' \|\| reIsUint.test(value)) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\n/\n Checks if `value` is suitable for use as unique object key.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n /\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' \|\| type == 'number' \|\| type == 'symbol' \|\| type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\n/\n Checks if `func` has its source masked.\n \n @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n /\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/\n Checks if `value` is likely a prototype object.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n /\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) \|\| objectProto;\n\n return value === proto;\n}\n\n/\n Converts `func` to its source code.\n \n @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n /\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\n/\n This method is like `_.clone` except that it recursively clones `value`.\n \n @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {} value The value to recursively clone.\n @returns {} Returns the deep cloned value.\n @see _.clone\n * @example\n \n var objects = [{ 'a': 1 }, { 'b': 2 }];\n \n var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n /\nfunction cloneDeep(value) {\n return baseClone(value, true, true);\n}\n\n/\n Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to compare.\n @param {} other The other value to compare.\n @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n \n var object = { 'a': 1 };\n * var other = { 'a': 1 };\n \n _.eq(object, object);\n * // => true\n \n _.eq(object, other);\n * // => false\n \n _.eq('a', 'a');\n * // => true\n \n _.eq('a', Object('a'));\n * // => false\n \n _.eq(NaN, NaN);\n * // => true\n /\nfunction eq(value, other) {\n return value === other \|\| (value !== value && other !== other);\n}\n\n/\n Checks if `value` is likely an `arguments` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n \n _.isArguments(function() { return arguments; }());\n * // => true\n \n _.isArguments([1, 2, 3]);\n * // => false\n /\nfunction isArguments(value) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n (!propertyIsEnumerable.call(value, 'callee') \|\| objectToString.call(value) == argsTag);\n}\n\n/\n Checks if `value` is classified as an `Array` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n \n _.isArray([1, 2, 3]);\n * // => true\n \n _.isArray(document.body.children);\n * // => false\n \n _.isArray('abc');\n * // => false\n \n _.isArray(_.noop);\n * // => false\n /\nvar isArray = Array.isArray;\n\n/\n Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n \n _.isArrayLike([1, 2, 3]);\n * // => true\n \n _.isArrayLike(document.body.children);\n * // => true\n \n _.isArrayLike('abc');\n * // => true\n \n _.isArrayLike(_.noop);\n * // => false\n /\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/\n This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n \n _.isArrayLikeObject([1, 2, 3]);\n * // => true\n \n _.isArrayLikeObject(document.body.children);\n * // => true\n \n _.isArrayLikeObject('abc');\n * // => false\n \n _.isArrayLikeObject(_.noop);\n * // => false\n /\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\n/\n Checks if `value` is a buffer.\n \n @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n \n _.isBuffer(new Buffer(2));\n * // => true\n \n _.isBuffer(new Uint8Array(2));\n * // => false\n /\nvar isBuffer = nativeIsBuffer \|\| stubFalse;\n\n/\n Checks if `value` is classified as a `Function` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n \n _.isFunction(_);\n * // => true\n \n _.isFunction(/abc/);\n * // => false\n /\nfunction isFunction(value) {\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 8-9 which returns 'object' for typed array and other constructors.\n var tag = isObject(value) ? objectToString.call(value) : '';\n return tag == funcTag \|\| tag == genTag;\n}\n\n/\n Checks if `value` is a valid array-like length.\n \n Note: This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n \n _.isLength(3);\n * // => true\n \n _.isLength(Number.MIN_VALUE);\n * // => false\n \n _.isLength(Infinity);\n * // => false\n \n _.isLength('3');\n * // => false\n /\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/\n Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n \n _.isObject({});\n * // => true\n \n _.isObject([1, 2, 3]);\n * // => true\n \n _.isObject(_.noop);\n * // => true\n \n _.isObject(null);\n * // => false\n /\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' \|\| type == 'function');\n}\n\n/\n Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n \n _.isObjectLike({});\n * // => true\n \n _.isObjectLike([1, 2, 3]);\n * // => true\n \n _.isObjectLike(_.noop);\n * // => false\n \n _.isObjectLike(null);\n * // => false\n /\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/\n Creates an array of the own enumerable property names of `object`.\n \n Note: Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n \n @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n \n function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n \n Foo.prototype.c = 3;\n \n _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n \n _.keys('hi');\n * // => ['0', '1']\n /\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/\n This method returns a new empty array.\n \n @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n \n var arrays = _.times(2, _.stubArray);\n \n console.log(arrays);\n * // => [[], []]\n \n console.log(arrays[0] === arrays[1]);\n * // => false\n /\nfunction stubArray() {\n return [];\n}\n\n/\n This method returns `false`.\n \n @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n \n _.times(2, _.stubFalse);\n * // => [false, false]\n /\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = cloneDeep;\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","/\n From https://github.com/wzbg/base58check\n * @Author: zyc\n * @Date: 2016-09-11 23:36:05\n /\n'use strict';\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decode = exports.encode = void 0;\nconst sha256_1 = require(\"@noble/hashes/sha256\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nconst basex = require(\"base-x\");\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\nfunction encode(data, prefix = '00') {\n const dataBytes = typeof data === 'string' ? (0, utils_1.hexToBytes)(data) : data;\n const prefixBytes = typeof prefix === 'string' ? (0, utils_1.hexToBytes)(prefix) : data;\n if (!(dataBytes instanceof Uint8Array) \|\| !(prefixBytes instanceof Uint8Array)) {\n throw new TypeError('Argument must be of type Uint8Array or string');\n }\n const checksum = (0, sha256_1.sha256)((0, sha256_1.sha256)(new Uint8Array([...prefixBytes, ...dataBytes])));\n return basex(ALPHABET).encode([...prefixBytes, ...dataBytes, ...checksum.slice(0, 4)]);\n}\nexports.encode = encode;\nfunction decode(string) {\n const bytes = basex(ALPHABET).decode(string);\n const prefixBytes = bytes.slice(0, 1);\n const dataBytes = bytes.slice(1, -4);\n // todo: for better performance replace spread with `concatBytes` method\n const checksum = (0, sha256_1.sha256)((0, sha256_1.sha256)(new Uint8Array([...prefixBytes, ...dataBytes])));\n bytes.slice(-4).forEach((check, index) => {\n if (check !== checksum[index]) {\n throw new Error('Invalid checksum');\n }\n });\n return { prefix: prefixBytes, data: dataBytes };\n}\nexports.decode = decode;\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.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 / (10246)) 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.c32checkDecode = exports.c32checkEncode = void 0;\nconst sha256_1 = require(\"@noble/hashes/sha256\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nconst encoding_1 = require(\"./encoding\");\n/*\n Get the c32check checksum of a hex-encoded string\n * @param {string} dataHex - the hex string\n * @returns {string} the c32 checksum, as a bin-encoded string\n /\nfunction c32checksum(dataHex) {\n const dataHash = (0, sha256_1.sha256)((0, sha256_1.sha256)((0, utils_1.hexToBytes)(dataHex)));\n const checksum = (0, utils_1.bytesToHex)(dataHash.slice(0, 4));\n return checksum;\n}\n/\n Encode a hex string as a c32check string. This is a lot like how\n * base58check works in Bitcoin-land, but this algorithm uses the\n * z-base-32 alphabet instead of the base58 alphabet. The algorithm\n * is as follows:\n * * calculate the c32checksum of version + data\n * * c32encode version + data + c32checksum\n * @param {number} version - the version string (between 0 and 31)\n * @param {string} data - the data to encode\n * @returns {string} the c32check representation\n /\nfunction c32checkEncode(version, data) {\n if (version < 0 \|\| version >= 32) {\n throw new Error('Invalid version (must be between 0 and 31)');\n }\n if (!data.match(/^[0-9a-fA-F]$/)) {\n throw new Error('Invalid data (not a hex string)');\n }\n data = data.toLowerCase();\n if (data.length % 2 !== 0) {\n data = `0${data}`;\n }\n let versionHex = version.toString(16);\n if (versionHex.length === 1) {\n versionHex = `0${versionHex}`;\n }\n const checksumHex = c32checksum(`${versionHex}${data}`);\n const c32str = (0, encoding_1.c32encode)(`${data}${checksumHex}`);\n return `${encoding_1.c32[version]}${c32str}`;\n}\nexports.c32checkEncode = c32checkEncode;\n/\n Decode a c32check string back into its version and data payload. This is\n * a lot like how base58check works in Bitcoin-land, but this algorithm uses\n * the z-base-32 alphabet instead of the base58 alphabet. The algorithm\n * is as follows:\n * * extract the version, data, and checksum\n * * verify the checksum matches c32checksum(version + data)\n * * return data\n * @param {string} c32data - the c32check-encoded string\n * @returns {array} [version (number), data (string)]. The returned data\n * will be a hex string. Throws an exception if the checksum does not match.\n /\nfunction c32checkDecode(c32data) {\n c32data = (0, encoding_1.c32normalize)(c32data);\n const dataHex = (0, encoding_1.c32decode)(c32data.slice(1));\n const versionChar = c32data[0];\n const version = encoding_1.c32.indexOf(versionChar);\n const checksum = dataHex.slice(-8);\n let versionHex = version.toString(16);\n if (versionHex.length === 1) {\n versionHex = `0${versionHex}`;\n }\n if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {\n throw new Error('Invalid c32check string: checksum mismatch');\n }\n return [version, dataHex.substring(0, dataHex.length - 8)];\n}\nexports.c32checkDecode = c32checkDecode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32decode = exports.c32normalize = exports.c32encode = exports.c32 = void 0;\nconst utils_1 = require(\"@noble/hashes/utils\");\nexports.c32 = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';\nconst hex = '0123456789abcdef';\n/\n Encode a hex string as a c32 string. Note that the hex string is assumed\n * to be big-endian (and the resulting c32 string will be as well).\n * @param {string} inputHex - the input to encode\n * @param {number} minLength - the minimum length of the c32 string\n * @returns {string} the c32check-encoded representation of the data, as a string\n /\nfunction c32encode(inputHex, minLength) {\n // must be hex\n if (!inputHex.match(/^[0-9a-fA-F]$/)) {\n throw new Error('Not a hex-encoded string');\n }\n if (inputHex.length % 2 !== 0) {\n inputHex = `0${inputHex}`;\n }\n inputHex = inputHex.toLowerCase();\n let res = [];\n let carry = 0;\n for (let i = inputHex.length - 1; i >= 0; i--) {\n if (carry < 4) {\n const currentCode = hex.indexOf(inputHex[i]) >> carry;\n let nextCode = 0;\n if (i !== 0) {\n nextCode = hex.indexOf(inputHex[i - 1]);\n }\n // carry = 0, nextBits is 1, carry = 1, nextBits is 2\n const nextBits = 1 + carry;\n const nextLowBits = nextCode % (1 << nextBits) << (5 - nextBits);\n const curC32Digit = exports.c32[currentCode + nextLowBits];\n carry = nextBits;\n res.unshift(curC32Digit);\n }\n else {\n carry = 0;\n }\n }\n let C32leadingZeros = 0;\n for (let i = 0; i < res.length; i++) {\n if (res[i] !== '0') {\n break;\n }\n else {\n C32leadingZeros++;\n }\n }\n res = res.slice(C32leadingZeros);\n const zeroPrefix = new TextDecoder().decode((0, utils_1.hexToBytes)(inputHex)).match(/^\\u0000/);\n const numLeadingZeroBytesInHex = zeroPrefix ? zeroPrefix[0].length : 0;\n for (let i = 0; i < numLeadingZeroBytesInHex; i++) {\n res.unshift(exports.c32[0]);\n }\n if (minLength) {\n const count = minLength - res.length;\n for (let i = 0; i < count; i++) {\n res.unshift(exports.c32[0]);\n }\n }\n return res.join('');\n}\nexports.c32encode = c32encode;\n/\n * Normalize a c32 string\n * @param {string} c32input - the c32-encoded input string\n * @returns {string} the canonical representation of the c32 input string\n /\nfunction c32normalize(c32input) {\n // must be upper-case\n // replace all O's with 0's\n // replace all I's and L's with 1's\n return c32input.toUpperCase().replace(/O/g, '0').replace(/L\|I/g, '1');\n}\nexports.c32normalize = c32normalize;\n/\n * Decode a c32 string back into a hex string. Note that the c32 input\n * string is assumed to be big-endian (and the resulting hex string will\n * be as well).\n * @param {string} c32input - the c32-encoded input to decode\n * @param {number} minLength - the minimum length of the output hex string (in bytes)\n * @returns {string} the hex-encoded representation of the data, as a string\n /\nfunction c32decode(c32input, minLength) {\n c32input = c32normalize(c32input);\n // must result in a c32 string\n if (!c32input.match(`^[${exports.c32}]$`)) {\n throw new Error('Not a c32-encoded string');\n }\n const zeroPrefix = c32input.match(`^${exports.c32[0]}`);\n const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0].length : 0;\n let res = [];\n let carry = 0;\n let carryBits = 0;\n for (let i = c32input.length - 1; i >= 0; i--) {\n if (carryBits === 4) {\n res.unshift(hex[carry]);\n carryBits = 0;\n carry = 0;\n }\n const currentCode = exports.c32.indexOf(c32input[i]) << carryBits;\n const currentValue = currentCode + carry;\n const currentHexDigit = hex[currentValue % 16];\n carryBits += 1;\n carry = currentValue >> 4;\n if (carry > 1 << carryBits) {\n throw new Error('Panic error in decoding.');\n }\n res.unshift(currentHexDigit);\n }\n // one last carry\n res.unshift(hex[carry]);\n if (res.length % 2 === 1) {\n res.unshift('0');\n }\n let hexLeadingZeros = 0;\n for (let i = 0; i < res.length; i++) {\n if (res[i] !== '0') {\n break;\n }\n else {\n hexLeadingZeros++;\n }\n }\n res = res.slice(hexLeadingZeros - (hexLeadingZeros % 2));\n let hexStr = res.join('');\n for (let i = 0; i < numLeadingZeroBytes; i++) {\n hexStr = `00${hexStr}`;\n }\n if (minLength) {\n const count = minLength 2 - hexStr.length;\n for (let i = 0; i < count; i += 2) {\n hexStr = `00${hexStr}`;\n }\n }\n return hexStr;\n}\nexports.c32decode = c32decode;\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\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32ToB58 = exports.b58ToC32 = exports.c32addressDecode = exports.c32address = exports.versions = void 0;\nconst checksum_1 = require(\"./checksum\");\nconst base58check = require(\"./base58check\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nexports.versions = {\n mainnet: {\n p2pkh: 22,\n p2sh: 20, // 'M'\n },\n testnet: {\n p2pkh: 26,\n p2sh: 21, // 'N'\n },\n};\n// address conversion : bitcoin to stacks\nconst ADDR_BITCOIN_TO_STACKS = {};\nADDR_BITCOIN_TO_STACKS[0] = exports.versions.mainnet.p2pkh;\nADDR_BITCOIN_TO_STACKS[5] = exports.versions.mainnet.p2sh;\nADDR_BITCOIN_TO_STACKS[111] = exports.versions.testnet.p2pkh;\nADDR_BITCOIN_TO_STACKS[196] = exports.versions.testnet.p2sh;\n// address conversion : stacks to bitcoin\nconst ADDR_STACKS_TO_BITCOIN = {};\nADDR_STACKS_TO_BITCOIN[exports.versions.mainnet.p2pkh] = 0;\nADDR_STACKS_TO_BITCOIN[exports.versions.mainnet.p2sh] = 5;\nADDR_STACKS_TO_BITCOIN[exports.versions.testnet.p2pkh] = 111;\nADDR_STACKS_TO_BITCOIN[exports.versions.testnet.p2sh] = 196;\n/\n Make a c32check address with the given version and hash160\n * The only difference between a c32check string and c32 address\n * is that the letter 'S' is pre-pended.\n * @param {number} version - the address version number\n * @param {string} hash160hex - the hash160 to encode (must be a hash160)\n * @returns {string} the address\n /\nfunction c32address(version, hash160hex) {\n if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {\n throw new Error('Invalid argument: not a hash160 hex string');\n }\n const c32string = (0, checksum_1.c32checkEncode)(version, hash160hex);\n return `S${c32string}`;\n}\nexports.c32address = c32address;\n/\n Decode a c32 address into its version and hash160\n * @param {string} c32addr - the c32check-encoded address\n * @returns {[number, string]} a tuple with the version and hash160\n /\nfunction c32addressDecode(c32addr) {\n if (c32addr.length <= 5) {\n throw new Error('Invalid c32 address: invalid length');\n }\n if (c32addr[0] != 'S') {\n throw new Error('Invalid c32 address: must start with \"S\"');\n }\n return (0, checksum_1.c32checkDecode)(c32addr.slice(1));\n}\nexports.c32addressDecode = c32addressDecode;\n/\n * Convert a base58check address to a c32check address.\n * Try to convert the version number if one is not given.\n * @param {string} b58check - the base58check encoded address\n * @param {number} version - the version number, if not inferred from the address\n * @returns {string} the c32 address with the given version number (or the\n * semantically-equivalent c32 version number, if not given)\n /\nfunction b58ToC32(b58check, version = -1) {\n const addrInfo = base58check.decode(b58check);\n const hash160String = (0, utils_1.bytesToHex)(addrInfo.data);\n const addrVersion = parseInt((0, utils_1.bytesToHex)(addrInfo.prefix), 16);\n let stacksVersion;\n if (version < 0) {\n stacksVersion = addrVersion;\n if (ADDR_BITCOIN_TO_STACKS[addrVersion] !== undefined) {\n stacksVersion = ADDR_BITCOIN_TO_STACKS[addrVersion];\n }\n }\n else {\n stacksVersion = version;\n }\n return c32address(stacksVersion, hash160String);\n}\nexports.b58ToC32 = b58ToC32;\n/\n * Convert a c32check address to a base58check address.\n * @param {string} c32string - the c32check address\n * @param {number} version - the version number, if not inferred from the address\n * @returns {string} the base58 address with the given version number (or the\n * semantically-equivalent bitcoin version number, if not given)\n /\nfunction c32ToB58(c32string, version = -1) {\n const addrInfo = c32addressDecode(c32string);\n const stacksVersion = addrInfo[0];\n const hash160String = addrInfo[1];\n let bitcoinVersion;\n if (version < 0) {\n bitcoinVersion = stacksVersion;\n if (ADDR_STACKS_TO_BITCOIN[stacksVersion] !== undefined) {\n bitcoinVersion = ADDR_STACKS_TO_BITCOIN[stacksVersion];\n }\n }\n else {\n bitcoinVersion = version;\n }\n let prefix = bitcoinVersion.toString(16);\n if (prefix.length === 1) {\n prefix = `0${prefix}`;\n }\n return base58check.encode(hash160String, prefix);\n}\nexports.c32ToB58 = c32ToB58;\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\tid: moduleId,\n\t\tloaded: false,\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// Flag the module as loaded\n\tmodule.loaded = true;\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};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\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 HIRO_MAINNET_URL = 'https://api.mainnet.hiro.so';\nexport const HIRO_TESTNET_URL = 'https://api.testnet.hiro.so';\nexport const DEVNET_URL = 'http://localhost:3999';\nexport const GAIA_URL = 'https://hub.blockstack.org';\nexport const PRIVATE_KEY_BYTES_COMPRESSED = 33;\nexport const PRIVATE_KEY_BYTES_UNCOMPRESSED = 32;\n//# sourceMappingURL=constants.js.map","const defaultFetchOpts = {\n referrerPolicy: 'origin',\n headers: {\n 'x-hiro-product': 'stacksjs',\n },\n};\nexport const getFetchOptions = () => {\n return defaultFetchOpts;\n};\nexport const setFetchOptions = (ops) => {\n return Object.assign(defaultFetchOpts, ops);\n};\nexport async function fetchWrapper(input, init) {\n const fetchOpts = {};\n Object.assign(fetchOpts, defaultFetchOpts, init);\n const fetchResult = await fetch(input, fetchOpts);\n return fetchResult;\n}\nexport function hostMatches(host, pattern) {\n if (typeof pattern === 'string')\n return pattern === host;\n return pattern.exec(host);\n}\nexport function createApiKeyMiddleware({ apiKey, host = /(.)api(.)(\\.stacks\\.co\|\\.hiro\\.so)$/i, httpHeader = 'x-api-key', }) {\n return {\n pre: context => {\n const reqUrl = new URL(context.url);\n if (!hostMatches(reqUrl.host, host))\n return;\n const headers = context.init.headers instanceof Headers\n ? context.init.headers\n : (context.init.headers = new Headers(context.init.headers));\n headers.set(httpHeader, apiKey);\n },\n };\n}\nfunction argsForCreateFetchFn(args) {\n let fetchLib = fetchWrapper;\n let middlewares = [];\n if (args.length > 0 && typeof args[0] === 'function') {\n fetchLib = args.shift();\n }\n if (args.length > 0) {\n middlewares = args;\n }\n return { fetchLib, middlewares };\n}\nexport function createFetchFn(...args) {\n const { fetchLib, middlewares } = argsForCreateFetchFn(args);\n const fetchFn = async (url, init) => {\n let fetchParams = { url, init: init ?? {} };\n for (const middleware of middlewares) {\n if (typeof middleware.pre === 'function') {\n const result = await Promise.resolve(middleware.pre({\n fetch: fetchLib,\n ...fetchParams,\n }));\n fetchParams = result ?? fetchParams;\n }\n }\n let response = await fetchLib(fetchParams.url, fetchParams.init);\n for (const middleware of middlewares) {\n if (typeof middleware.post === 'function') {\n const result = await Promise.resolve(middleware.post({\n fetch: fetchLib,\n url: fetchParams.url,\n init: fetchParams.init,\n response: response?.clone() ?? response,\n }));\n response = result ?? response;\n }\n }\n return response;\n };\n return fetchFn;\n}\n//# sourceMappingURL=fetch.js.map","export var ChainId;\n(function (ChainId) {\n ChainId[ChainId[\"Mainnet\"] = 1] = \"Mainnet\";\n ChainId[ChainId[\"Testnet\"] = 2147483648] = \"Testnet\";\n})(ChainId \|\| (ChainId = {}));\nexport var PeerNetworkId;\n(function (PeerNetworkId) {\n PeerNetworkId[PeerNetworkId[\"Mainnet\"] = 385875968] = \"Mainnet\";\n PeerNetworkId[PeerNetworkId[\"Testnet\"] = 4278190080] = \"Testnet\";\n})(PeerNetworkId \|\| (PeerNetworkId = {}));\nexport const DEFAULT_CHAIN_ID = ChainId.Mainnet;\nexport var TransactionVersion;\n(function (TransactionVersion) {\n TransactionVersion[TransactionVersion[\"Mainnet\"] = 0] = \"Mainnet\";\n TransactionVersion[TransactionVersion[\"Testnet\"] = 128] = \"Testnet\";\n})(TransactionVersion \|\| (TransactionVersion = {}));\nexport var AddressVersion;\n(function (AddressVersion) {\n AddressVersion[AddressVersion[\"MainnetSingleSig\"] = 22] = \"MainnetSingleSig\";\n AddressVersion[AddressVersion[\"MainnetMultiSig\"] = 20] = \"MainnetMultiSig\";\n AddressVersion[AddressVersion[\"TestnetSingleSig\"] = 26] = \"TestnetSingleSig\";\n AddressVersion[AddressVersion[\"TestnetMultiSig\"] = 21] = \"TestnetMultiSig\";\n})(AddressVersion \|\| (AddressVersion = {}));\nexport const DEFAULT_TRANSACTION_VERSION = TransactionVersion.Mainnet;\nexport function whenTransactionVersion(transactionVersion) {\n return (map) => map[transactionVersion];\n}\n//# sourceMappingURL=constants.js.map","import { DEVNET_URL, HIRO_MAINNET_URL, HIRO_TESTNET_URL, createFetchFn, createApiKeyMiddleware, } from '@stacks/common';\nimport { AddressVersion, ChainId, PeerNetworkId, TransactionVersion } from './constants';\nexport const STACKS_MAINNET = {\n chainId: ChainId.Mainnet,\n transactionVersion: TransactionVersion.Mainnet,\n peerNetworkId: PeerNetworkId.Mainnet,\n magicBytes: 'X2',\n bootAddress: 'SP000000000000000000002Q6VF78',\n addressVersion: {\n singleSig: AddressVersion.MainnetSingleSig,\n multiSig: AddressVersion.MainnetMultiSig,\n },\n client: { baseUrl: HIRO_MAINNET_URL },\n};\nexport const STACKS_TESTNET = {\n chainId: ChainId.Testnet,\n transactionVersion: TransactionVersion.Testnet,\n peerNetworkId: PeerNetworkId.Testnet,\n magicBytes: 'T2',\n bootAddress: 'ST000000000000000000002AMW42H',\n addressVersion: {\n singleSig: AddressVersion.TestnetSingleSig,\n multiSig: AddressVersion.TestnetMultiSig,\n },\n client: { baseUrl: HIRO_TESTNET_URL },\n};\nexport const STACKS_DEVNET = {\n ...STACKS_TESTNET,\n addressVersion: { ...STACKS_TESTNET.addressVersion },\n magicBytes: 'id',\n client: { baseUrl: DEVNET_URL },\n};\nexport const STACKS_MOCKNET = {\n ...STACKS_DEVNET,\n addressVersion: { ...STACKS_DEVNET.addressVersion },\n client: { ...STACKS_DEVNET.client },\n};\nexport const StacksNetworks = ['mainnet', 'testnet', 'devnet', 'mocknet'];\nexport function networkFromName(name) {\n switch (name) {\n case 'mainnet':\n return STACKS_MAINNET;\n case 'testnet':\n return STACKS_TESTNET;\n case 'devnet':\n return STACKS_DEVNET;\n case 'mocknet':\n return STACKS_MOCKNET;\n default:\n throw new Error(`Unknown network name: ${name}`);\n }\n}\nexport function networkFrom(network) {\n if (typeof network === 'string')\n return networkFromName(network);\n return network;\n}\nexport function defaultUrlFromNetwork(network) {\n if (!network)\n return HIRO_MAINNET_URL;\n network = networkFrom(network);\n return !network \|\| network.transactionVersion === TransactionVersion.Mainnet\n ? HIRO_MAINNET_URL\n : network.magicBytes === 'id'\n ? DEVNET_URL\n : HIRO_TESTNET_URL;\n}\nexport function clientFromNetwork(network) {\n if (network.client.fetch)\n return network.client;\n return {\n ...network.client,\n fetch: createFetchFn(),\n };\n}\nexport function createNetwork(arg1, arg2) {\n const baseNetwork = networkFrom(typeof arg1 === 'object' && 'network' in arg1 ? arg1.network : arg1);\n const newNetwork = {\n ...baseNetwork,\n addressVersion: { ...baseNetwork.addressVersion },\n client: { ...baseNetwork.client },\n };\n if (typeof arg1 === 'object' && 'network' in arg1) {\n if (arg1.client) {\n newNetwork.client.baseUrl = arg1.client.baseUrl ?? newNetwork.client.baseUrl;\n newNetwork.client.fetch = arg1.client.fetch ?? newNetwork.client.fetch;\n }\n if (typeof arg1.apiKey === 'string') {\n const middleware = createApiKeyMiddleware(arg1);\n newNetwork.client.fetch = newNetwork.client.fetch\n ? createFetchFn(newNetwork.client.fetch, middleware)\n : createFetchFn(middleware);\n }\n return newNetwork;\n }\n if (typeof arg2 === 'string') {\n const middleware = createApiKeyMiddleware({ apiKey: arg2 });\n newNetwork.client.fetch = newNetwork.client.fetch\n ? createFetchFn(newNetwork.client.fetch, middleware)\n : createFetchFn(middleware);\n return newNetwork;\n }\n return newNetwork;\n}\n//# sourceMappingURL=network.js.map","class TransactionError extends Error {\n constructor(message) {\n super(message);\n this.message = message;\n this.name = this.constructor.name;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, this.constructor);\n }\n }\n}\nexport class SerializationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class DeserializationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class NoEstimateAvailableError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class NotImplementedError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class SigningError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class VerificationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\n//# sourceMappingURL=errors.js.map","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 { bytesToHex, hexToBytes, readUInt16BE, readUInt32BE, readUInt8 } from '@stacks/common';\nfunction createEnumChecker(enumVariable) {\n const enumValues = Object.values(enumVariable).filter(v => typeof v === 'number');\n const enumValueSet = new Set(enumValues);\n return (value) => enumValueSet.has(value);\n}\nconst enumCheckFunctions = new Map();\nexport function isEnum(enumVariable, value) {\n const checker = enumCheckFunctions.get(enumVariable);\n if (checker !== undefined) {\n return checker(value);\n }\n const newChecker = createEnumChecker(enumVariable);\n enumCheckFunctions.set(enumVariable, newChecker);\n return isEnum(enumVariable, value);\n}\nexport class BytesReader {\n constructor(bytes) {\n this.consumed = 0;\n this.source = typeof bytes === 'string' ? hexToBytes(bytes) : bytes;\n }\n readBytes(length) {\n const view = this.source.subarray(this.consumed, this.consumed + length);\n this.consumed += length;\n return view;\n }\n readUInt32BE() {\n return readUInt32BE(this.readBytes(4), 0);\n }\n readUInt8() {\n return readUInt8(this.readBytes(1), 0);\n }\n readUInt16BE() {\n return readUInt16BE(this.readBytes(2), 0);\n }\n readBigUIntLE(length) {\n const bytes = this.readBytes(length).slice().reverse();\n const hex = bytesToHex(bytes);\n return BigInt(`0x${hex}`);\n }\n readBigUIntBE(length) {\n const bytes = this.readBytes(length);\n const hex = bytesToHex(bytes);\n return BigInt(`0x${hex}`);\n }\n get readOffset() {\n return this.consumed;\n }\n set readOffset(val) {\n this.consumed = val;\n }\n get internalBytes() {\n return this.source;\n }\n readUInt8Enum(enumVariable, invalidEnumErrorFormatter) {\n const num = this.readUInt8();\n if (isEnum(enumVariable, num)) {\n return num;\n }\n throw invalidEnumErrorFormatter(num);\n }\n}\n//# sourceMappingURL=BytesReader.js.map","export const BLOCKSTACK_DEFAULT_GAIA_HUB_URL = 'https://hub.blockstack.org';\nexport const MAX_STRING_LENGTH_BYTES = 128;\nexport const CLARITY_INT_SIZE = 128;\nexport const CLARITY_INT_BYTE_SIZE = 16;\nexport const COINBASE_BYTES_LENGTH = 32;\nexport const VRF_PROOF_BYTES_LENGTH = 80;\nexport const RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;\nexport const COMPRESSED_PUBKEY_LENGTH_BYTES = 32;\nexport const UNCOMPRESSED_PUBKEY_LENGTH_BYTES = 64;\nexport const MEMO_MAX_LENGTH_BYTES = 34;\nconst MAX_PAYLOAD_LEN = 1 + 16 * 1024 * 1024;\nconst PREAMBLE_ENCODED_SIZE = 165;\nconst MAX_RELAYERS_LEN = 16;\nconst PEER_ADDRESS_ENCODED_SIZE = 16;\nconst HASH160_ENCODED_SIZE = 20;\nconst NEIGHBOR_ADDRESS_ENCODED_SIZE = PEER_ADDRESS_ENCODED_SIZE + 2 + HASH160_ENCODED_SIZE;\nconst RELAY_DATA_ENCODED_SIZE = NEIGHBOR_ADDRESS_ENCODED_SIZE + 4;\nexport const STRING_MAX_LENGTH = MAX_PAYLOAD_LEN + (PREAMBLE_ENCODED_SIZE + MAX_RELAYERS_LEN * RELAY_DATA_ENCODED_SIZE);\nexport var PayloadType;\n(function (PayloadType) {\n PayloadType[PayloadType[\"TokenTransfer\"] = 0] = \"TokenTransfer\";\n PayloadType[PayloadType[\"SmartContract\"] = 1] = \"SmartContract\";\n PayloadType[PayloadType[\"VersionedSmartContract\"] = 6] = \"VersionedSmartContract\";\n PayloadType[PayloadType[\"ContractCall\"] = 2] = \"ContractCall\";\n PayloadType[PayloadType[\"PoisonMicroblock\"] = 3] = \"PoisonMicroblock\";\n PayloadType[PayloadType[\"Coinbase\"] = 4] = \"Coinbase\";\n PayloadType[PayloadType[\"CoinbaseToAltRecipient\"] = 5] = \"CoinbaseToAltRecipient\";\n PayloadType[PayloadType[\"TenureChange\"] = 7] = \"TenureChange\";\n PayloadType[PayloadType[\"NakamotoCoinbase\"] = 8] = \"NakamotoCoinbase\";\n})(PayloadType \|\| (PayloadType = {}));\nexport var ClarityVersion;\n(function (ClarityVersion) {\n ClarityVersion[ClarityVersion[\"Clarity1\"] = 1] = \"Clarity1\";\n ClarityVersion[ClarityVersion[\"Clarity2\"] = 2] = \"Clarity2\";\n ClarityVersion[ClarityVersion[\"Clarity3\"] = 3] = \"Clarity3\";\n ClarityVersion[ClarityVersion[\"Clarity4\"] = 4] = \"Clarity4\";\n})(ClarityVersion \|\| (ClarityVersion = {}));\nexport var AnchorMode;\n(function (AnchorMode) {\n AnchorMode[AnchorMode[\"OnChainOnly\"] = 1] = \"OnChainOnly\";\n AnchorMode[AnchorMode[\"OffChainOnly\"] = 2] = \"OffChainOnly\";\n AnchorMode[AnchorMode[\"Any\"] = 3] = \"Any\";\n})(AnchorMode \|\| (AnchorMode = {}));\nexport const AnchorModeNames = ['onChainOnly', 'offChainOnly', 'any'];\nconst AnchorModeMap = {\n [AnchorModeNames[0]]: AnchorMode.OnChainOnly,\n [AnchorModeNames[1]]: AnchorMode.OffChainOnly,\n [AnchorModeNames[2]]: AnchorMode.Any,\n [AnchorMode.OnChainOnly]: AnchorMode.OnChainOnly,\n [AnchorMode.OffChainOnly]: AnchorMode.OffChainOnly,\n [AnchorMode.Any]: AnchorMode.Any,\n};\nexport function anchorModeFrom(mode) {\n if (mode in AnchorModeMap)\n return AnchorModeMap[mode];\n throw new Error(`Invalid anchor mode \"${mode}\", must be one of: ${AnchorModeNames.join(', ')}`);\n}\nexport var PostConditionMode;\n(function (PostConditionMode) {\n PostConditionMode[PostConditionMode[\"Allow\"] = 1] = \"Allow\";\n PostConditionMode[PostConditionMode[\"Deny\"] = 2] = \"Deny\";\n})(PostConditionMode \|\| (PostConditionMode = {}));\nexport var PostConditionType;\n(function (PostConditionType) {\n PostConditionType[PostConditionType[\"STX\"] = 0] = \"STX\";\n PostConditionType[PostConditionType[\"Fungible\"] = 1] = \"Fungible\";\n PostConditionType[PostConditionType[\"NonFungible\"] = 2] = \"NonFungible\";\n})(PostConditionType \|\| (PostConditionType = {}));\nexport var AuthType;\n(function (AuthType) {\n AuthType[AuthType[\"Standard\"] = 4] = \"Standard\";\n AuthType[AuthType[\"Sponsored\"] = 5] = \"Sponsored\";\n})(AuthType \|\| (AuthType = {}));\nexport var AddressHashMode;\n(function (AddressHashMode) {\n AddressHashMode[AddressHashMode[\"P2PKH\"] = 0] = \"P2PKH\";\n AddressHashMode[AddressHashMode[\"P2SH\"] = 1] = \"P2SH\";\n AddressHashMode[AddressHashMode[\"P2WPKH\"] = 2] = \"P2WPKH\";\n AddressHashMode[AddressHashMode[\"P2WSH\"] = 3] = \"P2WSH\";\n AddressHashMode[AddressHashMode[\"P2SHNonSequential\"] = 5] = \"P2SHNonSequential\";\n AddressHashMode[AddressHashMode[\"P2WSHNonSequential\"] = 7] = \"P2WSHNonSequential\";\n})(AddressHashMode \|\| (AddressHashMode = {}));\nexport { AddressVersion } from '@stacks/network';\nexport var PubKeyEncoding;\n(function (PubKeyEncoding) {\n PubKeyEncoding[PubKeyEncoding[\"Compressed\"] = 0] = \"Compressed\";\n PubKeyEncoding[PubKeyEncoding[\"Uncompressed\"] = 1] = \"Uncompressed\";\n})(PubKeyEncoding \|\| (PubKeyEncoding = {}));\nexport var FungibleConditionCode;\n(function (FungibleConditionCode) {\n FungibleConditionCode[FungibleConditionCode[\"Equal\"] = 1] = \"Equal\";\n FungibleConditionCode[FungibleConditionCode[\"Greater\"] = 2] = \"Greater\";\n FungibleConditionCode[FungibleConditionCode[\"GreaterEqual\"] = 3] = \"GreaterEqual\";\n FungibleConditionCode[FungibleConditionCode[\"Less\"] = 4] = \"Less\";\n FungibleConditionCode[FungibleConditionCode[\"LessEqual\"] = 5] = \"LessEqual\";\n})(FungibleConditionCode \|\| (FungibleConditionCode = {}));\nexport var NonFungibleConditionCode;\n(function (NonFungibleConditionCode) {\n NonFungibleConditionCode[NonFungibleConditionCode[\"Sends\"] = 16] = \"Sends\";\n NonFungibleConditionCode[NonFungibleConditionCode[\"DoesNotSend\"] = 17] = \"DoesNotSend\";\n})(NonFungibleConditionCode \|\| (NonFungibleConditionCode = {}));\nexport var PostConditionPrincipalId;\n(function (PostConditionPrincipalId) {\n PostConditionPrincipalId[PostConditionPrincipalId[\"Origin\"] = 1] = \"Origin\";\n PostConditionPrincipalId[PostConditionPrincipalId[\"Standard\"] = 2] = \"Standard\";\n PostConditionPrincipalId[PostConditionPrincipalId[\"Contract\"] = 3] = \"Contract\";\n})(PostConditionPrincipalId \|\| (PostConditionPrincipalId = {}));\nexport var AssetType;\n(function (AssetType) {\n AssetType[AssetType[\"STX\"] = 0] = \"STX\";\n AssetType[AssetType[\"Fungible\"] = 1] = \"Fungible\";\n AssetType[AssetType[\"NonFungible\"] = 2] = \"NonFungible\";\n})(AssetType \|\| (AssetType = {}));\nexport var TenureChangeCause;\n(function (TenureChangeCause) {\n TenureChangeCause[TenureChangeCause[\"BlockFound\"] = 0] = \"BlockFound\";\n TenureChangeCause[TenureChangeCause[\"Extended\"] = 1] = \"Extended\";\n})(TenureChangeCause \|\| (TenureChangeCause = {}));\nexport var AuthFieldType;\n(function (AuthFieldType) {\n AuthFieldType[AuthFieldType[\"PublicKeyCompressed\"] = 0] = \"PublicKeyCompressed\";\n AuthFieldType[AuthFieldType[\"PublicKeyUncompressed\"] = 1] = \"PublicKeyUncompressed\";\n AuthFieldType[AuthFieldType[\"SignatureCompressed\"] = 2] = \"SignatureCompressed\";\n AuthFieldType[AuthFieldType[\"SignatureUncompressed\"] = 3] = \"SignatureUncompressed\";\n})(AuthFieldType \|\| (AuthFieldType = {}));\nexport var TxRejectedReason;\n(function (TxRejectedReason) {\n TxRejectedReason[\"Serialization\"] = \"Serialization\";\n TxRejectedReason[\"Deserialization\"] = \"Deserialization\";\n TxRejectedReason[\"SignatureValidation\"] = \"SignatureValidation\";\n TxRejectedReason[\"FeeTooLow\"] = \"FeeTooLow\";\n TxRejectedReason[\"BadNonce\"] = \"BadNonce\";\n TxRejectedReason[\"NotEnoughFunds\"] = \"NotEnoughFunds\";\n TxRejectedReason[\"NoSuchContract\"] = \"NoSuchContract\";\n TxRejectedReason[\"NoSuchPublicFunction\"] = \"NoSuchPublicFunction\";\n TxRejectedReason[\"BadFunctionArgument\"] = \"BadFunctionArgument\";\n TxRejectedReason[\"ContractAlreadyExists\"] = \"ContractAlreadyExists\";\n TxRejectedReason[\"PoisonMicroblocksDoNotConflict\"] = \"PoisonMicroblocksDoNotConflict\";\n TxRejectedReason[\"PoisonMicroblockHasUnknownPubKeyHash\"] = \"PoisonMicroblockHasUnknownPubKeyHash\";\n TxRejectedReason[\"PoisonMicroblockIsInvalid\"] = \"PoisonMicroblockIsInvalid\";\n TxRejectedReason[\"BadAddressVersionByte\"] = \"BadAddressVersionByte\";\n TxRejectedReason[\"NoCoinbaseViaMempool\"] = \"NoCoinbaseViaMempool\";\n TxRejectedReason[\"ServerFailureNoSuchChainTip\"] = \"ServerFailureNoSuchChainTip\";\n TxRejectedReason[\"ServerFailureDatabase\"] = \"ServerFailureDatabase\";\n TxRejectedReason[\"ServerFailureOther\"] = \"ServerFailureOther\";\n})(TxRejectedReason \|\| (TxRejectedReason = {}));\n//# sourceMappingURL=constants.js.map","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, 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 / (10246)) 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 { 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","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","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","/! 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","export var ClarityType;\n(function (ClarityType) {\n ClarityType[\"Int\"] = \"int\";\n ClarityType[\"UInt\"] = \"uint\";\n ClarityType[\"Buffer\"] = \"buffer\";\n ClarityType[\"BoolTrue\"] = \"true\";\n ClarityType[\"BoolFalse\"] = \"false\";\n ClarityType[\"PrincipalStandard\"] = \"address\";\n ClarityType[\"PrincipalContract\"] = \"contract\";\n ClarityType[\"ResponseOk\"] = \"ok\";\n ClarityType[\"ResponseErr\"] = \"err\";\n ClarityType[\"OptionalNone\"] = \"none\";\n ClarityType[\"OptionalSome\"] = \"some\";\n ClarityType[\"List\"] = \"list\";\n ClarityType[\"Tuple\"] = \"tuple\";\n ClarityType[\"StringASCII\"] = \"ascii\";\n ClarityType[\"StringUTF8\"] = \"utf8\";\n})(ClarityType \|\| (ClarityType = {}));\nexport var ClarityWireType;\n(function (ClarityWireType) {\n ClarityWireType[ClarityWireType[\"int\"] = 0] = \"int\";\n ClarityWireType[ClarityWireType[\"uint\"] = 1] = \"uint\";\n ClarityWireType[ClarityWireType[\"buffer\"] = 2] = \"buffer\";\n ClarityWireType[ClarityWireType[\"true\"] = 3] = \"true\";\n ClarityWireType[ClarityWireType[\"false\"] = 4] = \"false\";\n ClarityWireType[ClarityWireType[\"address\"] = 5] = \"address\";\n ClarityWireType[ClarityWireType[\"contract\"] = 6] = \"contract\";\n ClarityWireType[ClarityWireType[\"ok\"] = 7] = \"ok\";\n ClarityWireType[ClarityWireType[\"err\"] = 8] = \"err\";\n ClarityWireType[ClarityWireType[\"none\"] = 9] = \"none\";\n ClarityWireType[ClarityWireType[\"some\"] = 10] = \"some\";\n ClarityWireType[ClarityWireType[\"list\"] = 11] = \"list\";\n ClarityWireType[ClarityWireType[\"tuple\"] = 12] = \"tuple\";\n ClarityWireType[ClarityWireType[\"ascii\"] = 13] = \"ascii\";\n ClarityWireType[ClarityWireType[\"utf8\"] = 14] = \"utf8\";\n})(ClarityWireType \|\| (ClarityWireType = {}));\nexport function clarityTypeToByte(type) {\n return ClarityWireType[type];\n}\nexport function clarityByteToType(wireType) {\n return ClarityWireType[wireType];\n}\n//# sourceMappingURL=constants.js.map","import { bytesToTwosBigInt, hexToBytes, intToBigInt, isInstance, } from '@stacks/common';\nimport { ClarityType } from '../constants';\nconst MAX_U128 = BigInt('0xffffffffffffffffffffffffffffffff');\nconst MIN_U128 = BigInt(0);\nconst MAX_I128 = BigInt('0x7fffffffffffffffffffffffffffffff');\nconst MIN_I128 = BigInt('-170141183460469231731687303715884105728');\nexport const intCV = (value) => {\n if (typeof value === 'string' && value.toLowerCase().startsWith('0x')) {\n value = bytesToTwosBigInt(hexToBytes(value));\n }\n if (isInstance(value, Uint8Array))\n value = bytesToTwosBigInt(value);\n const bigInt = intToBigInt(value);\n if (bigInt > MAX_I128) {\n throw new RangeError(`Cannot construct clarity integer from value greater than ${MAX_I128}`);\n }\n else if (bigInt < MIN_I128) {\n throw new RangeError(`Cannot construct clarity integer form value less than ${MIN_I128}`);\n }\n return { type: ClarityType.Int, value: bigInt };\n};\nexport const uintCV = (value) => {\n const bigInt = intToBigInt(value);\n if (bigInt < MIN_U128) {\n throw new RangeError('Cannot construct unsigned clarity integer from negative value');\n }\n else if (bigInt > MAX_U128) {\n throw new RangeError(`Cannot construct unsigned clarity integer greater than ${MAX_U128}`);\n }\n return { type: ClarityType.UInt, value: bigInt };\n};\n//# sourceMappingURL=intCV.js.map","import { bytesToHex, utf8ToBytes } from '@stacks/common';\nimport { ClarityType } from '../constants';\nexport const bufferCV = (buffer) => {\n if (buffer.byteLength > 1048576) {\n throw new Error('Cannot construct clarity buffer that is greater than 1MB');\n }\n return { type: ClarityType.Buffer, value: bytesToHex(buffer) };\n};\nexport const bufferCVFromString = (str) => bufferCV(utf8ToBytes(str));\n//# sourceMappingURL=bufferCV.js.map","export var StacksWireType;\n(function (StacksWireType) {\n StacksWireType[StacksWireType[\"Address\"] = 0] = \"Address\";\n StacksWireType[StacksWireType[\"Principal\"] = 1] = \"Principal\";\n StacksWireType[StacksWireType[\"LengthPrefixedString\"] = 2] = \"LengthPrefixedString\";\n StacksWireType[StacksWireType[\"MemoString\"] = 3] = \"MemoString\";\n StacksWireType[StacksWireType[\"Asset\"] = 4] = \"Asset\";\n StacksWireType[StacksWireType[\"PostCondition\"] = 5] = \"PostCondition\";\n StacksWireType[StacksWireType[\"PublicKey\"] = 6] = \"PublicKey\";\n StacksWireType[StacksWireType[\"LengthPrefixedList\"] = 7] = \"LengthPrefixedList\";\n StacksWireType[StacksWireType[\"Payload\"] = 8] = \"Payload\";\n StacksWireType[StacksWireType[\"MessageSignature\"] = 9] = \"MessageSignature\";\n StacksWireType[StacksWireType[\"StructuredDataSignature\"] = 10] = \"StructuredDataSignature\";\n StacksWireType[StacksWireType[\"TransactionAuthField\"] = 11] = \"TransactionAuthField\";\n})(StacksWireType \|\| (StacksWireType = {}));\nexport function whenWireType(wireType) {\n return (wireTypeMap) => wireTypeMap[wireType];\n}\n//# sourceMappingURL=types.js.map","import { hexToBytes, intToBigInt } from '@stacks/common';\nimport { c32addressDecode } from 'c32check';\nimport { ClarityType, principalCV } from '../clarity';\nimport { AddressVersion, COINBASE_BYTES_LENGTH, MAX_STRING_LENGTH_BYTES, MEMO_MAX_LENGTH_BYTES, PayloadType, PostConditionPrincipalId, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, VRF_PROOF_BYTES_LENGTH, } from '../constants';\nimport { exceedsMaxLengthBytes } from '../utils';\nimport { StacksWireType, } from './types';\nexport function createEmptyAddress() {\n return {\n type: StacksWireType.Address,\n version: AddressVersion.MainnetSingleSig,\n hash160: '0'.repeat(40),\n };\n}\nexport function createMemoString(content) {\n if (content && exceedsMaxLengthBytes(content, MEMO_MAX_LENGTH_BYTES)) {\n throw new Error(`Memo exceeds maximum length of ${MEMO_MAX_LENGTH_BYTES} bytes`);\n }\n return { type: StacksWireType.MemoString, content };\n}\nexport function createLPList(values, lengthPrefixBytes) {\n return {\n type: StacksWireType.LengthPrefixedList,\n lengthPrefixBytes: lengthPrefixBytes \|\| 4,\n values,\n };\n}\nexport function createMessageSignature(signature) {\n const length = hexToBytes(signature).byteLength;\n if (length != RECOVERABLE_ECDSA_SIG_LENGTH_BYTES) {\n throw Error('Invalid signature');\n }\n return {\n type: StacksWireType.MessageSignature,\n data: signature,\n };\n}\nexport function createTokenTransferPayload(recipient, amount, memo) {\n if (typeof recipient === 'string') {\n recipient = principalCV(recipient);\n }\n if (typeof memo === 'string') {\n memo = createMemoString(memo);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.TokenTransfer,\n recipient,\n amount: intToBigInt(amount),\n memo: memo ?? createMemoString(''),\n };\n}\nexport function createContractCallPayload(contractAddress, contractName, functionName, functionArgs) {\n if (typeof contractName === 'string') {\n contractName = createLPString(contractName);\n }\n if (typeof functionName === 'string') {\n functionName = createLPString(functionName);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.ContractCall,\n contractAddress: typeof contractAddress === 'string' ? createAddress(contractAddress) : contractAddress,\n contractName,\n functionName,\n functionArgs,\n };\n}\nexport function codeBodyString(content) {\n return createLPString(content, 4, 100000);\n}\nexport function createSmartContractPayload(contractName, codeBody, clarityVersion) {\n if (typeof contractName === 'string') {\n contractName = createLPString(contractName);\n }\n if (typeof codeBody === 'string') {\n codeBody = codeBodyString(codeBody);\n }\n if (typeof clarityVersion === 'number') {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.VersionedSmartContract,\n clarityVersion,\n contractName,\n codeBody,\n };\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.SmartContract,\n contractName,\n codeBody,\n };\n}\nexport function createPoisonPayload() {\n return { type: StacksWireType.Payload, payloadType: PayloadType.PoisonMicroblock };\n}\nexport function createCoinbasePayload(coinbaseBytes, altRecipient) {\n if (coinbaseBytes.byteLength != COINBASE_BYTES_LENGTH) {\n throw Error(`Coinbase buffer size must be ${COINBASE_BYTES_LENGTH} bytes`);\n }\n if (altRecipient != undefined) {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.CoinbaseToAltRecipient,\n coinbaseBytes,\n recipient: altRecipient,\n };\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.Coinbase,\n coinbaseBytes,\n };\n}\nexport function createNakamotoCoinbasePayload(coinbaseBytes, recipient, vrfProof) {\n if (coinbaseBytes.byteLength != COINBASE_BYTES_LENGTH) {\n throw Error(`Coinbase buffer size must be ${COINBASE_BYTES_LENGTH} bytes`);\n }\n if (vrfProof.byteLength != VRF_PROOF_BYTES_LENGTH) {\n throw Error(`VRF proof buffer size must be ${VRF_PROOF_BYTES_LENGTH} bytes`);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.NakamotoCoinbase,\n coinbaseBytes,\n recipient: recipient.type === ClarityType.OptionalSome ? recipient.value : undefined,\n vrfProof,\n };\n}\nexport function createTenureChangePayload(tenureHash, previousTenureHash, burnViewHash, previousTenureEnd, previousTenureBlocks, cause, publicKeyHash) {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.TenureChange,\n tenureHash,\n previousTenureHash,\n burnViewHash,\n previousTenureEnd,\n previousTenureBlocks,\n cause,\n publicKeyHash,\n };\n}\nexport function createLPString(content, lengthPrefixBytes, maxLengthBytes) {\n const prefixLength = lengthPrefixBytes \|\| 1;\n const maxLength = maxLengthBytes \|\| MAX_STRING_LENGTH_BYTES;\n if (exceedsMaxLengthBytes(content, maxLength)) {\n throw new Error(`String length exceeds maximum bytes ${maxLength}`);\n }\n return {\n type: StacksWireType.LengthPrefixedString,\n content,\n lengthPrefixBytes: prefixLength,\n maxLengthBytes: maxLength,\n };\n}\nexport function createAsset(addressString, contractName, assetName) {\n return {\n type: StacksWireType.Asset,\n address: createAddress(addressString),\n contractName: createLPString(contractName),\n assetName: createLPString(assetName),\n };\n}\nexport function createAddress(c32AddressString) {\n const addressData = c32addressDecode(c32AddressString);\n return {\n type: StacksWireType.Address,\n version: addressData[0],\n hash160: addressData[1],\n };\n}\nexport function createContractPrincipal(addressString, contractName) {\n const addr = createAddress(addressString);\n const name = createLPString(contractName);\n return {\n type: StacksWireType.Principal,\n prefix: PostConditionPrincipalId.Contract,\n address: addr,\n contractName: name,\n };\n}\nexport function createStandardPrincipal(addressString) {\n const addr = createAddress(addressString);\n return {\n type: StacksWireType.Principal,\n prefix: PostConditionPrincipalId.Standard,\n address: addr,\n };\n}\nexport function createTransactionAuthField(pubKeyEncoding, contents) {\n return {\n pubKeyEncoding,\n type: StacksWireType.TransactionAuthField,\n contents,\n };\n}\n//# sourceMappingURL=create.js.map","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 { 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","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 { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { getPublicKey as nobleGetPublicKey, Point, Signature, signSync, utils, } from '@noble/secp256k1';\nimport { bytesToHex, hexToBigInt, hexToBytes, intToHex, parseRecoverableSignatureVrs, PRIVATE_KEY_BYTES_COMPRESSED, privateKeyToBytes, signatureRsvToVrs, signatureVrsToRsv, } from '@stacks/common';\nimport { networkFrom, STACKS_MAINNET } from '@stacks/network';\nimport { c32address } from 'c32check';\nimport { addressHashModeToVersion } from './address';\nimport { AddressHashMode, PubKeyEncoding } from './constants';\nimport { hash160, hashP2PKH } from './utils';\nimport { addressFromVersionHash, addressToString, StacksWireType } from './wire';\nutils.hmacSha256Sync = (key, ...msgs) => {\n const h = hmac.create(sha256, key);\n msgs.forEach(msg => h.update(msg));\n return h.digest();\n};\nexport function getAddressFromPrivateKey(privateKey, network = 'mainnet') {\n network = networkFrom(network);\n const publicKey = privateKeyToPublic(privateKey);\n return getAddressFromPublicKey(publicKey, network);\n}\nexport function getAddressFromPublicKey(publicKey, network = 'mainnet') {\n network = networkFrom(network);\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n const addrVer = addressHashModeToVersion(AddressHashMode.P2PKH, network);\n const addr = addressFromVersionHash(addrVer, hashP2PKH(publicKey));\n const addrString = addressToString(addr);\n return addrString;\n}\nexport function createStacksPublicKey(publicKey) {\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return {\n type: StacksWireType.PublicKey,\n data: publicKey,\n };\n}\nexport function publicKeyFromSignatureVrs(messageHash, messageSignature, pubKeyEncoding = PubKeyEncoding.Compressed) {\n const parsedSignature = parseRecoverableSignatureVrs(messageSignature);\n const signature = new Signature(hexToBigInt(parsedSignature.r), hexToBigInt(parsedSignature.s));\n const point = Point.fromSignature(messageHash, signature, parsedSignature.recoveryId);\n const compressed = pubKeyEncoding === PubKeyEncoding.Compressed;\n return point.toHex(compressed);\n}\nexport function publicKeyFromSignatureRsv(messageHash, messageSignature, pubKeyEncoding = PubKeyEncoding.Compressed) {\n return publicKeyFromSignatureVrs(messageHash, signatureRsvToVrs(messageSignature), pubKeyEncoding);\n}\nexport function privateKeyToHex(publicKey) {\n return typeof publicKey === 'string' ? publicKey : bytesToHex(publicKey);\n}\nexport const publicKeyToHex = privateKeyToHex;\nexport const isPrivateKeyCompressed = privateKeyIsCompressed;\nexport function privateKeyIsCompressed(privateKey) {\n const length = typeof privateKey === 'string' ? privateKey.length / 2 : privateKey.byteLength;\n return length === PRIVATE_KEY_BYTES_COMPRESSED;\n}\nexport const isPublicKeyCompressed = publicKeyIsCompressed;\nexport function publicKeyIsCompressed(publicKey) {\n return !publicKeyToHex(publicKey).startsWith('04');\n}\nexport function privateKeyToPublic(privateKey) {\n privateKey = privateKeyToBytes(privateKey);\n const isCompressed = privateKeyIsCompressed(privateKey);\n return bytesToHex(nobleGetPublicKey(privateKey.slice(0, 32), isCompressed));\n}\nexport function compressPublicKey(publicKey) {\n return Point.fromHex(publicKeyToHex(publicKey)).toHex(true);\n}\nexport function uncompressPublicKey(publicKey) {\n return Point.fromHex(publicKeyToHex(publicKey)).toHex(false);\n}\nexport const makeRandomPrivKey = randomPrivateKey;\nexport function randomPrivateKey() {\n return compressPrivateKey(utils.randomPrivateKey());\n}\nexport function signWithKey(privateKey, messageHash) {\n privateKey = privateKeyToBytes(privateKey);\n const [rawSignature, recoveryId] = signSync(messageHash, privateKey.slice(0, 32), {\n canonical: true,\n recovered: true,\n });\n if (recoveryId == null) {\n throw new Error('No signature recoveryId received');\n }\n const recoveryIdHex = intToHex(recoveryId, 1);\n return recoveryIdHex + Signature.fromHex(rawSignature).toCompactHex();\n}\nexport function signMessageHashRsv({ messageHash, privateKey, }) {\n return signatureVrsToRsv(signWithKey(privateKey, messageHash));\n}\nexport function compressPrivateKey(privateKey) {\n privateKey = privateKeyToHex(privateKey);\n return privateKey.length == PRIVATE_KEY_BYTES_COMPRESSED * 2\n ? privateKey\n : `${privateKey}01`;\n}\nexport function privateKeyToAddress(privateKey, network) {\n const publicKey = privateKeyToPublic(privateKey);\n return publicKeyToAddressSingleSig(publicKey, network);\n}\nexport function publicKeyToAddress(...args) {\n if (typeof args[0] === 'number')\n return _publicKeyToAddress(...args);\n return publicKeyToAddressSingleSig(...args);\n}\nfunction _publicKeyToAddress(version, publicKey) {\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return c32address(version, bytesToHex(hash160(publicKey)));\n}\nexport function publicKeyToAddressSingleSig(publicKey, network) {\n network = network ? networkFrom(network) : STACKS_MAINNET;\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return c32address(network.addressVersion.singleSig, bytesToHex(hash160(publicKey)));\n}\n//# sourceMappingURL=keys.js.map","import { c32address } from 'c32check';\nimport { AddressHashMode, PayloadType } from '../constants';\nimport { publicKeyIsCompressed } from '../keys';\nimport { hashP2PKH, hashP2SH, hashP2WPKH, hashP2WSH } from '../utils';\nimport { createAsset, createContractPrincipal, createStandardPrincipal } from './create';\nimport { serializePublicKeyBytes } from './serialization';\nimport { StacksWireType, } from './types';\nexport function addressFromPublicKeys(version, hashMode, numSigs, publicKeys) {\n if (publicKeys.length === 0) {\n throw Error('Invalid number of public keys');\n }\n if (hashMode === AddressHashMode.P2PKH \|\| hashMode === AddressHashMode.P2WPKH) {\n if (publicKeys.length !== 1 \|\| numSigs !== 1) {\n throw Error('Invalid number of public keys or signatures');\n }\n }\n if (hashMode === AddressHashMode.P2WPKH \|\|\n hashMode === AddressHashMode.P2WSH \|\|\n hashMode === AddressHashMode.P2WSHNonSequential) {\n if (!publicKeys.map(p => p.data).every(publicKeyIsCompressed)) {\n throw Error('Public keys must be compressed for segwit');\n }\n }\n switch (hashMode) {\n case AddressHashMode.P2PKH:\n return addressFromVersionHash(version, hashP2PKH(publicKeys[0].data));\n case AddressHashMode.P2WPKH:\n return addressFromVersionHash(version, hashP2WPKH(publicKeys[0].data));\n case AddressHashMode.P2SH:\n case AddressHashMode.P2SHNonSequential:\n return addressFromVersionHash(version, hashP2SH(numSigs, publicKeys.map(serializePublicKeyBytes)));\n case AddressHashMode.P2WSH:\n case AddressHashMode.P2WSHNonSequential:\n return addressFromVersionHash(version, hashP2WSH(numSigs, publicKeys.map(serializePublicKeyBytes)));\n }\n}\nexport function addressFromVersionHash(version, hash) {\n return { type: StacksWireType.Address, version, hash160: hash };\n}\nexport function addressToString(address) {\n return c32address(address.version, address.hash160);\n}\nexport function isTokenTransferPayload(p) {\n return p.payloadType === PayloadType.TokenTransfer;\n}\nexport function isContractCallPayload(p) {\n return p.payloadType === PayloadType.ContractCall;\n}\nexport function isSmartContractPayload(p) {\n return p.payloadType === PayloadType.SmartContract;\n}\nexport function isPoisonPayload(p) {\n return p.payloadType === PayloadType.PoisonMicroblock;\n}\nexport function isCoinbasePayload(p) {\n return p.payloadType === PayloadType.Coinbase;\n}\nexport function parseAssetString(id) {\n const [assetAddress, assetContractName, assetTokenName] = id.split(/\\.\|::/);\n const asset = createAsset(assetAddress, assetContractName, assetTokenName);\n return asset;\n}\nexport function parsePrincipalString(principalString) {\n if (principalString.includes('.')) {\n const [address, contractName] = principalString.split('.');\n return createContractPrincipal(address, contractName);\n }\n else {\n return createStandardPrincipal(principalString);\n }\n}\n//# sourceMappingURL=helpers.js.map","import { utf8ToBytes } from '@stacks/common';\nimport { addressToString, createAddress, createLPString, } from '../../wire';\nimport { ClarityType } from '../constants';\nexport function principalCV(principal) {\n if (principal.includes('.')) {\n const [address, contractName] = principal.split('.');\n return contractPrincipalCV(address, contractName);\n }\n else {\n return standardPrincipalCV(principal);\n }\n}\nexport function standardPrincipalCV(addressString) {\n const addr = createAddress(addressString);\n return { type: ClarityType.PrincipalStandard, value: addressToString(addr) };\n}\nexport function standardPrincipalCVFromAddress(address) {\n return { type: ClarityType.PrincipalStandard, value: addressToString(address) };\n}\nexport function contractPrincipalCV(addressString, contractName) {\n const addr = createAddress(addressString);\n const lengthPrefixedContractName = createLPString(contractName);\n return contractPrincipalCVFromAddress(addr, lengthPrefixedContractName);\n}\nexport function contractPrincipalCVFromAddress(address, contractName) {\n if (utf8ToBytes(contractName.content).byteLength >= 128) {\n throw new Error('Contract name must be less than 128 bytes');\n }\n return {\n type: ClarityType.PrincipalContract,\n value: `${addressToString(address)}.${contractName.content}`,\n };\n}\nexport function contractPrincipalCVFromStandard(sp, contractName) {\n return {\n type: ClarityType.PrincipalContract,\n value: `${sp.value}.${contractName}`,\n };\n}\n//# sourceMappingURL=principalCV.js.map","import { ClarityType } from '../constants';\nexport function noneCV() {\n return { type: ClarityType.OptionalNone };\n}\nexport function someCV(value) {\n return { type: ClarityType.OptionalSome, value };\n}\nexport function optionalCVOf(value) {\n return value ? someCV(value) : noneCV();\n}\n//# sourceMappingURL=optionalCV.js.map","import { ClarityType } from '../constants';\nimport { isClarityName } from '../../utils';\nexport function tupleCV(data) {\n for (const key in data) {\n if (!isClarityName(key)) {\n throw new Error(`\"${key}\" is not a valid Clarity name`);\n }\n }\n return { type: ClarityType.Tuple, value: data };\n}\n//# sourceMappingURL=tupleCV.js.map","import { ClarityType } from '../constants';\nexport const stringAsciiCV = (data) => {\n return { type: ClarityType.StringASCII, value: data };\n};\nexport const stringUtf8CV = (data) => {\n return { type: ClarityType.StringUTF8, value: data };\n};\nexport const stringCV = (data, encoding) => {\n switch (encoding) {\n case 'ascii':\n return stringAsciiCV(data);\n case 'utf8':\n return stringUtf8CV(data);\n }\n};\n//# sourceMappingURL=stringCV.js.map","import { bytesToAscii, bytesToTwosBigInt, bytesToUtf8, hexToBytes } from '@stacks/common';\nimport { ClarityWireType, bufferCV, contractPrincipalCVFromAddress, falseCV, intCV, listCV, noneCV, responseErrorCV, responseOkCV, someCV, standardPrincipalCVFromAddress, stringAsciiCV, stringUtf8CV, trueCV, tupleCV, uintCV, } from '.';\nimport { BytesReader } from '../BytesReader';\nimport { DeserializationError } from '../errors';\nimport { deserializeAddress, deserializeLPString } from '../wire';\nexport function deserializeCV(serializedClarityValue) {\n let bytesReader;\n if (typeof serializedClarityValue === 'string') {\n const hasHexPrefix = serializedClarityValue.slice(0, 2).toLowerCase() === '0x';\n bytesReader = new BytesReader(hexToBytes(hasHexPrefix ? serializedClarityValue.slice(2) : serializedClarityValue));\n }\n else if (serializedClarityValue instanceof Uint8Array) {\n bytesReader = new BytesReader(serializedClarityValue);\n }\n else {\n bytesReader = serializedClarityValue;\n }\n const type = bytesReader.readUInt8Enum(ClarityWireType, n => {\n throw new DeserializationError(`Cannot recognize Clarity Type: ${n}`);\n });\n switch (type) {\n case ClarityWireType.int:\n return intCV(bytesToTwosBigInt(bytesReader.readBytes(16)));\n case ClarityWireType.uint:\n return uintCV(bytesReader.readBytes(16));\n case ClarityWireType.buffer:\n const bufferLength = bytesReader.readUInt32BE();\n return bufferCV(bytesReader.readBytes(bufferLength));\n case ClarityWireType.true:\n return trueCV();\n case ClarityWireType.false:\n return falseCV();\n case ClarityWireType.address:\n const sAddress = deserializeAddress(bytesReader);\n return standardPrincipalCVFromAddress(sAddress);\n case ClarityWireType.contract:\n const cAddress = deserializeAddress(bytesReader);\n const contractName = deserializeLPString(bytesReader);\n return contractPrincipalCVFromAddress(cAddress, contractName);\n case ClarityWireType.ok:\n return responseOkCV(deserializeCV(bytesReader));\n case ClarityWireType.err:\n return responseErrorCV(deserializeCV(bytesReader));\n case ClarityWireType.none:\n return noneCV();\n case ClarityWireType.some:\n return someCV(deserializeCV(bytesReader));\n case ClarityWireType.list:\n const listLength = bytesReader.readUInt32BE();\n const listContents = [];\n for (let i = 0; i < listLength; i++) {\n listContents.push(deserializeCV(bytesReader));\n }\n return listCV(listContents);\n case ClarityWireType.tuple:\n const tupleLength = bytesReader.readUInt32BE();\n const tupleContents = {};\n for (let i = 0; i < tupleLength; i++) {\n const clarityName = deserializeLPString(bytesReader).content;\n if (clarityName === undefined) {\n throw new DeserializationError('\"content\" is undefined');\n }\n tupleContents[clarityName] = deserializeCV(bytesReader);\n }\n return tupleCV(tupleContents);\n case ClarityWireType.ascii:\n const asciiStrLen = bytesReader.readUInt32BE();\n const asciiStr = bytesToAscii(bytesReader.readBytes(asciiStrLen));\n return stringAsciiCV(asciiStr);\n case ClarityWireType.utf8:\n const utf8StrLen = bytesReader.readUInt32BE();\n const utf8Str = bytesToUtf8(bytesReader.readBytes(utf8StrLen));\n return stringUtf8CV(utf8Str);\n default:\n throw new DeserializationError('Unable to deserialize Clarity Value from Uint8Array. Could not find valid Clarity Type.');\n }\n}\n//# sourceMappingURL=deserialize.js.map","import { ClarityType } from '../constants';\nexport const trueCV = () => ({ type: ClarityType.BoolTrue });\nexport const falseCV = () => ({ type: ClarityType.BoolFalse });\nexport const boolCV = (bool) => (bool ? trueCV() : falseCV());\n//# sourceMappingURL=booleanCV.js.map","import { ClarityType } from '../constants';\nexport function responseErrorCV(value) {\n return { type: ClarityType.ResponseErr, value };\n}\nexport function responseOkCV(value) {\n return { type: ClarityType.ResponseOk, value };\n}\n//# sourceMappingURL=responseCV.js.map","import { ClarityType } from '../constants';\nexport function listCV(values) {\n return { type: ClarityType.List, value: values };\n}\n//# sourceMappingURL=listCV.js.map","import { ripemd160 } from '@noble/hashes/ripemd160';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { sha512_256 } from '@noble/hashes/sha512';\nimport { utils } from '@noble/secp256k1';\nimport { bytesToHex, concatArray, concatBytes, utf8ToBytes } from '@stacks/common';\nimport { c32addressDecode } from 'c32check';\nimport lodashCloneDeep from 'lodash.clonedeep';\nimport { deserializeCV, serializeCV } from './clarity';\nexport { verify as verifySignature } from '@noble/secp256k1';\nexport const randomBytes = (bytesLength) => utils.randomBytes(bytesLength);\nexport const leftPadHex = (hexString) => hexString.length % 2 ? `0${hexString}` : hexString;\nexport const leftPadHexToLength = (hexString, length) => hexString.padStart(length, '0');\nexport const rightPadHexToLength = (hexString, length) => hexString.padEnd(length, '0');\nexport const exceedsMaxLengthBytes = (string, maxLengthBytes) => string ? utf8ToBytes(string).length > maxLengthBytes : false;\nexport function cloneDeep(obj) {\n return lodashCloneDeep(obj);\n}\nexport function omit(obj, prop) {\n const clone = cloneDeep(obj);\n delete clone[prop];\n return clone;\n}\nexport const hash160 = (input) => {\n return ripemd160(sha256(input));\n};\nexport const txidFromData = (data) => {\n return bytesToHex(sha512_256(data));\n};\nexport const txidFromBytes = txidFromData;\nexport const hashP2PKH = (input) => {\n return bytesToHex(hash160(input));\n};\nexport const hashP2WPKH = (input) => {\n const keyHash = hash160(input);\n const redeemScript = concatBytes(new Uint8Array([0]), new Uint8Array([keyHash.length]), keyHash);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport const hashP2SH = (numSigs, pubKeys) => {\n if (numSigs > 15 \|\| pubKeys.length > 15) {\n throw Error('P2SH multisig address can only contain up to 15 public keys');\n }\n const bytesArray = [];\n bytesArray.push(80 + numSigs);\n pubKeys.forEach(pubKey => {\n bytesArray.push(pubKey.length);\n bytesArray.push(pubKey);\n });\n bytesArray.push(80 + pubKeys.length);\n bytesArray.push(174);\n const redeemScript = concatArray(bytesArray);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport const hashP2WSH = (numSigs, pubKeys) => {\n if (numSigs > 15 \|\| pubKeys.length > 15) {\n throw Error('P2WSH multisig address can only contain up to 15 public keys');\n }\n const scriptArray = [];\n scriptArray.push(80 + numSigs);\n pubKeys.forEach(pubKey => {\n scriptArray.push(pubKey.length);\n scriptArray.push(pubKey);\n });\n scriptArray.push(80 + pubKeys.length);\n scriptArray.push(174);\n const script = concatArray(scriptArray);\n const digest = sha256(script);\n const bytesArray = [];\n bytesArray.push(0);\n bytesArray.push(digest.length);\n bytesArray.push(digest);\n const redeemScript = concatArray(bytesArray);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport function isClarityName(name) {\n const regex = /^[a-zA-Z]([a-zA-Z0-9]\|[-_!?+<>=/])$\|^[-+=/]$\|^[<>]=?$/;\n return regex.test(name) && name.length < 128;\n}\nexport function cvToHex(cv) {\n const serialized = serializeCV(cv);\n return `0x${serialized}`;\n}\nexport function hexToCV(hex) {\n return deserializeCV(hex);\n}\nexport const parseReadOnlyResponse = (response) => {\n if (response.okay)\n return hexToCV(response.result);\n throw new Error(response.cause);\n};\nexport const validateStacksAddress = (address) => {\n try {\n c32addressDecode(address);\n return true;\n }\n catch (e) {\n return false;\n }\n};\nexport function parseContractId(contractId) {\n const [address, name] = contractId.split('.');\n if (!address \|\| !name)\n throw new Error(`Invalid contract identifier: ${contractId}`);\n return [address, name];\n}\n//# sourceMappingURL=utils.js.map","import { asciiToBytes, bigIntToBytes, bytesToHex, concatArray, concatBytes, hexToBytes, toTwos, utf8ToBytes, writeUInt32BE, } from '@stacks/common';\nimport { CLARITY_INT_BYTE_SIZE, CLARITY_INT_SIZE } from '../constants';\nimport { SerializationError } from '../errors';\nimport { parseContractId } from '../utils';\nimport { createAddress, createLPString, serializeAddressBytes, serializeLPStringBytes, } from '../wire';\nimport { ClarityType, clarityTypeToByte } from './constants';\nfunction bytesWithTypeID(typeId, bytes) {\n return concatArray([clarityTypeToByte(typeId), bytes]);\n}\nfunction serializeBoolCV(value) {\n return new Uint8Array([clarityTypeToByte(value.type)]);\n}\nfunction serializeOptionalCV(cv) {\n if (cv.type === ClarityType.OptionalNone) {\n return new Uint8Array([clarityTypeToByte(cv.type)]);\n }\n else {\n return bytesWithTypeID(cv.type, serializeCVBytes(cv.value));\n }\n}\nfunction serializeBufferCV(cv) {\n const length = new Uint8Array(4);\n writeUInt32BE(length, Math.ceil(cv.value.length / 2), 0);\n return bytesWithTypeID(cv.type, concatBytes(length, hexToBytes(cv.value)));\n}\nfunction serializeIntCV(cv) {\n const bytes = bigIntToBytes(toTwos(BigInt(cv.value), BigInt(CLARITY_INT_SIZE)), CLARITY_INT_BYTE_SIZE);\n return bytesWithTypeID(cv.type, bytes);\n}\nfunction serializeUIntCV(cv) {\n const bytes = bigIntToBytes(BigInt(cv.value), CLARITY_INT_BYTE_SIZE);\n return bytesWithTypeID(cv.type, bytes);\n}\nfunction serializeStandardPrincipalCV(cv) {\n return bytesWithTypeID(cv.type, serializeAddressBytes(createAddress(cv.value)));\n}\nfunction serializeContractPrincipalCV(cv) {\n const [address, name] = parseContractId(cv.value);\n return bytesWithTypeID(cv.type, concatBytes(serializeAddressBytes(createAddress(address)), serializeLPStringBytes(createLPString(name))));\n}\nfunction serializeResponseCV(cv) {\n return bytesWithTypeID(cv.type, serializeCVBytes(cv.value));\n}\nfunction serializeListCV(cv) {\n const bytesArray = [];\n const length = new Uint8Array(4);\n writeUInt32BE(length, cv.value.length, 0);\n bytesArray.push(length);\n for (const value of cv.value) {\n const serializedValue = serializeCVBytes(value);\n bytesArray.push(serializedValue);\n }\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeTupleCV(cv) {\n const bytesArray = [];\n const length = new Uint8Array(4);\n writeUInt32BE(length, Object.keys(cv.value).length, 0);\n bytesArray.push(length);\n const lexicographicOrder = Object.keys(cv.value).sort((a, b) => a.localeCompare(b));\n for (const key of lexicographicOrder) {\n const nameWithLength = createLPString(key);\n bytesArray.push(serializeLPStringBytes(nameWithLength));\n const serializedValue = serializeCVBytes(cv.value[key]);\n bytesArray.push(serializedValue);\n }\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeStringCV(cv, encoding) {\n const bytesArray = [];\n const str = encoding == 'ascii' ? asciiToBytes(cv.value) : utf8ToBytes(cv.value);\n const len = new Uint8Array(4);\n writeUInt32BE(len, str.length, 0);\n bytesArray.push(len);\n bytesArray.push(str);\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeStringAsciiCV(cv) {\n return serializeStringCV(cv, 'ascii');\n}\nfunction serializeStringUtf8CV(cv) {\n return serializeStringCV(cv, 'utf8');\n}\nexport function serializeCV(value) {\n return bytesToHex(serializeCVBytes(value));\n}\nexport function serializeCVBytes(value) {\n switch (value.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return serializeBoolCV(value);\n case ClarityType.OptionalNone:\n case ClarityType.OptionalSome:\n return serializeOptionalCV(value);\n case ClarityType.Buffer:\n return serializeBufferCV(value);\n case ClarityType.UInt:\n return serializeUIntCV(value);\n case ClarityType.Int:\n return serializeIntCV(value);\n case ClarityType.PrincipalStandard:\n return serializeStandardPrincipalCV(value);\n case ClarityType.PrincipalContract:\n return serializeContractPrincipalCV(value);\n case ClarityType.ResponseOk:\n case ClarityType.ResponseErr:\n return serializeResponseCV(value);\n case ClarityType.List:\n return serializeListCV(value);\n case ClarityType.Tuple:\n return serializeTupleCV(value);\n case ClarityType.StringASCII:\n return serializeStringAsciiCV(value);\n case ClarityType.StringUTF8:\n return serializeStringUtf8CV(value);\n default:\n throw new SerializationError('Unable to serialize. Invalid Clarity Value.');\n }\n}\n//# sourceMappingURL=serialize.js.map","import { bytesToHex, bytesToUtf8, concatArray, hexToBytes, hexToInt, intToBigInt, intToBytes, intToHex, isInstance, utf8ToBytes, writeUInt32BE, writeUInt8, } from '@stacks/common';\nimport { BytesReader } from '../BytesReader';\nimport { deserializeCV, noneCV, serializeCVBytes, someCV, } from '../clarity';\nimport { AuthFieldType, COINBASE_BYTES_LENGTH, COMPRESSED_PUBKEY_LENGTH_BYTES, ClarityVersion, FungibleConditionCode, STRING_MAX_LENGTH, MEMO_MAX_LENGTH_BYTES, NonFungibleConditionCode, PayloadType, PostConditionPrincipalId, PostConditionType, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, TenureChangeCause, UNCOMPRESSED_PUBKEY_LENGTH_BYTES, VRF_PROOF_BYTES_LENGTH, } from '../constants';\nimport { DeserializationError, SerializationError } from '../errors';\nimport { compressPublicKey, createStacksPublicKey, uncompressPublicKey } from '../keys';\nimport { rightPadHexToLength } from '../utils';\nimport { createCoinbasePayload, createContractCallPayload, createLPList, createLPString, createMessageSignature, createNakamotoCoinbasePayload, createPoisonPayload, createSmartContractPayload, createTenureChangePayload, createTokenTransferPayload, createTransactionAuthField, } from './create';\nimport { StacksWireType, } from './types';\nexport function serializeStacksWire(wire) {\n return bytesToHex(serializeStacksWireBytes(wire));\n}\nexport function serializeStacksWireBytes(wire) {\n switch (wire.type) {\n case StacksWireType.Address:\n return serializeAddressBytes(wire);\n case StacksWireType.Principal:\n return serializePrincipalBytes(wire);\n case StacksWireType.LengthPrefixedString:\n return serializeLPStringBytes(wire);\n case StacksWireType.MemoString:\n return serializeMemoStringBytes(wire);\n case StacksWireType.Asset:\n return serializeAssetBytes(wire);\n case StacksWireType.PostCondition:\n return serializePostConditionWireBytes(wire);\n case StacksWireType.PublicKey:\n return serializePublicKeyBytes(wire);\n case StacksWireType.LengthPrefixedList:\n return serializeLPListBytes(wire);\n case StacksWireType.Payload:\n return serializePayloadBytes(wire);\n case StacksWireType.TransactionAuthField:\n return serializeTransactionAuthFieldBytes(wire);\n case StacksWireType.MessageSignature:\n return serializeMessageSignatureBytes(wire);\n }\n}\nexport function deserializeStacksWire(bytesReader, type, listType) {\n switch (type) {\n case StacksWireType.Address:\n return deserializeAddress(bytesReader);\n case StacksWireType.Principal:\n return deserializePrincipal(bytesReader);\n case StacksWireType.LengthPrefixedString:\n return deserializeLPString(bytesReader);\n case StacksWireType.MemoString:\n return deserializeMemoString(bytesReader);\n case StacksWireType.Asset:\n return deserializeAsset(bytesReader);\n case StacksWireType.PostCondition:\n return deserializePostConditionWire(bytesReader);\n case StacksWireType.PublicKey:\n return deserializePublicKey(bytesReader);\n case StacksWireType.Payload:\n return deserializePayload(bytesReader);\n case StacksWireType.LengthPrefixedList:\n if (!listType) {\n throw new DeserializationError('No list type specified');\n }\n return deserializeLPList(bytesReader, listType);\n case StacksWireType.MessageSignature:\n return deserializeMessageSignature(bytesReader);\n default:\n throw new Error('Could not recognize StacksWireType');\n }\n}\nexport function serializeAddress(address) {\n return bytesToHex(serializeAddressBytes(address));\n}\nexport function serializeAddressBytes(address) {\n const bytesArray = [];\n bytesArray.push(hexToBytes(intToHex(address.version, 1)));\n bytesArray.push(hexToBytes(address.hash160));\n return concatArray(bytesArray);\n}\nexport function deserializeAddress(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const version = hexToInt(bytesToHex(bytesReader.readBytes(1)));\n const data = bytesToHex(bytesReader.readBytes(20));\n return { type: StacksWireType.Address, version, hash160: data };\n}\nexport function serializePrincipal(principal) {\n return bytesToHex(serializePrincipalBytes(principal));\n}\nexport function serializePrincipalBytes(principal) {\n const bytesArray = [];\n bytesArray.push(principal.prefix);\n if (principal.prefix === PostConditionPrincipalId.Standard \|\|\n principal.prefix === PostConditionPrincipalId.Contract) {\n bytesArray.push(serializeAddressBytes(principal.address));\n }\n if (principal.prefix === PostConditionPrincipalId.Contract) {\n bytesArray.push(serializeLPStringBytes(principal.contractName));\n }\n return concatArray(bytesArray);\n}\nexport function deserializePrincipal(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const prefix = bytesReader.readUInt8Enum(PostConditionPrincipalId, n => {\n throw new DeserializationError(`Unexpected Principal payload type: ${n}`);\n });\n if (prefix === PostConditionPrincipalId.Origin) {\n return { type: StacksWireType.Principal, prefix };\n }\n const address = deserializeAddress(bytesReader);\n if (prefix === PostConditionPrincipalId.Standard) {\n return { type: StacksWireType.Principal, prefix, address };\n }\n const contractName = deserializeLPString(bytesReader);\n return {\n type: StacksWireType.Principal,\n prefix,\n address,\n contractName,\n };\n}\nexport function serializeLPString(lps) {\n return bytesToHex(serializeLPStringBytes(lps));\n}\nexport function serializeLPStringBytes(lps) {\n const bytesArray = [];\n const contentBytes = utf8ToBytes(lps.content);\n const length = contentBytes.byteLength;\n bytesArray.push(hexToBytes(intToHex(length, lps.lengthPrefixBytes)));\n bytesArray.push(contentBytes);\n return concatArray(bytesArray);\n}\nexport function deserializeLPString(serialized, prefixBytes, maxLength) {\n prefixBytes = prefixBytes ? prefixBytes : 1;\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const length = hexToInt(bytesToHex(bytesReader.readBytes(prefixBytes)));\n const content = bytesToUtf8(bytesReader.readBytes(length));\n return createLPString(content, prefixBytes, maxLength ?? 128);\n}\nexport function serializeMemoString(memoString) {\n return bytesToHex(serializeMemoStringBytes(memoString));\n}\nexport function serializeMemoStringBytes(memoString) {\n const bytesArray = [];\n const contentBytes = utf8ToBytes(memoString.content);\n const paddedContent = rightPadHexToLength(bytesToHex(contentBytes), MEMO_MAX_LENGTH_BYTES 2);\n bytesArray.push(hexToBytes(paddedContent));\n return concatArray(bytesArray);\n}\nexport function deserializeMemoString(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n let content = bytesToUtf8(bytesReader.readBytes(MEMO_MAX_LENGTH_BYTES));\n content = content.replace(/\\u0000$/, '');\n return { type: StacksWireType.MemoString, content };\n}\nexport function serializeAsset(info) {\n return bytesToHex(serializeAssetBytes(info));\n}\nexport function serializeAssetBytes(info) {\n const bytesArray = [];\n bytesArray.push(serializeAddressBytes(info.address));\n bytesArray.push(serializeLPStringBytes(info.contractName));\n bytesArray.push(serializeLPStringBytes(info.assetName));\n return concatArray(bytesArray);\n}\nexport function deserializeAsset(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n return {\n type: StacksWireType.Asset,\n address: deserializeAddress(bytesReader),\n contractName: deserializeLPString(bytesReader),\n assetName: deserializeLPString(bytesReader),\n };\n}\nexport function serializeLPList(lpList) {\n return bytesToHex(serializeLPListBytes(lpList));\n}\nexport function serializeLPListBytes(lpList) {\n const list = lpList.values;\n const bytesArray = [];\n bytesArray.push(hexToBytes(intToHex(list.length, lpList.lengthPrefixBytes)));\n for (const l of list) {\n bytesArray.push(serializeStacksWireBytes(l));\n }\n return concatArray(bytesArray);\n}\nexport function deserializeLPList(serialized, type, lengthPrefixBytes) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const length = hexToInt(bytesToHex(bytesReader.readBytes(lengthPrefixBytes \|\| 4)));\n const l = [];\n for (let index = 0; index < length; index++) {\n switch (type) {\n case StacksWireType.Address:\n l.push(deserializeAddress(bytesReader));\n break;\n case StacksWireType.LengthPrefixedString:\n l.push(deserializeLPString(bytesReader));\n break;\n case StacksWireType.MemoString:\n l.push(deserializeMemoString(bytesReader));\n break;\n case StacksWireType.Asset:\n l.push(deserializeAsset(bytesReader));\n break;\n case StacksWireType.PostCondition:\n l.push(deserializePostConditionWire(bytesReader));\n break;\n case StacksWireType.PublicKey:\n l.push(deserializePublicKey(bytesReader));\n break;\n case StacksWireType.TransactionAuthField:\n l.push(deserializeTransactionAuthField(bytesReader));\n break;\n }\n }\n return createLPList(l, lengthPrefixBytes);\n}\nexport function serializePostConditionWire(postCondition) {\n return bytesToHex(serializePostConditionWireBytes(postCondition));\n}\nexport function serializePostConditionWireBytes(postCondition) {\n const bytesArray = [];\n bytesArray.push(postCondition.conditionType);\n bytesArray.push(serializePrincipalBytes(postCondition.principal));\n if (postCondition.conditionType === PostConditionType.Fungible \|\|\n postCondition.conditionType === PostConditionType.NonFungible) {\n bytesArray.push(serializeAssetBytes(postCondition.asset));\n }\n if (postCondition.conditionType === PostConditionType.NonFungible) {\n bytesArray.push(serializeCVBytes(postCondition.assetName));\n }\n bytesArray.push(postCondition.conditionCode);\n if (postCondition.conditionType === PostConditionType.STX \|\|\n postCondition.conditionType === PostConditionType.Fungible) {\n if (postCondition.amount > BigInt('0xffffffffffffffff'))\n throw new SerializationError('The post-condition amount may not be larger than 8 bytes');\n bytesArray.push(intToBytes(postCondition.amount, 8));\n }\n return concatArray(bytesArray);\n}\nexport function deserializePostConditionWire(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const postConditionType = bytesReader.readUInt8Enum(PostConditionType, n => {\n throw new DeserializationError(`Could not read ${n} as PostConditionType`);\n });\n const principal = deserializePrincipal(bytesReader);\n let conditionCode;\n let asset;\n let amount;\n switch (postConditionType) {\n case PostConditionType.STX:\n conditionCode = bytesReader.readUInt8Enum(FungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n amount = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.STX,\n principal,\n conditionCode,\n amount,\n };\n case PostConditionType.Fungible:\n asset = deserializeAsset(bytesReader);\n conditionCode = bytesReader.readUInt8Enum(FungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n amount = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.Fungible,\n principal,\n conditionCode,\n amount,\n asset: asset,\n };\n case PostConditionType.NonFungible:\n asset = deserializeAsset(bytesReader);\n const assetName = deserializeCV(bytesReader);\n conditionCode = bytesReader.readUInt8Enum(NonFungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.NonFungible,\n principal,\n conditionCode,\n asset,\n assetName,\n };\n }\n}\nexport function serializePayload(payload) {\n return bytesToHex(serializePayloadBytes(payload));\n}\nexport function serializePayloadBytes(payload) {\n const bytesArray = [];\n bytesArray.push(payload.payloadType);\n switch (payload.payloadType) {\n case PayloadType.TokenTransfer:\n bytesArray.push(serializeCVBytes(payload.recipient));\n bytesArray.push(intToBytes(payload.amount, 8));\n bytesArray.push(serializeStacksWireBytes(payload.memo));\n break;\n case PayloadType.ContractCall:\n bytesArray.push(serializeStacksWireBytes(payload.contractAddress));\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.functionName));\n const numArgs = new Uint8Array(4);\n writeUInt32BE(numArgs, payload.functionArgs.length, 0);\n bytesArray.push(numArgs);\n payload.functionArgs.forEach(arg => {\n bytesArray.push(serializeCVBytes(arg));\n });\n break;\n case PayloadType.SmartContract:\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.codeBody));\n break;\n case PayloadType.VersionedSmartContract:\n bytesArray.push(payload.clarityVersion);\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.codeBody));\n break;\n case PayloadType.PoisonMicroblock:\n break;\n case PayloadType.Coinbase:\n bytesArray.push(payload.coinbaseBytes);\n break;\n case PayloadType.CoinbaseToAltRecipient:\n bytesArray.push(payload.coinbaseBytes);\n bytesArray.push(serializeCVBytes(payload.recipient));\n break;\n case PayloadType.NakamotoCoinbase:\n bytesArray.push(payload.coinbaseBytes);\n bytesArray.push(serializeCVBytes(payload.recipient ? someCV(payload.recipient) : noneCV()));\n bytesArray.push(payload.vrfProof);\n break;\n case PayloadType.TenureChange:\n bytesArray.push(hexToBytes(payload.tenureHash));\n bytesArray.push(hexToBytes(payload.previousTenureHash));\n bytesArray.push(hexToBytes(payload.burnViewHash));\n bytesArray.push(hexToBytes(payload.previousTenureEnd));\n bytesArray.push(writeUInt32BE(new Uint8Array(4), payload.previousTenureBlocks));\n bytesArray.push(writeUInt8(new Uint8Array(1), payload.cause));\n bytesArray.push(hexToBytes(payload.publicKeyHash));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function deserializePayload(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const payloadType = bytesReader.readUInt8Enum(PayloadType, n => {\n throw new Error(`Cannot recognize PayloadType: ${n}`);\n });\n switch (payloadType) {\n case PayloadType.TokenTransfer:\n const recipient = deserializeCV(bytesReader);\n const amount = intToBigInt(bytesReader.readBytes(8));\n const memo = deserializeMemoString(bytesReader);\n return createTokenTransferPayload(recipient, amount, memo);\n case PayloadType.ContractCall:\n const contractAddress = deserializeAddress(bytesReader);\n const contractCallName = deserializeLPString(bytesReader);\n const functionName = deserializeLPString(bytesReader);\n const functionArgs = [];\n const numberOfArgs = bytesReader.readUInt32BE();\n for (let i = 0; i < numberOfArgs; i++) {\n const clarityValue = deserializeCV(bytesReader);\n functionArgs.push(clarityValue);\n }\n return createContractCallPayload(contractAddress, contractCallName, functionName, functionArgs);\n case PayloadType.SmartContract:\n const smartContractName = deserializeLPString(bytesReader);\n const codeBody = deserializeLPString(bytesReader, 4, 100000);\n return createSmartContractPayload(smartContractName, codeBody);\n case PayloadType.VersionedSmartContract: {\n const clarityVersion = bytesReader.readUInt8Enum(ClarityVersion, n => {\n throw new Error(`Cannot recognize ClarityVersion: ${n}`);\n });\n const smartContractName = deserializeLPString(bytesReader);\n const codeBody = deserializeLPString(bytesReader, 4, STRING_MAX_LENGTH);\n return createSmartContractPayload(smartContractName, codeBody, clarityVersion);\n }\n case PayloadType.PoisonMicroblock:\n return createPoisonPayload();\n case PayloadType.Coinbase: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n return createCoinbasePayload(coinbaseBytes);\n }\n case PayloadType.CoinbaseToAltRecipient: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n const altRecipient = deserializeCV(bytesReader);\n return createCoinbasePayload(coinbaseBytes, altRecipient);\n }\n case PayloadType.NakamotoCoinbase: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n const recipient = deserializeCV(bytesReader);\n const vrfProof = bytesReader.readBytes(VRF_PROOF_BYTES_LENGTH);\n return createNakamotoCoinbasePayload(coinbaseBytes, recipient, vrfProof);\n }\n case PayloadType.TenureChange:\n const tenureHash = bytesToHex(bytesReader.readBytes(20));\n const previousTenureHash = bytesToHex(bytesReader.readBytes(20));\n const burnViewHash = bytesToHex(bytesReader.readBytes(20));\n const previousTenureEnd = bytesToHex(bytesReader.readBytes(32));\n const previousTenureBlocks = bytesReader.readUInt32BE();\n const cause = bytesReader.readUInt8Enum(TenureChangeCause, n => {\n throw new Error(`Cannot recognize TenureChangeCause: ${n}`);\n });\n const publicKeyHash = bytesToHex(bytesReader.readBytes(20));\n return createTenureChangePayload(tenureHash, previousTenureHash, burnViewHash, previousTenureEnd, previousTenureBlocks, cause, publicKeyHash);\n }\n}\nexport function deserializeMessageSignature(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n return createMessageSignature(bytesToHex(bytesReader.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES)));\n}\nexport function deserializeTransactionAuthField(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const authFieldType = bytesReader.readUInt8Enum(AuthFieldType, n => {\n throw new DeserializationError(`Could not read ${n} as AuthFieldType`);\n });\n switch (authFieldType) {\n case AuthFieldType.PublicKeyCompressed:\n return createTransactionAuthField(PubKeyEncoding.Compressed, deserializePublicKey(bytesReader));\n case AuthFieldType.PublicKeyUncompressed:\n return createTransactionAuthField(PubKeyEncoding.Uncompressed, createStacksPublicKey(uncompressPublicKey(deserializePublicKey(bytesReader).data)));\n case AuthFieldType.SignatureCompressed:\n return createTransactionAuthField(PubKeyEncoding.Compressed, deserializeMessageSignature(bytesReader));\n case AuthFieldType.SignatureUncompressed:\n return createTransactionAuthField(PubKeyEncoding.Uncompressed, deserializeMessageSignature(bytesReader));\n default:\n throw new Error(`Unknown auth field type: ${JSON.stringify(authFieldType)}`);\n }\n}\nexport function serializeMessageSignature(messageSignature) {\n return bytesToHex(serializeMessageSignatureBytes(messageSignature));\n}\nexport function serializeMessageSignatureBytes(messageSignature) {\n return hexToBytes(messageSignature.data);\n}\nexport function serializeTransactionAuthField(field) {\n return bytesToHex(serializeTransactionAuthFieldBytes(field));\n}\nexport function serializeTransactionAuthFieldBytes(field) {\n const bytesArray = [];\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n bytesArray.push(field.pubKeyEncoding === PubKeyEncoding.Compressed\n ? AuthFieldType.PublicKeyCompressed\n : AuthFieldType.PublicKeyUncompressed);\n bytesArray.push(hexToBytes(compressPublicKey(field.contents.data)));\n break;\n case StacksWireType.MessageSignature:\n bytesArray.push(field.pubKeyEncoding === PubKeyEncoding.Compressed\n ? AuthFieldType.SignatureCompressed\n : AuthFieldType.SignatureUncompressed);\n bytesArray.push(serializeMessageSignatureBytes(field.contents));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function serializePublicKey(key) {\n return bytesToHex(serializePublicKeyBytes(key));\n}\nexport function serializePublicKeyBytes(key) {\n return key.data.slice();\n}\nexport function deserializePublicKey(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const fieldId = bytesReader.readUInt8();\n const keyLength = fieldId === 4 ? UNCOMPRESSED_PUBKEY_LENGTH_BYTES : COMPRESSED_PUBKEY_LENGTH_BYTES;\n return createStacksPublicKey(concatArray([fieldId, bytesReader.readBytes(keyLength)]));\n}\n//# sourceMappingURL=serialization.js.map","import { bytesToHex, concatArray, hexToBytes, intToBigInt, intToBytes, writeUInt16BE, } from '@stacks/common';\nimport { AddressHashMode, AuthType, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, } from './constants';\nimport { DeserializationError, SigningError, VerificationError } from './errors';\nimport { createStacksPublicKey, privateKeyToPublic, publicKeyFromSignatureVrs, publicKeyIsCompressed, signWithKey, } from './keys';\nimport { cloneDeep, leftPadHex, txidFromData } from './utils';\nimport { addressFromPublicKeys, createEmptyAddress, createLPList, deserializeLPList, deserializeMessageSignature, serializeLPListBytes, serializeMessageSignatureBytes, StacksWireType, } from './wire';\nexport function emptyMessageSignature() {\n return {\n type: StacksWireType.MessageSignature,\n data: bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES)),\n };\n}\nexport function createSpendingCondition(options) {\n if ('publicKey' in options) {\n return createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n return createMultiSigSpendingCondition(AddressHashMode.P2SH, options.numSignatures, options.publicKeys, options.nonce, options.fee);\n}\nexport function createSingleSigSpendingCondition(hashMode, pubKey, nonce, fee) {\n const signer = addressFromPublicKeys(0, hashMode, 1, [createStacksPublicKey(pubKey)]).hash160;\n const keyEncoding = publicKeyIsCompressed(pubKey)\n ? PubKeyEncoding.Compressed\n : PubKeyEncoding.Uncompressed;\n return {\n hashMode,\n signer,\n nonce: intToBigInt(nonce),\n fee: intToBigInt(fee),\n keyEncoding,\n signature: emptyMessageSignature(),\n };\n}\nexport function createMultiSigSpendingCondition(hashMode, numSigs, pubKeys, nonce, fee) {\n const stacksPublicKeys = pubKeys.map(createStacksPublicKey);\n const signer = addressFromPublicKeys(0, hashMode, numSigs, stacksPublicKeys).hash160;\n return {\n hashMode,\n signer,\n nonce: intToBigInt(nonce),\n fee: intToBigInt(fee),\n fields: [],\n signaturesRequired: numSigs,\n };\n}\nexport function isSingleSig(condition) {\n return 'signature' in condition;\n}\nexport function isSequentialMultiSig(hashMode) {\n return hashMode === AddressHashMode.P2SH \|\| hashMode === AddressHashMode.P2WSH;\n}\nexport function isNonSequentialMultiSig(hashMode) {\n return (hashMode === AddressHashMode.P2SHNonSequential \|\|\n hashMode === AddressHashMode.P2WSHNonSequential);\n}\nfunction clearCondition(condition) {\n const cloned = cloneDeep(condition);\n cloned.nonce = 0;\n cloned.fee = 0;\n if (isSingleSig(cloned)) {\n cloned.signature = emptyMessageSignature();\n }\n else {\n cloned.fields = [];\n }\n return {\n ...cloned,\n nonce: BigInt(0),\n fee: BigInt(0),\n };\n}\nexport function serializeSingleSigSpendingCondition(condition) {\n return bytesToHex(serializeSingleSigSpendingConditionBytes(condition));\n}\nexport function serializeSingleSigSpendingConditionBytes(condition) {\n const bytesArray = [\n condition.hashMode,\n hexToBytes(condition.signer),\n intToBytes(condition.nonce, 8),\n intToBytes(condition.fee, 8),\n condition.keyEncoding,\n serializeMessageSignatureBytes(condition.signature),\n ];\n return concatArray(bytesArray);\n}\nexport function serializeMultiSigSpendingCondition(condition) {\n return bytesToHex(serializeMultiSigSpendingConditionBytes(condition));\n}\nexport function serializeMultiSigSpendingConditionBytes(condition) {\n const bytesArray = [\n condition.hashMode,\n hexToBytes(condition.signer),\n intToBytes(condition.nonce, 8),\n intToBytes(condition.fee, 8),\n ];\n const fields = createLPList(condition.fields);\n bytesArray.push(serializeLPListBytes(fields));\n const numSigs = new Uint8Array(2);\n writeUInt16BE(numSigs, condition.signaturesRequired, 0);\n bytesArray.push(numSigs);\n return concatArray(bytesArray);\n}\nexport function deserializeSingleSigSpendingCondition(hashMode, bytesReader) {\n const signer = bytesToHex(bytesReader.readBytes(20));\n const nonce = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n const fee = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n const keyEncoding = bytesReader.readUInt8Enum(PubKeyEncoding, n => {\n throw new DeserializationError(`Could not parse ${n} as PubKeyEncoding`);\n });\n if (hashMode === AddressHashMode.P2WPKH && keyEncoding != PubKeyEncoding.Compressed) {\n throw new DeserializationError('Failed to parse singlesig spending condition: incomaptible hash mode and key encoding');\n }\n const signature = deserializeMessageSignature(bytesReader);\n return {\n hashMode,\n signer,\n nonce,\n fee,\n keyEncoding,\n signature,\n };\n}\nexport function deserializeMultiSigSpendingCondition(hashMode, bytesReader) {\n const signer = bytesToHex(bytesReader.readBytes(20));\n const nonce = BigInt('0x' + bytesToHex(bytesReader.readBytes(8)));\n const fee = BigInt('0x' + bytesToHex(bytesReader.readBytes(8)));\n const fields = deserializeLPList(bytesReader, StacksWireType.TransactionAuthField)\n .values;\n let haveUncompressed = false;\n let numSigs = 0;\n for (const field of fields) {\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n if (!publicKeyIsCompressed(field.contents.data))\n haveUncompressed = true;\n break;\n case StacksWireType.MessageSignature:\n if (field.pubKeyEncoding === PubKeyEncoding.Uncompressed)\n haveUncompressed = true;\n numSigs += 1;\n if (numSigs === 65536)\n throw new VerificationError('Failed to parse multisig spending condition: too many signatures');\n break;\n }\n }\n const signaturesRequired = bytesReader.readUInt16BE();\n if (haveUncompressed &&\n (hashMode === AddressHashMode.P2WSH \|\| hashMode === AddressHashMode.P2WSHNonSequential)) {\n throw new VerificationError('Uncompressed keys are not allowed in this hash mode');\n }\n return {\n hashMode,\n signer,\n nonce,\n fee,\n fields,\n signaturesRequired,\n };\n}\nexport function serializeSpendingCondition(condition) {\n return bytesToHex(serializeSpendingConditionBytes(condition));\n}\nexport function serializeSpendingConditionBytes(condition) {\n if (isSingleSig(condition))\n return serializeSingleSigSpendingConditionBytes(condition);\n return serializeMultiSigSpendingConditionBytes(condition);\n}\nexport function deserializeSpendingCondition(bytesReader) {\n const hashMode = bytesReader.readUInt8Enum(AddressHashMode, n => {\n throw new DeserializationError(`Could not parse ${n} as AddressHashMode`);\n });\n if (hashMode === AddressHashMode.P2PKH \|\| hashMode === AddressHashMode.P2WPKH) {\n return deserializeSingleSigSpendingCondition(hashMode, bytesReader);\n }\n else {\n return deserializeMultiSigSpendingCondition(hashMode, bytesReader);\n }\n}\nexport function sigHashPreSign(curSigHash, authType, fee, nonce) {\n const hashLength = 32 + 1 + 8 + 8;\n const sigHash = curSigHash +\n bytesToHex(new Uint8Array([authType])) +\n bytesToHex(intToBytes(fee, 8)) +\n bytesToHex(intToBytes(nonce, 8));\n if (hexToBytes(sigHash).byteLength !== hashLength) {\n throw Error('Invalid signature hash length');\n }\n return txidFromData(hexToBytes(sigHash));\n}\nfunction sigHashPostSign(curSigHash, pubKey, signature) {\n const hashLength = 32 + 1 + RECOVERABLE_ECDSA_SIG_LENGTH_BYTES;\n const pubKeyEncoding = publicKeyIsCompressed(pubKey.data)\n ? PubKeyEncoding.Compressed\n : PubKeyEncoding.Uncompressed;\n const sigHash = curSigHash + leftPadHex(pubKeyEncoding.toString(16)) + signature;\n const sigHashBytes = hexToBytes(sigHash);\n if (sigHashBytes.byteLength > hashLength) {\n throw Error('Invalid signature hash length');\n }\n return txidFromData(sigHashBytes);\n}\nexport function nextSignature(curSigHash, authType, fee, nonce, privateKey) {\n const sigHashPre = sigHashPreSign(curSigHash, authType, fee, nonce);\n const signature = signWithKey(privateKey, sigHashPre);\n const publicKey = createStacksPublicKey(privateKeyToPublic(privateKey));\n const nextSigHash = sigHashPostSign(sigHashPre, publicKey, signature);\n return {\n nextSig: signature,\n nextSigHash,\n };\n}\nexport function nextVerification(initialSigHash, authType, fee, nonce, pubKeyEncoding, signature) {\n const sigHashPre = sigHashPreSign(initialSigHash, authType, fee, nonce);\n const publicKey = createStacksPublicKey(publicKeyFromSignatureVrs(sigHashPre, signature, pubKeyEncoding));\n const nextSigHash = sigHashPostSign(sigHashPre, publicKey, signature);\n return {\n pubKey: publicKey,\n nextSigHash,\n };\n}\nfunction newInitialSigHash() {\n const spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, '', 0, 0);\n spendingCondition.signer = createEmptyAddress().hash160;\n spendingCondition.keyEncoding = PubKeyEncoding.Compressed;\n spendingCondition.signature = emptyMessageSignature();\n return spendingCondition;\n}\nfunction verify(condition, initialSigHash, authType) {\n if (isSingleSig(condition)) {\n return verifySingleSig(condition, initialSigHash, authType);\n }\n else {\n return verifyMultiSig(condition, initialSigHash, authType);\n }\n}\nfunction verifySingleSig(condition, initialSigHash, authType) {\n const { pubKey, nextSigHash } = nextVerification(initialSigHash, authType, condition.fee, condition.nonce, condition.keyEncoding, condition.signature.data);\n const addrBytes = addressFromPublicKeys(0, condition.hashMode, 1, [pubKey]).hash160;\n if (addrBytes !== condition.signer)\n throw new VerificationError(`Signer hash does not equal hash of public key(s): ${addrBytes} != ${condition.signer}`);\n return nextSigHash;\n}\nfunction verifyMultiSig(condition, initialSigHash, authType) {\n const publicKeys = [];\n let curSigHash = initialSigHash;\n let haveUncompressed = false;\n let numSigs = 0;\n for (const field of condition.fields) {\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n if (!publicKeyIsCompressed(field.contents.data))\n haveUncompressed = true;\n publicKeys.push(field.contents);\n break;\n case StacksWireType.MessageSignature:\n if (field.pubKeyEncoding === PubKeyEncoding.Uncompressed)\n haveUncompressed = true;\n const { pubKey, nextSigHash } = nextVerification(curSigHash, authType, condition.fee, condition.nonce, field.pubKeyEncoding, field.contents.data);\n if (isSequentialMultiSig(condition.hashMode)) {\n curSigHash = nextSigHash;\n }\n publicKeys.push(pubKey);\n numSigs += 1;\n if (numSigs === 65536)\n throw new VerificationError('Too many signatures');\n break;\n }\n }\n if ((isSequentialMultiSig(condition.hashMode) && numSigs !== condition.signaturesRequired) \|\|\n (isNonSequentialMultiSig(condition.hashMode) && numSigs < condition.signaturesRequired))\n throw new VerificationError('Incorrect number of signatures');\n if (haveUncompressed &&\n (condition.hashMode === AddressHashMode.P2WSH \|\|\n condition.hashMode === AddressHashMode.P2WSHNonSequential))\n throw new VerificationError('Uncompressed keys are not allowed in this hash mode');\n const addrBytes = addressFromPublicKeys(0, condition.hashMode, condition.signaturesRequired, publicKeys).hash160;\n if (addrBytes !== condition.signer)\n throw new VerificationError(`Signer hash does not equal hash of public key(s): ${addrBytes} != ${condition.signer}`);\n return curSigHash;\n}\nexport function createStandardAuth(spendingCondition) {\n return {\n authType: AuthType.Standard,\n spendingCondition,\n };\n}\nexport function createSponsoredAuth(spendingCondition, sponsorSpendingCondition) {\n return {\n authType: AuthType.Sponsored,\n spendingCondition,\n sponsorSpendingCondition: sponsorSpendingCondition\n ? sponsorSpendingCondition\n : createSingleSigSpendingCondition(AddressHashMode.P2PKH, '0'.repeat(66), 0, 0),\n };\n}\nexport function intoInitialSighashAuth(auth) {\n if (auth.spendingCondition) {\n switch (auth.authType) {\n case AuthType.Standard:\n return createStandardAuth(clearCondition(auth.spendingCondition));\n case AuthType.Sponsored:\n return createSponsoredAuth(clearCondition(auth.spendingCondition), newInitialSigHash());\n default:\n throw new SigningError('Unexpected authorization type for signing');\n }\n }\n throw new Error('Authorization missing SpendingCondition');\n}\nexport function verifyOrigin(auth, initialSigHash) {\n switch (auth.authType) {\n case AuthType.Standard:\n return verify(auth.spendingCondition, initialSigHash, AuthType.Standard);\n case AuthType.Sponsored:\n return verify(auth.spendingCondition, initialSigHash, AuthType.Standard);\n default:\n throw new SigningError('Invalid origin auth type');\n }\n}\nexport function setFee(auth, amount) {\n switch (auth.authType) {\n case AuthType.Standard:\n const spendingCondition = {\n ...auth.spendingCondition,\n fee: intToBigInt(amount),\n };\n return { ...auth, spendingCondition };\n case AuthType.Sponsored:\n const sponsorSpendingCondition = {\n ...auth.sponsorSpendingCondition,\n fee: intToBigInt(amount),\n };\n return { ...auth, sponsorSpendingCondition };\n }\n}\nexport function getFee(auth) {\n switch (auth.authType) {\n case AuthType.Standard:\n return auth.spendingCondition.fee;\n case AuthType.Sponsored:\n return auth.sponsorSpendingCondition.fee;\n }\n}\nexport function setNonce(auth, nonce) {\n const spendingCondition = {\n ...auth.spendingCondition,\n nonce: intToBigInt(nonce),\n };\n return {\n ...auth,\n spendingCondition,\n };\n}\nexport function setSponsorNonce(auth, nonce) {\n const sponsorSpendingCondition = {\n ...auth.sponsorSpendingCondition,\n nonce: intToBigInt(nonce),\n };\n return {\n ...auth,\n sponsorSpendingCondition,\n };\n}\nexport function setSponsor(auth, sponsorSpendingCondition) {\n const sc = {\n ...sponsorSpendingCondition,\n nonce: intToBigInt(sponsorSpendingCondition.nonce),\n fee: intToBigInt(sponsorSpendingCondition.fee),\n };\n return {\n ...auth,\n sponsorSpendingCondition: sc,\n };\n}\nexport function serializeAuthorization(auth) {\n return bytesToHex(serializeAuthorizationBytes(auth));\n}\nexport function serializeAuthorizationBytes(auth) {\n const bytesArray = [];\n bytesArray.push(auth.authType);\n switch (auth.authType) {\n case AuthType.Standard:\n bytesArray.push(serializeSpendingConditionBytes(auth.spendingCondition));\n break;\n case AuthType.Sponsored:\n bytesArray.push(serializeSpendingConditionBytes(auth.spendingCondition));\n bytesArray.push(serializeSpendingConditionBytes(auth.sponsorSpendingCondition));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function deserializeAuthorization(bytesReader) {\n const authType = bytesReader.readUInt8Enum(AuthType, n => {\n throw new DeserializationError(`Could not parse ${n} as AuthType`);\n });\n let spendingCondition;\n switch (authType) {\n case AuthType.Standard:\n spendingCondition = deserializeSpendingCondition(bytesReader);\n return createStandardAuth(spendingCondition);\n case AuthType.Sponsored:\n spendingCondition = deserializeSpendingCondition(bytesReader);\n const sponsorSpendingCondition = deserializeSpendingCondition(bytesReader);\n return createSponsoredAuth(spendingCondition, sponsorSpendingCondition);\n }\n}\n//# sourceMappingURL=authorization.js.map","import { bytesToHex, concatArray, intToBigInt, isInstance, writeUInt32BE, } from '@stacks/common';\nimport { STACKS_MAINNET, STACKS_TESTNET, TransactionVersion, networkFrom, whenTransactionVersion, } from '@stacks/network';\nimport { serializePayloadBytes } from '.';\nimport { BytesReader } from './BytesReader';\nimport { deserializeAuthorization, intoInitialSighashAuth, isSingleSig, nextSignature, serializeAuthorizationBytes, setFee, setNonce, setSponsor, setSponsorNonce, verifyOrigin, } from './authorization';\nimport { AddressHashMode, AnchorMode, AuthType, PostConditionMode, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, } from './constants';\nimport { SerializationError, SigningError } from './errors';\nimport { createStacksPublicKey, privateKeyIsCompressed, publicKeyIsCompressed } from './keys';\nimport { cloneDeep, txidFromData } from './utils';\nimport { StacksWireType, createLPList, createMessageSignature, createTransactionAuthField, deserializeLPList, deserializePayload, serializeLPListBytes, } from './wire';\nexport class StacksTransactionWire {\n constructor({ auth, payload, postConditions = createLPList([]), postConditionMode = PostConditionMode.Deny, transactionVersion, chainId, network = 'mainnet', }) {\n network = networkFrom(network);\n this.transactionVersion = transactionVersion ?? network.transactionVersion;\n this.chainId = chainId ?? network.chainId;\n this.auth = auth;\n if ('amount' in payload) {\n this.payload = {\n ...payload,\n amount: intToBigInt(payload.amount),\n };\n }\n else {\n this.payload = payload;\n }\n this.postConditionMode = postConditionMode;\n this.postConditions = postConditions;\n this.anchorMode = AnchorMode.Any;\n }\n signBegin() {\n const tx = cloneDeep(this);\n tx.auth = intoInitialSighashAuth(tx.auth);\n return tx.txid();\n }\n verifyBegin() {\n const tx = cloneDeep(this);\n tx.auth = intoInitialSighashAuth(tx.auth);\n return tx.txid();\n }\n verifyOrigin() {\n return verifyOrigin(this.auth, this.verifyBegin());\n }\n signNextOrigin(sigHash, privateKey) {\n if (this.auth.spendingCondition === undefined) {\n throw new Error('\"auth.spendingCondition\" is undefined');\n }\n if (this.auth.authType === undefined) {\n throw new Error('\"auth.authType\" is undefined');\n }\n return this.signAndAppend(this.auth.spendingCondition, sigHash, AuthType.Standard, privateKey);\n }\n signNextSponsor(sigHash, privateKey) {\n if (this.auth.authType === AuthType.Sponsored) {\n return this.signAndAppend(this.auth.sponsorSpendingCondition, sigHash, AuthType.Sponsored, privateKey);\n }\n else {\n throw new Error('\"auth.sponsorSpendingCondition\" is undefined');\n }\n }\n appendPubkey(publicKey) {\n const wire = typeof publicKey === 'object' && 'type' in publicKey\n ? publicKey\n : createStacksPublicKey(publicKey);\n const cond = this.auth.spendingCondition;\n if (cond && !isSingleSig(cond)) {\n const compressed = publicKeyIsCompressed(wire.data);\n cond.fields.push(createTransactionAuthField(compressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed, wire));\n }\n else {\n throw new Error(`Can't append public key to a singlesig condition`);\n }\n }\n signAndAppend(condition, curSigHash, authType, privateKey) {\n const { nextSig, nextSigHash } = nextSignature(curSigHash, authType, condition.fee, condition.nonce, privateKey);\n if (isSingleSig(condition)) {\n condition.signature = createMessageSignature(nextSig);\n }\n else {\n const compressed = privateKeyIsCompressed(privateKey);\n condition.fields.push(createTransactionAuthField(compressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed, createMessageSignature(nextSig)));\n }\n return nextSigHash;\n }\n txid() {\n const serialized = this.serializeBytes();\n return txidFromData(serialized);\n }\n setSponsor(sponsorSpendingCondition) {\n if (this.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot sponsor sign a non-sponsored transaction');\n }\n this.auth = setSponsor(this.auth, sponsorSpendingCondition);\n }\n setFee(amount) {\n this.auth = setFee(this.auth, amount);\n }\n setNonce(nonce) {\n this.auth = setNonce(this.auth, nonce);\n }\n setSponsorNonce(nonce) {\n if (this.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot sponsor sign a non-sponsored transaction');\n }\n this.auth = setSponsorNonce(this.auth, nonce);\n }\n serialize() {\n return bytesToHex(this.serializeBytes());\n }\n serializeBytes() {\n if (this.transactionVersion === undefined) {\n throw new SerializationError('\"transactionVersion\" is undefined');\n }\n if (this.chainId === undefined) {\n throw new SerializationError('\"chainId\" is undefined');\n }\n if (this.auth === undefined) {\n throw new SerializationError('\"auth\" is undefined');\n }\n if (this.payload === undefined) {\n throw new SerializationError('\"payload\" is undefined');\n }\n const bytesArray = [];\n bytesArray.push(this.transactionVersion);\n const chainIdBytes = new Uint8Array(4);\n writeUInt32BE(chainIdBytes, this.chainId, 0);\n bytesArray.push(chainIdBytes);\n bytesArray.push(serializeAuthorizationBytes(this.auth));\n bytesArray.push(this.anchorMode);\n bytesArray.push(this.postConditionMode);\n bytesArray.push(serializeLPListBytes(this.postConditions));\n bytesArray.push(serializePayloadBytes(this.payload));\n return concatArray(bytesArray);\n }\n}\nexport function deserializeTransaction(tx) {\n const bytesReader = isInstance(tx, BytesReader) ? tx : new BytesReader(tx);\n const transactionVersion = bytesReader.readUInt8Enum(TransactionVersion, n => {\n throw new Error(`Could not parse ${n} as TransactionVersion`);\n });\n const chainId = bytesReader.readUInt32BE();\n const auth = deserializeAuthorization(bytesReader);\n const anchorMode = bytesReader.readUInt8Enum(AnchorMode, n => {\n throw new Error(`Could not parse ${n} as AnchorMode`);\n });\n const postConditionMode = bytesReader.readUInt8Enum(PostConditionMode, n => {\n throw new Error(`Could not parse ${n} as PostConditionMode`);\n });\n const postConditions = deserializeLPList(bytesReader, StacksWireType.PostCondition);\n const payload = deserializePayload(bytesReader);\n const transaction = new StacksTransactionWire({\n transactionVersion,\n chainId,\n auth,\n payload,\n postConditions,\n postConditionMode,\n });\n transaction.anchorMode = anchorMode;\n return transaction;\n}\nexport function deriveNetworkFromTx(transaction) {\n return whenTransactionVersion(transaction.transactionVersion)({\n [TransactionVersion.Mainnet]: STACKS_MAINNET,\n [TransactionVersion.Testnet]: STACKS_TESTNET,\n });\n}\nexport function estimateTransactionByteLength(transaction) {\n const hashMode = transaction.auth.spendingCondition.hashMode;\n const multiSigHashModes = [AddressHashMode.P2SH, AddressHashMode.P2WSH];\n if (multiSigHashModes.includes(hashMode)) {\n const multiSigSpendingCondition = transaction.auth\n .spendingCondition;\n const existingSignatures = multiSigSpendingCondition.fields.filter(field => field.contents.type === StacksWireType.MessageSignature).length;\n const totalSignatureLength = (multiSigSpendingCondition.signaturesRequired - existingSignatures) \n (RECOVERABLE_ECDSA_SIG_LENGTH_BYTES + 1);\n return transaction.serializeBytes().byteLength + totalSignatureLength;\n }\n else {\n return transaction.serializeBytes().byteLength;\n }\n}\nexport function serializeTransaction(transaction) {\n return transaction.serialize();\n}\nexport function serializeTransactionBytes(transaction) {\n return transaction.serializeBytes();\n}\nexport function transactionToHex(transaction) {\n return transaction.serialize();\n}\n//# sourceMappingURL=transaction.js.map","import { bytesToHex, validateHash256, with0x } from '@stacks/common';\nimport { clientFromNetwork, networkFrom } from '@stacks/network';\nimport { deserializeCV, serializeCV } from './clarity';\nimport { NoEstimateAvailableError } from './errors';\nimport { deriveNetworkFromTx, estimateTransactionByteLength, } from './transaction';\nimport { cvToHex, parseReadOnlyResponse } from './utils';\nimport { serializePayloadBytes } from './wire';\nexport const BROADCAST_PATH = '/v2/transactions';\nexport const TRANSFER_FEE_ESTIMATE_PATH = '/v2/fees/transfer';\nexport const TRANSACTION_FEE_ESTIMATE_PATH = '/v2/fees/transaction';\nexport const ACCOUNT_PATH = '/v2/accounts';\nexport const CONTRACT_ABI_PATH = '/v2/contracts/interface';\nexport const READONLY_FUNCTION_CALL_PATH = '/v2/contracts/call-read';\nexport const MAP_ENTRY_PATH = '/v2/map_entry';\nexport async function broadcastTransaction({ transaction: txOpt, attachment: attachOpt, network: _network, client: _client, }) {\n const tx = txOpt.serialize();\n const attachment = attachOpt\n ? typeof attachOpt === 'string'\n ? attachOpt\n : bytesToHex(attachOpt)\n : undefined;\n const json = attachOpt ? { tx, attachment } : { tx };\n const options = {\n method: 'POST',\n headers: { 'Content-Type': 'application/json' },\n body: JSON.stringify(json),\n };\n const network = _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${BROADCAST_PATH}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n try {\n return (await response.json());\n }\n catch (e) {\n throw Error('Failed to broadcast transaction (unable to parse node response).', { cause: e });\n }\n }\n const text = await response.text();\n const txid = text.replace(/[\"]+/g, '');\n if (!validateHash256(txid))\n throw new Error(text);\n return { txid };\n}\nasync function _getNonceApi({ address, network = 'mainnet', client: _client, }) {\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}/extended/v1/address/${address}/nonces`;\n const response = await client.fetch(url);\n const result = await response.json();\n return BigInt(result.possible_next_nonce);\n}\nexport async function fetchNonce(opts) {\n try {\n return await _getNonceApi(opts);\n }\n catch (e) { }\n const network = networkFrom(opts.network ?? 'mainnet');\n const client = Object.assign({}, clientFromNetwork(network), opts.client);\n const url = `${client.baseUrl}${ACCOUNT_PATH}/${opts.address}?proof=0`;\n const response = await client.fetch(url);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching nonce. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const json = (await response.json());\n return BigInt(json.nonce);\n}\nexport async function fetchFeeEstimateTransfer({ transaction: txOpt, network: _network, client: _client, }) {\n const network = typeof txOpt === 'number' ? 'mainnet' : (_network ?? deriveNetworkFromTx(txOpt));\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${TRANSFER_FEE_ESTIMATE_PATH}`;\n const response = await client.fetch(url, {\n headers: { Accept: 'application/text' },\n });\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error estimating transfer fee. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const feeRateResult = await response.text();\n const txBytes = typeof txOpt === 'number'\n ? BigInt(txOpt)\n : BigInt(Math.ceil(txOpt.serializeBytes().byteLength));\n const feeRate = BigInt(feeRateResult);\n return feeRate * txBytes;\n}\nexport async function fetchFeeEstimateTransaction({ payload, estimatedLength, network = 'mainnet', client: _client, }) {\n const json = {\n transaction_payload: payload,\n estimated_len: estimatedLength,\n };\n const options = {\n method: 'POST',\n headers: { 'Content-Type': 'application/json' },\n body: JSON.stringify(json),\n };\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${TRANSACTION_FEE_ESTIMATE_PATH}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const body = await response.text().catch(() => '');\n if (body.includes('NoEstimateAvailable')) {\n let json = {};\n try {\n json = JSON.parse(body);\n }\n catch (err) {\n }\n throw new NoEstimateAvailableError(json?.reason_data?.message ?? '');\n }\n throw new Error(`Error estimating transaction fee. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${body}\"`);\n }\n const data = await response.json();\n return data.estimations;\n}\nexport async function fetchFeeEstimate({ transaction: txOpt, network: _network, client: _client, }) {\n const network = _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n try {\n const estimatedLength = estimateTransactionByteLength(txOpt);\n return (await fetchFeeEstimateTransaction({\n payload: bytesToHex(serializePayloadBytes(txOpt.payload)),\n estimatedLength,\n network,\n client,\n }))[1].fee;\n }\n catch (error) {\n if (!(error instanceof NoEstimateAvailableError))\n throw error;\n return await fetchFeeEstimateTransfer({ transaction: txOpt, network });\n }\n}\nexport async function fetchAbi({ contractAddress: address, contractName: name, network = 'mainnet', client: _client, }) {\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${CONTRACT_ABI_PATH}/${address}/${name}`;\n const response = await client.fetch(url);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching contract ABI for contract \"${name}\" at address ${address}. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n return JSON.parse(await response.text());\n}\nexport async function fetchCallReadOnlyFunction({ contractName, contractAddress, functionName, functionArgs, senderAddress, network = 'mainnet', client: _client, }) {\n const json = {\n sender: senderAddress,\n arguments: functionArgs.map(arg => cvToHex(arg)),\n };\n const options = {\n method: 'POST',\n headers: {\n 'Content-Type': 'application/json',\n },\n body: JSON.stringify(json),\n };\n const name = encodeURIComponent(functionName);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${READONLY_FUNCTION_CALL_PATH}/${contractAddress}/${contractName}/${name}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error calling read-only function. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n return await response.json().then(parseReadOnlyResponse);\n}\nexport async function fetchContractMapEntry({ contractAddress, contractName, mapName, mapKey, network = 'mainnet', client: _client, }) {\n const keyHex = with0x(serializeCV(mapKey));\n const options = {\n method: 'POST',\n headers: {\n Accept: 'application/json',\n 'Content-Type': 'application/json',\n },\n body: JSON.stringify(keyHex),\n };\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${MAP_ENTRY_PATH}/${contractAddress}/${contractName}/${mapName}?proof=0`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching map entry for map \"${mapName}\" in contract \"${contractName}\" at address ${contractAddress}, using map key \"${keyHex}\". Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const json = await response.json();\n if (!json.data) {\n throw new Error(`Error fetching map entry for map \"${mapName}\" in contract \"${contractName}\" at address ${contractAddress}, using map key \"${keyHex}\". Response ${response.status}: ${response.statusText}. Attempted to fetch ${client.baseUrl} and failed with the response: \"${JSON.stringify(json)}\"`);\n }\n try {\n return deserializeCV(json.data);\n }\n catch (error) {\n throw new Error(`Error deserializing Clarity value \"${json.data}\": ${error}`);\n }\n}\n//# sourceMappingURL=fetch.js.map","import { ClarityType } from './constants';\nimport { asciiToBytes, bytesToAscii, hexToBytes, utf8ToBytes } from '@stacks/common';\nexport function cvToString(val, encoding = 'hex') {\n switch (val.type) {\n case ClarityType.BoolTrue:\n return 'true';\n case ClarityType.BoolFalse:\n return 'false';\n case ClarityType.Int:\n return val.value.toString();\n case ClarityType.UInt:\n return `u${val.value.toString()}`;\n case ClarityType.Buffer:\n if (encoding === 'tryAscii') {\n const str = bytesToAscii(hexToBytes(val.value));\n if (/[ -~]/.test(str)) {\n return JSON.stringify(str);\n }\n }\n return `0x${val.value}`;\n case ClarityType.OptionalNone:\n return 'none';\n case ClarityType.OptionalSome:\n return `(some ${cvToString(val.value, encoding)})`;\n case ClarityType.ResponseErr:\n return `(err ${cvToString(val.value, encoding)})`;\n case ClarityType.ResponseOk:\n return `(ok ${cvToString(val.value, encoding)})`;\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return val.value;\n case ClarityType.List:\n return `(list ${val.value.map(v => cvToString(v, encoding)).join(' ')})`;\n case ClarityType.Tuple:\n return `(tuple ${Object.keys(val.value)\n .map(key => `(${key} ${cvToString(val.value[key], encoding)})`)\n .join(' ')})`;\n case ClarityType.StringASCII:\n return `\"${val.value}\"`;\n case ClarityType.StringUTF8:\n return `u\"${val.value}\"`;\n }\n}\nexport function cvToValue(val, strictJsonCompat = false) {\n switch (val.type) {\n case ClarityType.BoolTrue:\n return true;\n case ClarityType.BoolFalse:\n return false;\n case ClarityType.Int:\n case ClarityType.UInt:\n if (strictJsonCompat) {\n return val.value.toString();\n }\n return val.value;\n case ClarityType.Buffer:\n return `0x${val.value}`;\n case ClarityType.OptionalNone:\n return null;\n case ClarityType.OptionalSome:\n return cvToJSON(val.value);\n case ClarityType.ResponseErr:\n return cvToJSON(val.value);\n case ClarityType.ResponseOk:\n return cvToJSON(val.value);\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return val.value;\n case ClarityType.List:\n return val.value.map(v => cvToJSON(v));\n case ClarityType.Tuple:\n const result = {};\n Object.keys(val.value).forEach(key => {\n result[key] = cvToJSON(val.value[key]);\n });\n return result;\n case ClarityType.StringASCII:\n return val.value;\n case ClarityType.StringUTF8:\n return val.value;\n }\n}\nexport function cvToJSON(val) {\n switch (val.type) {\n case ClarityType.ResponseErr:\n return { type: getCVTypeString(val), value: cvToValue(val, true), success: false };\n case ClarityType.ResponseOk:\n return { type: getCVTypeString(val), value: cvToValue(val, true), success: true };\n default:\n return { type: getCVTypeString(val), value: cvToValue(val, true) };\n }\n}\nexport function getCVTypeString(val) {\n switch (val.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return 'bool';\n case ClarityType.Int:\n return 'int';\n case ClarityType.UInt:\n return 'uint';\n case ClarityType.Buffer:\n return `(buff ${Math.ceil(val.value.length / 2)})`;\n case ClarityType.OptionalNone:\n return '(optional none)';\n case ClarityType.OptionalSome:\n return `(optional ${getCVTypeString(val.value)})`;\n case ClarityType.ResponseErr:\n return `(response UnknownType ${getCVTypeString(val.value)})`;\n case ClarityType.ResponseOk:\n return `(response ${getCVTypeString(val.value)} UnknownType)`;\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return 'principal';\n case ClarityType.List:\n return `(list ${val.value.length} ${val.value.length ? getCVTypeString(val.value[0]) : 'UnknownType'})`;\n case ClarityType.Tuple:\n return `(tuple ${Object.keys(val.value)\n .map(key => `(${key} ${getCVTypeString(val.value[key])})`)\n .join(' ')})`;\n case ClarityType.StringASCII:\n return `(string-ascii ${asciiToBytes(val.value).length})`;\n case ClarityType.StringUTF8:\n return `(string-utf8 ${utf8ToBytes(val.value).length})`;\n }\n}\nexport function isClarityType(input, withType) {\n return input.type === withType;\n}\n//# sourceMappingURL=clarityValue.js.map","import { hexToBytes, utf8ToBytes } from '@stacks/common';\nimport { ClarityType, bufferCV, bufferCVFromString, contractPrincipalCV, falseCV, getCVTypeString, intCV, noneCV, someCV, standardPrincipalCV, stringAsciiCV, stringUtf8CV, trueCV, uintCV, } from './clarity';\nimport { NotImplementedError } from './errors';\nimport { cloneDeep } from './utils';\nexport var ClarityAbiTypeId;\n(function (ClarityAbiTypeId) {\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeUInt128\"] = 1] = \"ClarityAbiTypeUInt128\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeInt128\"] = 2] = \"ClarityAbiTypeInt128\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeBool\"] = 3] = \"ClarityAbiTypeBool\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypePrincipal\"] = 4] = \"ClarityAbiTypePrincipal\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeNone\"] = 5] = \"ClarityAbiTypeNone\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeBuffer\"] = 6] = \"ClarityAbiTypeBuffer\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeResponse\"] = 7] = \"ClarityAbiTypeResponse\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeOptional\"] = 8] = \"ClarityAbiTypeOptional\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeTuple\"] = 9] = \"ClarityAbiTypeTuple\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeList\"] = 10] = \"ClarityAbiTypeList\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeStringAscii\"] = 11] = \"ClarityAbiTypeStringAscii\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeStringUtf8\"] = 12] = \"ClarityAbiTypeStringUtf8\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeTraitReference\"] = 13] = \"ClarityAbiTypeTraitReference\";\n})(ClarityAbiTypeId \|\| (ClarityAbiTypeId = {}));\nexport const isClarityAbiPrimitive = (val) => typeof val === 'string';\nexport const isClarityAbiBuffer = (val) => val.buffer !== undefined;\nexport const isClarityAbiStringAscii = (val) => val['string-ascii'] !== undefined;\nexport const isClarityAbiStringUtf8 = (val) => val['string-utf8'] !== undefined;\nexport const isClarityAbiResponse = (val) => val.response !== undefined;\nexport const isClarityAbiOptional = (val) => val.optional !== undefined;\nexport const isClarityAbiTuple = (val) => val.tuple !== undefined;\nexport const isClarityAbiList = (val) => val.list !== undefined;\nexport function getTypeUnion(val) {\n if (isClarityAbiPrimitive(val)) {\n if (val === 'uint128') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeUInt128, type: val };\n }\n else if (val === 'int128') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeInt128, type: val };\n }\n else if (val === 'bool') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeBool, type: val };\n }\n else if (val === 'principal') {\n return { id: ClarityAbiTypeId.ClarityAbiTypePrincipal, type: val };\n }\n else if (val === 'trait_reference') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeTraitReference, type: val };\n }\n else if (val === 'none') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeNone, type: val };\n }\n else {\n throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);\n }\n }\n else if (isClarityAbiBuffer(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeBuffer, type: val };\n }\n else if (isClarityAbiResponse(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeResponse, type: val };\n }\n else if (isClarityAbiOptional(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeOptional, type: val };\n }\n else if (isClarityAbiTuple(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeTuple, type: val };\n }\n else if (isClarityAbiList(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeList, type: val };\n }\n else if (isClarityAbiStringAscii(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeStringAscii, type: val };\n }\n else if (isClarityAbiStringUtf8(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeStringUtf8, type: val };\n }\n else {\n throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);\n }\n}\nexport function encodeAbiClarityValue(value, type) {\n const union = type.id\n ? type\n : getTypeUnion(type);\n switch (union.id) {\n case ClarityAbiTypeId.ClarityAbiTypeUInt128:\n return uintCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeInt128:\n return intCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeBool:\n if (value === 'false' \|\| value === '0')\n return falseCV();\n else if (value === 'true' \|\| value === '1')\n return trueCV();\n else\n throw new Error(`Unexpected Clarity bool value: ${JSON.stringify(value)}`);\n case ClarityAbiTypeId.ClarityAbiTypePrincipal:\n if (value.includes('.')) {\n const [addr, name] = value.split('.');\n return contractPrincipalCV(addr, name);\n }\n else {\n return standardPrincipalCV(value);\n }\n case ClarityAbiTypeId.ClarityAbiTypeTraitReference:\n const [addr, name] = value.split('.');\n return contractPrincipalCV(addr, name);\n case ClarityAbiTypeId.ClarityAbiTypeNone:\n return noneCV();\n case ClarityAbiTypeId.ClarityAbiTypeBuffer:\n return bufferCV(hexToBytes(value));\n case ClarityAbiTypeId.ClarityAbiTypeStringAscii:\n return stringAsciiCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeStringUtf8:\n return stringUtf8CV(value);\n case ClarityAbiTypeId.ClarityAbiTypeOptional:\n return someCV(encodeAbiClarityValue(value, union.type.optional));\n case ClarityAbiTypeId.ClarityAbiTypeResponse:\n case ClarityAbiTypeId.ClarityAbiTypeTuple:\n case ClarityAbiTypeId.ClarityAbiTypeList:\n throw new NotImplementedError(`Unsupported encoding for Clarity type: ${union.id}`);\n default:\n throw new Error(`Unexpected Clarity type ID: ${JSON.stringify(union)}`);\n }\n}\nexport function encodeClarityValue(type, value) {\n const union = type.id\n ? type\n : getTypeUnion(type);\n if (union.id === ClarityAbiTypeId.ClarityAbiTypeBuffer) {\n return bufferCV(utf8ToBytes(value));\n }\n return encodeAbiClarityValue(value, union);\n}\nexport function getTypeString(val) {\n if (isClarityAbiPrimitive(val)) {\n if (val === 'int128') {\n return 'int';\n }\n else if (val === 'uint128') {\n return 'uint';\n }\n return val;\n }\n else if (isClarityAbiBuffer(val)) {\n return `(buff ${val.buffer.length})`;\n }\n else if (isClarityAbiStringAscii(val)) {\n return `(string-ascii ${val['string-ascii'].length})`;\n }\n else if (isClarityAbiStringUtf8(val)) {\n return `(string-utf8 ${val['string-utf8'].length})`;\n }\n else if (isClarityAbiResponse(val)) {\n return `(response ${getTypeString(val.response.ok)} ${getTypeString(val.response.error)})`;\n }\n else if (isClarityAbiOptional(val)) {\n return `(optional ${getTypeString(val.optional)})`;\n }\n else if (isClarityAbiTuple(val)) {\n return `(tuple ${val.tuple.map(t => `(${t.name} ${getTypeString(t.type)})`).join(' ')})`;\n }\n else if (isClarityAbiList(val)) {\n return `(list ${val.list.length} ${getTypeString(val.list.type)})`;\n }\n else {\n throw new Error(`Type string unsupported for Clarity type: ${JSON.stringify(val)}`);\n }\n}\nexport function abiFunctionToString(func) {\n const access = func.access === 'read_only' ? 'read-only' : func.access;\n return `(define-${access} (${func.name} ${func.args\n .map(arg => `(${arg.name} ${getTypeString(arg.type)})`)\n .join(' ')}))`;\n}\nfunction matchType(cv, abiType) {\n const union = getTypeUnion(abiType);\n switch (cv.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeBool;\n case ClarityType.Int:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeInt128;\n case ClarityType.UInt:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeUInt128;\n case ClarityType.Buffer:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeBuffer &&\n union.type.buffer.length >= Math.ceil(cv.value.length / 2));\n case ClarityType.StringASCII:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeStringAscii &&\n union.type['string-ascii'].length >= cv.value.length);\n case ClarityType.StringUTF8:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeStringUtf8 &&\n union.type['string-utf8'].length >= cv.value.length);\n case ClarityType.OptionalNone:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeNone \|\|\n union.id === ClarityAbiTypeId.ClarityAbiTypeOptional);\n case ClarityType.OptionalSome:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeOptional &&\n matchType(cv.value, union.type.optional));\n case ClarityType.ResponseErr:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeResponse &&\n matchType(cv.value, union.type.response.error));\n case ClarityType.ResponseOk:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeResponse &&\n matchType(cv.value, union.type.response.ok));\n case ClarityType.PrincipalContract:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypePrincipal \|\|\n union.id === ClarityAbiTypeId.ClarityAbiTypeTraitReference);\n case ClarityType.PrincipalStandard:\n return union.id === ClarityAbiTypeId.ClarityAbiTypePrincipal;\n case ClarityType.List:\n return (union.id == ClarityAbiTypeId.ClarityAbiTypeList &&\n union.type.list.length >= cv.value.length &&\n cv.value.every(val => matchType(val, union.type.list.type)));\n case ClarityType.Tuple:\n if (union.id == ClarityAbiTypeId.ClarityAbiTypeTuple) {\n const tuple = cloneDeep(cv.value);\n for (let i = 0; i < union.type.tuple.length; i++) {\n const abiTupleEntry = union.type.tuple[i];\n const key = abiTupleEntry.name;\n const val = tuple[key];\n if (val) {\n if (!matchType(val, abiTupleEntry.type)) {\n return false;\n }\n delete tuple[key];\n }\n else {\n return false;\n }\n }\n return true;\n }\n else {\n return false;\n }\n default:\n return false;\n }\n}\nexport function validateContractCall(payload, abi) {\n const filtered = abi.functions.filter(fn => fn.name === payload.functionName.content);\n if (filtered.length === 1) {\n const abiFunc = filtered[0];\n const abiArgs = abiFunc.args;\n if (payload.functionArgs.length !== abiArgs.length) {\n throw new Error(`Clarity function expects ${abiArgs.length} argument(s) but received ${payload.functionArgs.length}`);\n }\n for (let i = 0; i < payload.functionArgs.length; i++) {\n const payloadArg = payload.functionArgs[i];\n const abiArg = abiArgs[i];\n if (!matchType(payloadArg, abiArg.type)) {\n const argNum = i + 1;\n throw new Error(`Clarity function \\`${payload.functionName.content}\\` expects argument ${argNum} to be of type ${getTypeString(abiArg.type)}, not ${getCVTypeString(payloadArg)}`);\n }\n }\n return true;\n }\n else if (filtered.length === 0) {\n throw new Error(`ABI doesn't contain a function with the name ${payload.functionName.content}`);\n }\n else {\n throw new Error(`Malformed ABI. Contains multiple functions with the name ${payload.functionName.content}`);\n }\n}\nexport function parseToCV(input, type) {\n const typeString = getTypeString(type);\n if (isClarityAbiPrimitive(type)) {\n if (type === 'uint128') {\n return uintCV(input);\n }\n else if (type === 'int128') {\n return intCV(input);\n }\n else if (type === 'bool') {\n if (input.toLowerCase() === 'true') {\n return trueCV();\n }\n else if (input.toLowerCase() === 'false') {\n return falseCV();\n }\n else {\n throw new Error(`Invalid bool value: ${input}`);\n }\n }\n else if (type === 'principal') {\n if (input.includes('.')) {\n const [address, contractName] = input.split('.');\n return contractPrincipalCV(address, contractName);\n }\n else {\n return standardPrincipalCV(input);\n }\n }\n else {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n }\n else if (isClarityAbiBuffer(type)) {\n const inputLength = utf8ToBytes(input).byteLength;\n if (inputLength > type.buffer.length) {\n throw new Error(`Input exceeds specified buffer length limit of ${type.buffer.length}`);\n }\n return bufferCVFromString(input);\n }\n else if (isClarityAbiResponse(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiOptional(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiTuple(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiList(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n}\n//# sourceMappingURL=contract-abi.js.map","import { PostConditionMode, PostConditionPrincipalId, PostConditionType, } from './constants';\nimport { StacksWireType, addressToString, parseAssetString, parsePrincipalString, serializePostConditionWire, } from './wire';\nvar PostConditionCodeWireType;\n(function (PostConditionCodeWireType) {\n PostConditionCodeWireType[PostConditionCodeWireType[\"eq\"] = 1] = \"eq\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"gt\"] = 2] = \"gt\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"lt\"] = 4] = \"lt\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"gte\"] = 3] = \"gte\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"lte\"] = 5] = \"lte\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"sent\"] = 16] = \"sent\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"not-sent\"] = 17] = \"not-sent\";\n})(PostConditionCodeWireType \|\| (PostConditionCodeWireType = {}));\nexport function postConditionToWire(postcondition) {\n switch (postcondition.type) {\n case 'stx-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.STX,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n amount: BigInt(postcondition.amount),\n };\n case 'ft-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.Fungible,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n amount: BigInt(postcondition.amount),\n asset: parseAssetString(postcondition.asset),\n };\n case 'nft-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.NonFungible,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n asset: parseAssetString(postcondition.asset),\n assetName: postcondition.assetId,\n };\n default:\n throw new Error('Invalid post condition type');\n }\n}\nexport function wireToPostCondition(wire) {\n switch (wire.conditionType) {\n case PostConditionType.STX:\n return {\n type: 'stx-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n amount: wire.amount.toString(),\n };\n case PostConditionType.Fungible:\n return {\n type: 'ft-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n amount: wire.amount.toString(),\n asset: assetWireToString(wire.asset),\n };\n case PostConditionType.NonFungible:\n return {\n type: 'nft-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n asset: assetWireToString(wire.asset),\n assetId: wire.assetName,\n };\n default: {\n const _exhaustiveCheck = wire;\n throw new Error(`Invalid post condition type: ${_exhaustiveCheck}`);\n }\n }\n}\nexport function conditionTypeToByte(condition) {\n return PostConditionCodeWireType[condition];\n}\nexport function conditionByteToType(wireType) {\n return PostConditionCodeWireType[wireType];\n}\nexport function postConditionToHex(postcondition) {\n const wire = postConditionToWire(postcondition);\n return serializePostConditionWire(wire);\n}\nexport function postConditionModeFrom(mode) {\n if (typeof mode === 'number')\n return mode;\n if (mode === 'allow')\n return PostConditionMode.Allow;\n if (mode === 'deny')\n return PostConditionMode.Deny;\n throw new Error(`Invalid post condition mode: ${mode}`);\n}\nfunction assetWireToString(asset) {\n const address = addressToString(asset.address);\n const contractId = `${address}.${asset.contractName.content}`;\n return `${contractId}::${asset.assetName.content}`;\n}\nfunction principalWireToString(principal) {\n switch (principal.prefix) {\n case PostConditionPrincipalId.Origin:\n return 'origin';\n case PostConditionPrincipalId.Standard:\n return addressToString(principal.address);\n case PostConditionPrincipalId.Contract:\n const address = addressToString(principal.address);\n return `${address}.${principal.contractName.content}`;\n default:\n const _exhaustiveCheck = principal;\n throw new Error(`Invalid principal type: ${_exhaustiveCheck}`);\n }\n}\n//# sourceMappingURL=postcondition.js.map","import { isNonSequentialMultiSig, isSequentialMultiSig, isSingleSig, nextVerification, } from './authorization';\nimport { AddressHashMode, AuthType, PubKeyEncoding } from './constants';\nimport { SigningError } from './errors';\nimport { cloneDeep } from './utils';\nimport { StacksWireType } from './wire';\nimport { createStacksPublicKey } from './keys';\nexport class TransactionSigner {\n constructor(transaction) {\n this.transaction = transaction;\n this.sigHash = transaction.signBegin();\n this.originDone = false;\n this.checkOversign = true;\n this.checkOverlap = true;\n const spendingCondition = transaction.auth.spendingCondition;\n if (spendingCondition && !isSingleSig(spendingCondition)) {\n if (spendingCondition.fields.filter(field => field.contents.type === StacksWireType.MessageSignature).length >= spendingCondition.signaturesRequired) {\n throw new Error('SpendingCondition has more signatures than are expected');\n }\n spendingCondition.fields.forEach(field => {\n if (field.contents.type !== StacksWireType.MessageSignature)\n return;\n const signature = field.contents;\n const nextVerify = nextVerification(this.sigHash, transaction.auth.authType, spendingCondition.fee, spendingCondition.nonce, PubKeyEncoding.Compressed, signature.data);\n if (!isNonSequentialMultiSig(spendingCondition.hashMode)) {\n this.sigHash = nextVerify.nextSigHash;\n }\n });\n }\n }\n static createSponsorSigner(transaction, spendingCondition) {\n if (transaction.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot add sponsor to non-sponsored transaction');\n }\n const tx = cloneDeep(transaction);\n tx.setSponsor(spendingCondition);\n const originSigHash = tx.verifyOrigin();\n const signer = new this(tx);\n signer.originDone = true;\n signer.sigHash = originSigHash;\n signer.checkOversign = true;\n signer.checkOverlap = true;\n return signer;\n }\n signOrigin(privateKey) {\n if (this.checkOverlap && this.originDone) {\n throw new SigningError('Cannot sign origin after sponsor key');\n }\n if (this.transaction.auth === undefined) {\n throw new SigningError('\"transaction.auth\" is undefined');\n }\n if (this.transaction.auth.spendingCondition === undefined) {\n throw new SigningError('\"transaction.auth.spendingCondition\" is undefined');\n }\n const spendingCondition = this.transaction.auth.spendingCondition;\n if (spendingCondition.hashMode === AddressHashMode.P2SH \|\|\n spendingCondition.hashMode === AddressHashMode.P2WSH) {\n if (this.checkOversign &&\n spendingCondition.fields.filter(field => field.contents.type === StacksWireType.MessageSignature).length >= spendingCondition.signaturesRequired) {\n throw new Error('Origin would have too many signatures');\n }\n }\n const nextSighash = this.transaction.signNextOrigin(this.sigHash, privateKey);\n if (isSingleSig(this.transaction.auth.spendingCondition) \|\|\n isSequentialMultiSig(this.transaction.auth.spendingCondition.hashMode)) {\n this.sigHash = nextSighash;\n }\n }\n appendOrigin(publicKey) {\n const wire = typeof publicKey === 'object' && 'type' in publicKey\n ? publicKey\n : createStacksPublicKey(publicKey);\n if (this.checkOverlap && this.originDone) {\n throw Error('Cannot append public key to origin after sponsor key');\n }\n if (this.transaction.auth === undefined) {\n throw new Error('\"transaction.auth\" is undefined');\n }\n if (this.transaction.auth.spendingCondition === undefined) {\n throw new Error('\"transaction.auth.spendingCondition\" is undefined');\n }\n this.transaction.appendPubkey(wire);\n }\n signSponsor(privateKey) {\n if (this.transaction.auth === undefined) {\n throw new SigningError('\"transaction.auth\" is undefined');\n }\n if (this.transaction.auth.authType !== AuthType.Sponsored) {\n throw new SigningError('\"transaction.auth.authType\" is not AuthType.Sponsored');\n }\n const nextSighash = this.transaction.signNextSponsor(this.sigHash, privateKey);\n this.sigHash = nextSighash;\n this.originDone = true;\n }\n getTxInComplete() {\n return cloneDeep(this.transaction);\n }\n resume(transaction) {\n this.transaction = cloneDeep(transaction);\n this.sigHash = transaction.signBegin();\n }\n}\n//# sourceMappingURL=signer.js.map","import { STACKS_MAINNET, clientFromNetwork, networkFrom, } from '@stacks/network';\nimport { c32address } from 'c32check';\nimport { createMultiSigSpendingCondition, createSingleSigSpendingCondition, createSponsoredAuth, createStandardAuth, isSingleSig, } from './authorization';\nimport { AddressHashMode, ClarityVersion, PayloadType, PostConditionMode, } from './constants';\nimport { validateContractCall } from './contract-abi';\nimport { fetchAbi, fetchFeeEstimate, fetchNonce } from './fetch';\nimport { createStacksPublicKey, privateKeyToHex, privateKeyToPublic, publicKeyToAddress, publicKeyToHex, } from './keys';\nimport { postConditionModeFrom, postConditionToWire } from './postcondition';\nimport { TransactionSigner } from './signer';\nimport { StacksTransactionWire, deriveNetworkFromTx } from './transaction';\nimport { omit } from './utils';\nimport { addressFromPublicKeys, createAddress, createContractCallPayload, createLPList, createSmartContractPayload, createTokenTransferPayload, deserializePostConditionWire, } from './wire';\nexport async function makeUnsignedSTXTokenTransfer(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n memo: '',\n sponsored: false,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), txOptions.client);\n const payload = createTokenTransferPayload(options.recipient, options.amount, options.memo);\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n });\n if (txOptions.fee == null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce == null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeSTXTokenTransfer(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedSTXTokenTransfer({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedSTXTokenTransfer(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function makeContractDeploy(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedContractDeploy({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedContractDeploy(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function makeUnsignedContractDeploy(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n postConditionMode: PostConditionMode.Deny,\n sponsored: false,\n clarityVersion: ClarityVersion.Clarity4,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), txOptions.client);\n options.postConditionMode = postConditionModeFrom(options.postConditionMode);\n const payload = createSmartContractPayload(options.contractName, options.codeBody, options.clarityVersion);\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const postConditions = (options.postConditions ?? []).map(pc => {\n if (typeof pc === 'string')\n return deserializePostConditionWire(pc);\n if (typeof pc.type === 'string')\n return postConditionToWire(pc);\n return pc;\n });\n const lpPostConditions = createLPList(postConditions);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n postConditions: lpPostConditions,\n postConditionMode: options.postConditionMode,\n });\n if (txOptions.fee === undefined \|\| txOptions.fee === null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce === undefined \|\| txOptions.nonce === null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeUnsignedContractCall(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n postConditionMode: PostConditionMode.Deny,\n sponsored: false,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), options.client);\n options.postConditionMode = postConditionModeFrom(options.postConditionMode);\n const payload = createContractCallPayload(options.contractAddress, options.contractName, options.functionName, options.functionArgs);\n if (options?.validateWithAbi) {\n let abi;\n if (typeof options.validateWithAbi === 'boolean') {\n if (options?.network) {\n abi = await fetchAbi({ ...options });\n }\n else {\n throw new Error('Network option must be provided in order to validate with ABI');\n }\n }\n else {\n abi = options.validateWithAbi;\n }\n validateContractCall(payload, abi);\n }\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const postConditions = (options.postConditions ?? []).map(pc => {\n if (typeof pc === 'string')\n return deserializePostConditionWire(pc);\n if (typeof pc.type === 'string')\n return postConditionToWire(pc);\n return pc;\n });\n const lpPostConditions = createLPList(postConditions);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n postConditions: lpPostConditions,\n postConditionMode: options.postConditionMode,\n });\n if (txOptions.fee === undefined \|\| txOptions.fee === null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce === undefined \|\| txOptions.nonce === null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeContractCall(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedContractCall({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedContractCall(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function sponsorTransaction(sponsorOptions) {\n const defaultOptions = {\n fee: 0,\n sponsorNonce: 0,\n sponsorAddressHashmode: AddressHashMode.P2PKH,\n network: deriveNetworkFromTx(sponsorOptions.transaction),\n };\n const options = Object.assign(defaultOptions, sponsorOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), options.client);\n const sponsorPubKey = privateKeyToPublic(options.sponsorPrivateKey);\n if (sponsorOptions.fee == null) {\n let txFee = 0;\n switch (options.transaction.payload.payloadType) {\n case PayloadType.TokenTransfer:\n case PayloadType.SmartContract:\n case PayloadType.VersionedSmartContract:\n case PayloadType.ContractCall:\n txFee = BigInt(await fetchFeeEstimate({ ...options }));\n break;\n default:\n throw new Error(`Sponsored transactions not supported for transaction type ${PayloadType[options.transaction.payload.payloadType]}`);\n }\n options.transaction.setFee(txFee);\n options.fee = txFee;\n }\n if (sponsorOptions.sponsorNonce == null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = publicKeyToAddress(addressVersion, sponsorPubKey);\n const sponsorNonce = await fetchNonce({ address, ...options });\n options.sponsorNonce = sponsorNonce;\n }\n const sponsorSpendingCondition = createSingleSigSpendingCondition(options.sponsorAddressHashmode, sponsorPubKey, options.sponsorNonce, options.fee);\n options.transaction.setSponsor(sponsorSpendingCondition);\n const privKey = options.sponsorPrivateKey;\n const signer = TransactionSigner.createSponsorSigner(options.transaction, sponsorSpendingCondition);\n signer.signSponsor(privKey);\n return signer.transaction;\n}\nfunction mutatingSignAppendMultiSig(transaction, publicKeys, signerKeys, address) {\n if (isSingleSig(transaction.auth.spendingCondition)) {\n throw new Error('Transaction is not a multi-sig transaction');\n }\n const signer = new TransactionSigner(transaction);\n const pubs = address\n ? sortPublicKeysForAddress(publicKeys, transaction.auth.spendingCondition.signaturesRequired, transaction.auth.spendingCondition.hashMode, createAddress(address).hash160)\n : publicKeys;\n for (const publicKey of pubs) {\n const signerKey = signerKeys.find(key => privateKeyToPublic(key) === publicKey);\n if (signerKey) {\n signer.signOrigin(signerKey);\n }\n else {\n signer.appendOrigin(publicKey);\n }\n }\n}\nfunction sortPublicKeysForAddress(publicKeys, numSigs, hashMode, hash) {\n const hashUnsorted = addressFromPublicKeys(0, hashMode, numSigs, publicKeys.map(createStacksPublicKey)).hash160;\n if (hashUnsorted === hash)\n return publicKeys;\n const publicKeysSorted = publicKeys.slice().sort();\n const hashSorted = addressFromPublicKeys(0, hashMode, numSigs, publicKeysSorted.map(createStacksPublicKey)).hash160;\n if (hashSorted === hash)\n return publicKeysSorted;\n throw new Error('Failed to find matching multi-sig address given public-keys.');\n}\n//# sourceMappingURL=builders.js.map","/** Address versions corresponding to pox.clar, pox-2.clar /\nexport enum PoXAddressVersion {\n /* (b58/legacy) p2pkh address, and `hashbytes` is the 20-byte hash160 of a single public key /\n P2PKH = 0x00,\n /* (b58/legacy) p2sh address, and `hashbytes` is the 20-byte hash160 of a redeemScript script /\n P2SH = 0x01,\n /* (b58/legacy) p2wpkh-p2sh address, and `hashbytes` is the 20-byte hash160 of a p2wpkh witness script /\n P2SHP2WPKH = 0x02, // likely unused, as indistinguishable from P2SH\n /* (b58/legacy) p2wsh-p2sh address, and `hashbytes` is the 20-byte hash160 of a p2wsh witness script /\n P2SHP2WSH = 0x03, // likely unused, as indistinguishable from P2SH\n /* (bech32/segwit) p2wpkh address, and `hashbytes` is the 20-byte hash160 of the witness script /\n P2WPKH = 0x04,\n /* (bech32/segwit) p2wsh address, and `hashbytes` is the 32-byte sha256 of the witness script /\n P2WSH = 0x05,\n /* (bech32/segwit) p2tr address, and `hashbytes` is the 32-byte sha256 of the witness script /\n P2TR = 0x06,\n}\n\n/* @ignore /\nexport const BitcoinNetworkVersion = {\n mainnet: {\n P2PKH: 0x00, // 0\n P2SH: 0x05, // 5\n },\n testnet: {\n P2PKH: 0x6f, // 111\n P2SH: 0xc4, // 196\n },\n devnet: {\n // equivalent to testnet for our purposes\n P2PKH: 0x6f, // 111\n P2SH: 0xc4, // 196\n },\n mocknet: {\n // equivalent to testnet for our purposes\n P2PKH: 0x6f, // 111\n P2SH: 0xc4, // 196\n },\n} as const;\n\n/\n Valid prefix chars for mainnet and testnet P2PKH and P2SH addresses\n * mainnet P2PKH: 1\n * testnet P2PKH: m or n\n * mainnet P2SH: 3\n * testnet P2SH: 2\n * @ignore\n /\nexport const B58_ADDR_PREFIXES = /^(1\|3\|m\|n\|2)/;\n\n/\n Valid prefixes for supported segwit address, structure is:\n * HRP PREFIX + SEPARATOR (always '1') + C32_ENCODED SEGWIT_VERSION_BYTE ('q' for 0, 'p' for 1) + HASHDATA\n * @ignore\n /\nexport const SEGWIT_V0_ADDR_PREFIX = /^(bc1q\|tb1q\|bcrt1q)/i;\nexport const SEGWIT_V1_ADDR_PREFIX = /^(bc1p\|tb1p\|bcrt1p)/i;\n\n/\n Segwit Human-Readable Parts\n * Valid prefixs for mainnet and testnet bech32/segwit addresses\n * @ignore\n /\nexport const SegwitPrefix = {\n mainnet: 'bc',\n testnet: 'tb',\n devnet: 'bcrt',\n mocknet: 'bcrt',\n} as const;\n/* @ignore /\nexport const SEGWIT_ADDR_PREFIXES = /^(bc\|tb)/i;\n\n/* @ignore /\nexport const SEGWIT_V0 = 0;\n/* @ignore /\nexport const SEGWIT_V1 = 1;\n\n// Segwit/taproot address examples:\n// mainnet P2WPKH: bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4\n// testnet P2WPKH: tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx\n// mainnet P2WSH: bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3\n// testnet P2WSH: tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7\n// mainnet P2TR: bc1p5d7rjq7g6rdk2yhzks9smlaqtedr4dekq08ge8ztwac72sfr9rusxg3297\n// testnet P2TR: tb1p6h5fuzmnvpdthf5shf0qqjzwy7wsqc5rhmgq2ks9xrak4ry6mtrscsqvzp\n\n/\n Transitional periods from the 2.1 launch\n * @see SIP-015\n /\nexport enum PoxOperationPeriod {\n /* Period 1: This is before the 2.1 fork. /\n Period1 = 'Period1',\n /* Period 2a: This is after the 2.1 fork, but before v1_unlock_height. /\n Period2a = 'Period2a', //\n /* Period 2b: This is after the 2.1 fork, after v1_unlock_height, but before the first PoX-2 reward cycle. /\n Period2b = 'Period2b',\n /* Period 3: This is after the first PoX-2 reward cycle has begun. The original PoX contract state will no longer have any impact on reward sets. /\n Period3 = 'Period3',\n}\n\nexport enum StackingErrors {\n // taken from https://github.com/stacks-network/stacks-blockchain/blob/088ff00761b27a12bfaf19dab5743e77e8ca4d0c/src/chainstate/stacks/boot/pox-3.clar\n ERR_STACKING_UNREACHABLE = 255,\n ERR_STACKING_CORRUPTED_STATE = 254,\n ERR_STACKING_INSUFFICIENT_FUNDS = 1,\n ERR_STACKING_INVALID_LOCK_PERIOD = 2,\n ERR_STACKING_ALREADY_STACKED = 3,\n ERR_STACKING_NO_SUCH_PRINCIPAL = 4,\n ERR_STACKING_EXPIRED = 5,\n ERR_STACKING_STX_LOCKED = 6,\n ERR_STACKING_PERMISSION_DENIED = 9,\n ERR_STACKING_THRESHOLD_NOT_MET = 11,\n ERR_STACKING_POX_ADDRESS_IN_USE = 12,\n ERR_STACKING_INVALID_POX_ADDRESS = 13,\n ERR_STACKING_ALREADY_REJECTED = 17,\n ERR_STACKING_INVALID_AMOUNT = 18,\n ERR_NOT_ALLOWED = 19,\n ERR_STACKING_ALREADY_DELEGATED = 20,\n ERR_DELEGATION_EXPIRES_DURING_LOCK = 21,\n ERR_DELEGATION_TOO_MUCH_LOCKED = 22,\n ERR_DELEGATION_POX_ADDR_REQUIRED = 23,\n ERR_INVALID_START_BURN_HEIGHT = 24,\n ERR_NOT_CURRENT_STACKER = 25,\n ERR_STACK_EXTEND_NOT_LOCKED = 26,\n ERR_STACK_INCREASE_NOT_LOCKED = 27,\n ERR_DELEGATION_NO_REWARD_SLOT = 28,\n ERR_DELEGATION_WRONG_REWARD_SLOT = 29,\n ERR_STACKING_IS_DELEGATED = 30,\n ERR_STACKING_NOT_DELEGATED = 31,\n}\n","/! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) /\nexport function assertNumber(n) {\n if (!Number.isSafeInteger(n))\n throw new Error(`Wrong integer: ${n}`);\n}\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}\nexport const utils = { alphabet, chain, checksum, radix, radix2, join, padding };\nexport const base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));\nexport const base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));\nexport const base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));\nexport const base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));\nexport const base64 = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));\nexport const base64url = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));\nconst genBase58 = (abc) => chain(radix(58), alphabet(abc), join(''));\nexport const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');\nexport const base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');\nexport const base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz');\nconst XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11];\nexport const 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 += 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 = 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};\nexport const base58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);\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}\nexport const bech32 = genBech32('bech32');\nexport const bech32m = genBech32('bech32m');\nexport const utf8 = {\n encode: (data) => new TextDecoder().decode(data),\n decode: (str) => new TextEncoder().encode(str),\n};\nexport const 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, hex, base16, base32, base64, base64url, base58, base58xmr\n};\nconst coderTypeError = `Invalid encoding type. Available types: ${Object.keys(CODERS).join(', ')}`;\nexport const 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};\nexport const str = bytesToString;\nexport const 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};\nexport const bytes = stringToBytes;\n","import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { getPublicKey as nobleGetPublicKey, signSync, utils } from '@noble/secp256k1';\nimport { bytesToHex, concatBytes, hexToBytes, privateKeyToBytes, readUInt8, } from '@stacks/common';\nimport base58 from 'bs58';\nimport { hashRipemd160 } from './hashRipemd160';\nimport { hashSha256Sync } from './sha2Hash';\nconst BITCOIN_PUBKEYHASH = 0x00;\nutils.hmacSha256Sync = (key, ...msgs) => {\n const h = hmac.create(sha256, key);\n msgs.forEach(msg => h.update(msg));\n return h.digest();\n};\nexport function makeECPrivateKey() {\n return bytesToHex(utils.randomPrivateKey());\n}\nexport function base58CheckDecode(btcAddress) {\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 if ((checksum[0] ^ newChecksum[0]) \|\n (checksum[1] ^ newChecksum[1]) \|\n (checksum[2] ^ newChecksum[2]) \|\n (checksum[3] ^ newChecksum[3])) {\n throw new Error('Invalid checksum');\n }\n if (payload.length !== 21)\n throw new TypeError('Invalid address length');\n const version = readUInt8(payload, 0);\n const hash = payload.slice(1);\n return { version, hash };\n}\nexport function base58Encode(hash) {\n const checksum = sha256(sha256(hash));\n return base58.encode(concatBytes(hash, checksum).slice(0, hash.length + 4));\n}\nexport function base58CheckEncode(version, hash) {\n return base58Encode(concatBytes(new Uint8Array([version]), hash.slice(0, 20)));\n}\nexport function publicKeyToBtcAddress(publicKey, version = BITCOIN_PUBKEYHASH) {\n const publicKeyBytes = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n const publicKeyHash160 = hashRipemd160(hashSha256Sync(publicKeyBytes));\n return base58CheckEncode(version, publicKeyHash160);\n}\nexport function getPublicKeyFromPrivate(privateKey) {\n const privateKeyBytes = privateKeyToBytes(privateKey);\n return bytesToHex(nobleGetPublicKey(privateKeyBytes.slice(0, 32), true));\n}\nexport function ecSign(messageHash, privateKey) {\n return signSync(messageHash, privateKeyToBytes(privateKey).slice(0, 32), {\n der: false,\n });\n}\n//# sourceMappingURL=keys.js.map","import { readUInt16LE, readUInt32LE, readUInt8, writeUInt16LE, writeUInt32LE, writeUInt8, } from '@stacks/common';\nconst MAX_SAFE_INTEGER = 9007199254740991;\nfunction ensureUInt53(n) {\n if (n < 0 \|\| n > MAX_SAFE_INTEGER \|\| n % 1 !== 0)\n throw new RangeError('value out of range');\n}\nexport function encode(number, bytes, offset = 0) {\n ensureUInt53(number);\n if (!bytes)\n bytes = new Uint8Array(encodingLength(number));\n if (number < 0xfd) {\n writeUInt8(bytes, number, offset);\n }\n else if (number <= 65535) {\n writeUInt8(bytes, 0xfd, offset);\n writeUInt16LE(bytes, number, offset + 1);\n }\n else if (number <= 4294967295) {\n writeUInt8(bytes, 0xfe, offset);\n writeUInt32LE(bytes, number, offset + 1);\n }\n else {\n writeUInt8(bytes, 0xff, offset);\n writeUInt32LE(bytes, number >>> 0, offset + 1);\n writeUInt32LE(bytes, (number / 4294967296) \| 0, offset + 5);\n }\n return bytes;\n}\nexport function decode(bytes, offset = 0) {\n const first = readUInt8(bytes, offset);\n if (first < 0xfd) {\n return first;\n }\n else if (first === 0xfd) {\n return readUInt16LE(bytes, offset + 1);\n }\n else if (first === 0xfe) {\n return readUInt32LE(bytes, offset + 1);\n }\n else {\n const lo = readUInt32LE(bytes, offset + 1);\n const hi = readUInt32LE(bytes, offset + 5);\n const number = hi * 4294967296 + lo;\n ensureUInt53(number);\n return number;\n }\n}\nexport function encodingLength(number) {\n ensureUInt53(number);\n return number < 0xfd ? 1 : number <= 65535 ? 3 : number <= 4294967295 ? 5 : 9;\n}\n//# sourceMappingURL=varuint.js.map","import { sha256 } from '@noble/hashes/sha256';\nimport { concatBytes, utf8ToBytes } from '@stacks/common';\nimport { decode, encode, encodingLength } from './varuint';\nconst chainPrefix = '\\x17Stacks Signed Message:\\n';\nexport function hashMessage(message, prefix = chainPrefix) {\n return sha256(encodeMessage(message, prefix));\n}\nexport function encodeMessage(message, prefix = chainPrefix) {\n const messageBytes = typeof message == 'string' ? utf8ToBytes(message) : message;\n const encodedLength = encode(messageBytes.length);\n return concatBytes(utf8ToBytes(prefix), encodedLength, messageBytes);\n}\nexport function decodeMessage(encodedMessage, prefix = chainPrefix) {\n const prefixByteLength = utf8ToBytes(prefix).byteLength;\n const messageWithoutChainPrefix = encodedMessage.subarray(prefixByteLength);\n const decoded = decode(messageWithoutChainPrefix);\n const varIntLength = encodingLength(decoded);\n return messageWithoutChainPrefix.slice(varIntLength);\n}\n//# sourceMappingURL=messageSignature.js.map","import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { getPublicKey, getSharedSecret, Point, Signature, signSync, utils, verify, } from '@noble/secp256k1';\nimport { bigIntToBytes, bytesToHex, bytesToUtf8, concatBytes, FailedDecryptionError, hexToBigInt, hexToBytes, parseRecoverableSignatureVrs, signatureRsvToVrs, utf8ToBytes, } 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';\nutils.hmacSha256Sync = (key, ...msgs) => {\n const h = hmac.create(sha256, key);\n msgs.forEach(msg => h.update(msg));\n return h.digest();\n};\nexport var InvalidPublicKeyReason;\n(function (InvalidPublicKeyReason) {\n InvalidPublicKeyReason[\"InvalidFormat\"] = \"InvalidFormat\";\n InvalidPublicKeyReason[\"IsNotPoint\"] = \"IsNotPoint\";\n})(InvalidPublicKeyReason \|\| (InvalidPublicKeyReason = {}));\nexport async function aes256CbcEncrypt(iv, key, plaintext) {\n const cipher = await createCipher();\n return await cipher.encrypt('aes-256-cbc', key, iv, plaintext);\n}\nasync function aes256CbcDecrypt(iv, key, ciphertext) {\n const cipher = await createCipher();\n return await cipher.decrypt('aes-256-cbc', key, iv, ciphertext);\n}\nexport function hmacSha256(key, content) {\n return hmac(sha256, key, content);\n}\nfunction equalsConstTime(a, b) {\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}\nfunction sharedSecretToKeys(sharedSecret) {\n const hashedSecret = hashSha512Sync(sharedSecret);\n return {\n encryptionKey: hashedSecret.slice(0, 32),\n hmacKey: hashedSecret.slice(32),\n };\n}\nfunction allHexChars(maybe) {\n return maybe.match(/^[0-9a-f]+$/i) !== null;\n}\nfunction isValidPublicKey(pub) {\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)\n return invalidFormat;\n const firstByte = pub.slice(0, 2);\n if (pub.length === 130 && firstByte !== '04')\n return invalidFormat;\n if (pub.length === 66 && firstByte !== '02' && firstByte !== '03')\n return invalidFormat;\n if (!allHexChars(pub))\n return invalidFormat;\n try {\n const point = Point.fromHex(pub);\n point.assertValidity();\n return {\n result: true,\n reason_data: null,\n reason: null,\n };\n }\n catch (e) {\n return invalidPoint;\n }\n}\nexport function getHexFromBN(bnInput) {\n const hexOut = bnInput.toString(16);\n if (hexOut.length === 64) {\n return hexOut;\n }\n else if (hexOut.length < 64) {\n const padding = '0'.repeat(64 - hexOut.length);\n return `${padding}${hexOut}`;\n }\n else {\n throw new Error('Generated a > 32-byte bigint for encryption. Failing.');\n }\n}\nexport function getBytesFromBN(bnInput) {\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}\nexport function getCipherObjectWrapper(opts) {\n const shell = {\n iv: '',\n ephemeralPK: '',\n mac: '',\n cipherText: '',\n wasString: !!opts.wasString,\n };\n if (opts.cipherTextEncoding === 'base64') {\n shell.cipherTextEncoding = 'base64';\n }\n const ivLength = 32;\n const ephemeralPKLength = 66;\n const macLength = 64;\n return {\n payloadValuesLength: ivLength + ephemeralPKLength + macLength,\n payloadShell: JSON.stringify(shell),\n };\n}\nexport function getSignedCipherObjectWrapper(payloadShell) {\n const shell = {\n signature: '',\n publicKey: '',\n cipherText: payloadShell,\n };\n const signatureLength = 144;\n const publicKeyLength = 66;\n return {\n signedPayloadValuesLength: signatureLength + publicKeyLength,\n signedPayloadShell: JSON.stringify(shell),\n };\n}\nexport function eciesGetJsonStringLength(opts) {\n const { payloadShell, payloadValuesLength } = getCipherObjectWrapper(opts);\n const cipherTextLength = getAesCbcOutputLength(opts.contentLength);\n let encodedCipherTextLength;\n if (!opts.cipherTextEncoding \|\| opts.cipherTextEncoding === 'hex') {\n encodedCipherTextLength = cipherTextLength * 2;\n }\n else if (opts.cipherTextEncoding === 'base64') {\n encodedCipherTextLength = getBase64OutputLength(cipherTextLength);\n }\n else {\n throw new Error(`Unexpected cipherTextEncoding \"${opts.cipherTextEncoding}\"`);\n }\n if (!opts.sign) {\n return payloadShell.length + payloadValuesLength + encodedCipherTextLength;\n }\n else {\n const { signedPayloadShell, signedPayloadValuesLength } = getSignedCipherObjectWrapper(payloadShell);\n return (signedPayloadShell.length +\n signedPayloadValuesLength +\n payloadValuesLength +\n encodedCipherTextLength);\n }\n}\nexport async function encryptECIES(publicKey, content, wasString, cipherTextEncoding) {\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 sharedSecret = sharedSecret.slice(1);\n const sharedKeys = sharedSecretToKeys(sharedSecret);\n const initializationVector = utils.randomBytes(16);\n const cipherText = await aes256CbcEncrypt(initializationVector, sharedKeys.encryptionKey, content);\n const macData = concatBytes(initializationVector, ephemeralPublicKey, cipherText);\n const mac = hmacSha256(sharedKeys.hmacKey, macData);\n let cipherTextString;\n if (!cipherTextEncoding \|\| cipherTextEncoding === 'hex') {\n cipherTextString = bytesToHex(cipherText);\n }\n else if (cipherTextEncoding === 'base64') {\n cipherTextString = fromByteArray(cipherText);\n }\n else {\n throw new Error(`Unexpected cipherTextEncoding \"${cipherTextEncoding}\"`);\n }\n const result = {\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}\nexport async function decryptECIES(privateKey, cipherObject) {\n if (!cipherObject.ephemeralPK) {\n throw new FailedDecryptionError('Unable to get public key from cipher object. ' +\n 'You might be trying to decrypt an unencrypted object.');\n }\n const ephemeralPK = cipherObject.ephemeralPK;\n let sharedSecret = getSharedSecret(privateKey, ephemeralPK, true);\n sharedSecret = sharedSecret.slice(1);\n const sharedKeys = sharedSecretToKeys(sharedSecret);\n const ivBytes = hexToBytes(cipherObject.iv);\n let cipherTextBytes;\n if (!cipherObject.cipherTextEncoding \|\| cipherObject.cipherTextEncoding === 'hex') {\n cipherTextBytes = hexToBytes(cipherObject.cipherText);\n }\n else if (cipherObject.cipherTextEncoding === 'base64') {\n cipherTextBytes = toByteArray(cipherObject.cipherText);\n }\n else {\n throw new Error(`Unexpected cipherTextEncoding \"${cipherObject.cipherText}\"`);\n }\n const macData = concatBytes(ivBytes, hexToBytes(ephemeralPK), cipherTextBytes);\n const actualMac = hmacSha256(sharedKeys.hmacKey, macData);\n const expectedMac = hexToBytes(cipherObject.mac);\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 if (cipherObject.wasString) {\n return bytesToUtf8(plainText);\n }\n return plainText;\n}\nexport function signECDSA(privateKey, content) {\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 return {\n signature: bytesToHex(signature),\n publicKey,\n };\n}\nexport function verifyECDSA(content, publicKey, signature) {\n const contentBytes = typeof content === 'string' ? utf8ToBytes(content) : content;\n const contentHash = hashSha256Sync(contentBytes);\n return verify(signature, contentHash, publicKey, { strict: false });\n}\nexport function verifyMessageSignature({ signature, message, publicKey, }) {\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 const verificationResult = verify(sig, hashedMsg, publicKey, { strict: false });\n if (verificationResult \|\| typeof message !== 'string')\n return verificationResult;\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}\nexport function verifyMessageSignatureRsv({ signature, message, publicKey, }) {\n return verifyMessageSignature({\n signature: signatureRsvToVrs(signature),\n message,\n publicKey,\n });\n}\n//# sourceMappingURL=ec.js.map","import { sha256 } from '@noble/hashes/sha256';\nimport { bytesToHex, concatBytes, hexToBytes } from '@stacks/common';\nimport { ClarityType, serializeCVBytes } from './clarity';\nimport { signMessageHashRsv } from './keys';\nexport const STRUCTURED_DATA_PREFIX = new Uint8Array([0x53, 0x49, 0x50, 0x30, 0x31, 0x38]);\nexport function hashStructuredData(structuredData) {\n return bytesToHex(sha256(serializeCVBytes(structuredData)));\n}\nexport function hashStructuredDataBytes(structuredData) {\n return sha256(serializeCVBytes(structuredData));\n}\nconst hash256BytesLength = 32;\nfunction isDomain(value) {\n if (value.type !== ClarityType.Tuple)\n return false;\n if (!['name', 'version', 'chain-id'].every(key => key in value.value))\n return false;\n if (!['name', 'version'].every(key => value.value[key].type === ClarityType.StringASCII))\n return false;\n if (value.value['chain-id'].type !== ClarityType.UInt)\n return false;\n return true;\n}\nexport function encodeStructuredData(opts) {\n const bytes = encodeStructuredDataBytes(opts);\n return bytesToHex(bytes);\n}\nexport function encodeStructuredDataBytes({ message, domain, }) {\n const structuredDataHash = hashStructuredDataBytes(message);\n if (!isDomain(domain)) {\n throw new Error(\"domain parameter must be a valid domain of type TupleCV with keys 'name', 'version', 'chain-id' with respective types StringASCII, StringASCII, UInt\");\n }\n const domainHash = hashStructuredDataBytes(domain);\n return concatBytes(STRUCTURED_DATA_PREFIX, domainHash, structuredDataHash);\n}\nexport function decodeStructuredDataSignature(signature) {\n const bytes = decodeStructuredDataSignatureBytes(signature);\n return {\n domainHash: bytesToHex(bytes.domainHash),\n messageHash: bytesToHex(bytes.messageHash),\n };\n}\nexport function decodeStructuredDataSignatureBytes(signature) {\n const encodedMessageBytes = typeof signature === 'string' ? hexToBytes(signature) : signature;\n const domainHash = encodedMessageBytes.slice(STRUCTURED_DATA_PREFIX.length, STRUCTURED_DATA_PREFIX.length + hash256BytesLength);\n const messageHash = encodedMessageBytes.slice(STRUCTURED_DATA_PREFIX.length + hash256BytesLength);\n return {\n domainHash,\n messageHash,\n };\n}\nexport function signStructuredData({ message, domain, privateKey, }) {\n const structuredDataHash = bytesToHex(sha256(encodeStructuredDataBytes({ message, domain })));\n return signMessageHashRsv({\n messageHash: structuredDataHash,\n privateKey,\n });\n}\n//# sourceMappingURL=structuredDataSignature.js.map","import { sha256 } from '@noble/hashes/sha256';\nimport { bech32, bech32m } from '@scure/base';\nimport { IntegerType, PrivateKey, bigIntToBytes, bytesToHex, hexToBytes } from '@stacks/common';\nimport {\n base58CheckDecode,\n base58CheckEncode,\n verifyMessageSignatureRsv,\n} from '@stacks/encryption';\nimport { StacksNetwork, StacksNetworkName, StacksNetworks, networkFrom } from '@stacks/network';\nimport {\n BufferCV,\n ClarityType,\n ClarityValue,\n OptionalCV,\n TupleCV,\n bufferCV,\n encodeStructuredDataBytes,\n signStructuredData,\n stringAsciiCV,\n tupleCV,\n uintCV,\n} from '@stacks/transactions';\nimport { PoxOperationInfo } from '.';\nimport {\n B58_ADDR_PREFIXES,\n BitcoinNetworkVersion,\n PoXAddressVersion,\n PoxOperationPeriod,\n SEGWIT_ADDR_PREFIXES,\n SEGWIT_V0,\n SEGWIT_V0_ADDR_PREFIX,\n SEGWIT_V1,\n SEGWIT_V1_ADDR_PREFIX,\n SegwitPrefix,\n StackingErrors,\n} from './constants';\n\nexport class InvalidAddressError extends Error {\n innerError?: Error;\n constructor(address: string, innerError?: Error) {\n const msg = `'${address}' is not a valid P2PKH/P2SH/P2WPKH/P2WSH/P2TR address`;\n super(msg);\n this.message = msg;\n this.name = this.constructor.name;\n this.innerError = innerError;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, this.constructor);\n }\n }\n}\n\n/** @ignore /\nexport function btcAddressVersionToLegacyHashMode(btcAddressVersion: number): PoXAddressVersion {\n switch (btcAddressVersion) {\n case BitcoinNetworkVersion.mainnet.P2PKH:\n return PoXAddressVersion.P2PKH;\n case BitcoinNetworkVersion.testnet.P2PKH:\n return PoXAddressVersion.P2PKH;\n case BitcoinNetworkVersion.mainnet.P2SH:\n return PoXAddressVersion.P2SH;\n case BitcoinNetworkVersion.testnet.P2SH:\n return PoXAddressVersion.P2SH;\n default:\n throw new Error('Invalid pox address version');\n }\n}\n\n/* @ignore /\nfunction nativeAddressToSegwitVersion(\n witnessVersion: number,\n dataLength: number\n): PoXAddressVersion {\n if (witnessVersion === SEGWIT_V0 && dataLength === 20) return PoXAddressVersion.P2WPKH;\n if (witnessVersion === SEGWIT_V0 && dataLength === 32) return PoXAddressVersion.P2WSH;\n if (witnessVersion === SEGWIT_V1 && dataLength === 32) return PoXAddressVersion.P2TR;\n\n throw new Error(\n 'Invalid native segwit witness version and byte length. Currently, only P2WPKH, P2WSH, and P2TR are supported.'\n );\n}\n\n/* @ignore /\nfunction bech32Decode(btcAddress: string) {\n const { words: bech32Words } = bech32.decode(btcAddress);\n const witnessVersion = bech32Words[0];\n\n if (witnessVersion > 0)\n throw new Error('Addresses with a witness version >= 1 should be encoded in bech32m');\n\n return {\n witnessVersion,\n data: bech32.fromWords(bech32Words.slice(1)),\n };\n}\n\n/* @ignore /\nfunction bech32MDecode(btcAddress: string) {\n const { words: bech32MWords } = bech32m.decode(btcAddress);\n const witnessVersion = bech32MWords[0];\n\n if (witnessVersion == 0)\n throw new Error('Addresses with witness version 1 should be encoded in bech32');\n\n return {\n witnessVersion,\n data: bech32m.fromWords(bech32MWords.slice(1)),\n };\n}\n\n/* @ignore /\nfunction decodeNativeSegwitBtcAddress(btcAddress: string): {\n witnessVersion: number;\n data: Uint8Array;\n} {\n if (SEGWIT_V0_ADDR_PREFIX.test(btcAddress)) return bech32Decode(btcAddress);\n if (SEGWIT_V1_ADDR_PREFIX.test(btcAddress)) return bech32MDecode(btcAddress);\n throw new Error(\n `Native segwit address ${btcAddress} does not match valid prefix ${SEGWIT_V0_ADDR_PREFIX} or ${SEGWIT_V1_ADDR_PREFIX}`\n );\n}\n\nexport function decodeBtcAddress(btcAddress: string): {\n version: PoXAddressVersion;\n data: string;\n} {\n const { version, data } = decodeBtcAddressBytes(btcAddress);\n return { version, data: bytesToHex(data) };\n}\n\nexport function decodeBtcAddressBytes(btcAddress: string): {\n version: PoXAddressVersion;\n data: Uint8Array;\n} {\n try {\n if (B58_ADDR_PREFIXES.test(btcAddress)) {\n const b58 = base58CheckDecode(btcAddress);\n const addressVersion = btcAddressVersionToLegacyHashMode(b58.version);\n return {\n version: addressVersion,\n data: b58.hash,\n };\n } else if (SEGWIT_ADDR_PREFIXES.test(btcAddress)) {\n const b32 = decodeNativeSegwitBtcAddress(btcAddress);\n const addressVersion = nativeAddressToSegwitVersion(b32.witnessVersion, b32.data.length);\n return {\n version: addressVersion,\n data: b32.data,\n };\n }\n throw new Error('Unknown BTC address prefix.');\n } catch (error) {\n throw new InvalidAddressError(btcAddress, error as Error);\n }\n}\n\nexport function extractPoxAddressFromClarityValue(poxAddrClarityValue: ClarityValue): {\n version: number;\n hashBytes: Uint8Array;\n} {\n const clarityValue = poxAddrClarityValue as TupleCV;\n if (clarityValue.type !== ClarityType.Tuple \|\| !clarityValue.value) {\n throw new Error('Invalid argument, expected ClarityValue to be a TupleCV');\n }\n if (!('version' in clarityValue.value) \|\| !('hashbytes' in clarityValue.value)) {\n throw new Error(\n 'Invalid argument, expected Clarity tuple value to contain `version` and `hashbytes` keys'\n );\n }\n const versionCV = clarityValue.value['version'] as BufferCV;\n const hashBytesCV = clarityValue.value['hashbytes'] as BufferCV;\n if (versionCV.type !== ClarityType.Buffer \|\| hashBytesCV.type !== ClarityType.Buffer) {\n throw new Error(\n 'Invalid argument, expected Clarity tuple value to contain `version` and `hashbytes` buffers'\n );\n }\n return {\n version: hexToBytes(versionCV.value)[0],\n hashBytes: hexToBytes(hashBytesCV.value),\n };\n}\n\nexport function getErrorString(error: StackingErrors): string {\n switch (error) {\n case StackingErrors.ERR_STACKING_UNREACHABLE:\n return 'Stacking unreachable';\n case StackingErrors.ERR_STACKING_CORRUPTED_STATE:\n return 'Stacking state is corrupted';\n case StackingErrors.ERR_STACKING_INSUFFICIENT_FUNDS:\n return 'Insufficient funds';\n case StackingErrors.ERR_STACKING_INVALID_LOCK_PERIOD:\n return 'Invalid lock period';\n case StackingErrors.ERR_STACKING_ALREADY_STACKED:\n return 'Account already stacked. Concurrent stacking not allowed.';\n case StackingErrors.ERR_STACKING_NO_SUCH_PRINCIPAL:\n return 'Principal does not exist';\n case StackingErrors.ERR_STACKING_EXPIRED:\n return 'Stacking expired';\n case StackingErrors.ERR_STACKING_STX_LOCKED:\n return 'STX balance is locked';\n case StackingErrors.ERR_STACKING_PERMISSION_DENIED:\n return 'Permission denied';\n case StackingErrors.ERR_STACKING_THRESHOLD_NOT_MET:\n return 'Stacking threshold not met';\n case StackingErrors.ERR_STACKING_POX_ADDRESS_IN_USE:\n return 'PoX address already in use';\n case StackingErrors.ERR_STACKING_INVALID_POX_ADDRESS:\n return 'Invalid PoX address';\n case StackingErrors.ERR_STACKING_ALREADY_REJECTED:\n return 'Stacking already rejected';\n case StackingErrors.ERR_STACKING_INVALID_AMOUNT:\n return 'Invalid amount';\n case StackingErrors.ERR_NOT_ALLOWED:\n return 'Stacking not allowed';\n case StackingErrors.ERR_STACKING_ALREADY_DELEGATED:\n return 'Already delegated';\n case StackingErrors.ERR_DELEGATION_EXPIRES_DURING_LOCK:\n return 'Delegation expires during lock period';\n case StackingErrors.ERR_DELEGATION_TOO_MUCH_LOCKED:\n return 'Delegation too much locked';\n case StackingErrors.ERR_DELEGATION_POX_ADDR_REQUIRED:\n return 'PoX address required for delegation';\n case StackingErrors.ERR_INVALID_START_BURN_HEIGHT:\n return 'Invalid start burn height';\n case StackingErrors.ERR_NOT_CURRENT_STACKER: // not used in pox contract\n return 'ERR_NOT_CURRENT_STACKER';\n case StackingErrors.ERR_STACK_EXTEND_NOT_LOCKED:\n return 'Stacker must be currently locked';\n case StackingErrors.ERR_STACK_INCREASE_NOT_LOCKED:\n return 'Stacker must be currently locked';\n case StackingErrors.ERR_DELEGATION_NO_REWARD_SLOT:\n return 'Invalid reward-cycle and reward-cycle-index';\n case StackingErrors.ERR_DELEGATION_WRONG_REWARD_SLOT:\n return 'PoX address must match the one on record';\n case StackingErrors.ERR_STACKING_IS_DELEGATED:\n return 'Stacker must be directly stacking and not delegating';\n case StackingErrors.ERR_STACKING_NOT_DELEGATED:\n return 'Stacker must be delegating and not be directly stacking';\n }\n}\n/\n Converts a PoX address to a tuple (e.g. to be used in a Clarity contract call).\n \n @param poxAddress - The PoX bitcoin address to be converted.\n * @returns The converted PoX address as a tuple of version and hashbytes.\n /\nexport function poxAddressToTuple(poxAddress: string) {\n const { version, data } = decodeBtcAddressBytes(poxAddress);\n const versionBuff = bufferCV(bigIntToBytes(BigInt(version), 1));\n const hashBuff = bufferCV(data);\n return tupleCV({\n version: versionBuff,\n hashbytes: hashBuff,\n });\n}\n\nfunction legacyHashModeToBtcAddressVersion(\n hashMode: PoXAddressVersion,\n network: StacksNetworkName\n): number {\n switch (hashMode) {\n case PoXAddressVersion.P2PKH:\n return BitcoinNetworkVersion[network].P2PKH;\n case PoXAddressVersion.P2SH:\n case PoXAddressVersion.P2SHP2WPKH:\n case PoXAddressVersion.P2SHP2WSH:\n // P2SHP2WPKH and P2SHP2WSH are treated as P2SH for the sender\n return BitcoinNetworkVersion[network].P2SH;\n default:\n throw new Error('Invalid pox address version');\n }\n}\n\nfunction _poxAddressToBtcAddress_Values(\n version: number,\n hash: string \| Uint8Array,\n network: StacksNetworkName\n): string {\n if (!StacksNetworks.includes(network)) throw new Error('Invalid network.');\n\n if (typeof hash === 'string') hash = hexToBytes(hash);\n\n switch (version) {\n case PoXAddressVersion.P2PKH:\n case PoXAddressVersion.P2SH:\n case PoXAddressVersion.P2SHP2WPKH:\n case PoXAddressVersion.P2SHP2WSH: {\n const btcAddrVersion = legacyHashModeToBtcAddressVersion(version, network);\n return base58CheckEncode(btcAddrVersion, hash);\n }\n case PoXAddressVersion.P2WPKH:\n case PoXAddressVersion.P2WSH: {\n const words = bech32.toWords(hash);\n return bech32.encode(SegwitPrefix[network], [SEGWIT_V0, ...words]);\n }\n case PoXAddressVersion.P2TR: {\n const words = bech32m.toWords(hash);\n return bech32m.encode(SegwitPrefix[network], [SEGWIT_V1, ...words]);\n }\n }\n throw new Error(`Unexpected address version: ${version}`);\n}\n\nfunction _poxAddressToBtcAddress_ClarityValue(\n poxAddrClarityValue: ClarityValue,\n network: StacksNetworkName\n): string {\n const poxAddr = extractPoxAddressFromClarityValue(poxAddrClarityValue);\n return _poxAddressToBtcAddress_Values(poxAddr.version, poxAddr.hashBytes, network);\n}\n\n/\n Converts a PoX address to a Bitcoin address.\n \n @param version - The version of the PoX address (as a single number, not a Uint8array).\n * @param hash - The hash bytes of the PoX address.\n * @param network - The network the PoX address is on.\n * @returns The corresponding Bitcoin address.\n /\nexport function poxAddressToBtcAddress(\n version: number,\n hash: string \| Uint8Array,\n network: StacksNetworkName // todo: allow NetworkParam in the future (minor)\n): string;\n/\n Converts a PoX address to a Bitcoin address.\n \n @param poxAddrClarityValue - The clarity tuple of the PoX address (version and hashbytes).\n * @param network - The network the PoX address is on.\n * @returns The corresponding Bitcoin address.\n /\nexport function poxAddressToBtcAddress(\n poxAddrClarityValue: ClarityValue,\n network: StacksNetworkName\n): string;\nexport function poxAddressToBtcAddress(...args: any[]): string {\n // todo: allow these helpers to take a bitcoin network instead of a stacks network, once we have a concept of bitcoin networks in the codebase\n if (typeof args[0] === 'number') return _poxAddressToBtcAddress_Values(args[0], args[1], args[2]);\n return _poxAddressToBtcAddress_ClarityValue(args[0], args[1]);\n}\n\n// todo: move unwrap to tx package and document\nexport function unwrap<T extends ClarityValue>(optional: OptionalCV<T>) {\n if (optional.type === ClarityType.OptionalSome) return optional.value;\n if (optional.type === ClarityType.OptionalNone) return undefined;\n throw new Error(\"Object is not an 'Optional'\");\n}\n\nexport function unwrapMap<T extends ClarityValue, U>(optional: OptionalCV<T>, map: (t: T) => U) {\n if (optional.type === ClarityType.OptionalSome) return map(optional.value);\n if (optional.type === ClarityType.OptionalNone) return undefined;\n throw new Error(\"Object is not an 'Optional'\");\n}\n\n/* @internal /\nexport function ensurePox2Activated(operationInfo: PoxOperationInfo) {\n if (operationInfo.period === PoxOperationPeriod.Period1)\n throw new Error(\n `PoX-2 has not activated yet (currently in period ${operationInfo.period} of PoX-2 operation)`\n );\n}\n\n/\n @internal\n * Throws if the given PoX address is not a legacy address for PoX-1.\n /\nexport function ensureLegacyBtcAddressForPox1({\n contract,\n poxAddress,\n}: {\n contract: string;\n poxAddress?: string;\n}) {\n if (!poxAddress) return;\n if (contract.endsWith('.pox') && !B58_ADDR_PREFIXES.test(poxAddress)) {\n throw new Error('PoX-1 requires P2PKH/P2SH/P2SH-P2WPKH/P2SH-P2WSH bitcoin addresses');\n }\n}\n\n/\n @internal\n * Throws if signer args are given for <= PoX-3 or the signer args are missing otherwise.\n /\nexport function ensureSignerArgsReadiness({\n contract,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n}: {\n contract: string;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n}) {\n const hasMaxAmount = typeof maxAmount !== 'undefined';\n const hasAuthId = typeof authId !== 'undefined';\n if (/\\.pox(-[2-3])?$/.test(contract)) {\n // .pox, .pox-2 or .pox-3\n if (signerKey \|\| signerSignature \|\| hasMaxAmount \|\| hasAuthId) {\n throw new Error(\n 'PoX-1, PoX-2 and PoX-3 do not accept a `signerKey`, `signerSignature`, `maxAmount` or `authId`'\n );\n }\n } else {\n // .pox-4 or later\n if (!signerKey \|\| !hasMaxAmount \|\| typeof authId === 'undefined') {\n throw new Error(\n 'PoX-4 requires a `signerKey` (buff 33), `maxAmount` (uint), and `authId` (uint)'\n );\n }\n }\n}\n\nexport enum Pox4SignatureTopic {\n StackStx = 'stack-stx',\n AggregateCommit = 'agg-commit',\n AggregateIncrease = 'agg-increase',\n StackExtend = 'stack-extend',\n StackIncrease = 'stack-increase',\n}\n\nexport interface Pox4SignatureOptions {\n /* topic of the signature (i.e. which stacking operation the signature is used for) /\n topic: `${Pox4SignatureTopic}` \| Pox4SignatureTopic;\n poxAddress: string;\n /* current reward cycle /\n rewardCycle: number;\n /* lock period (in cycles) /\n period: number;\n network: StacksNetworkName \| StacksNetwork;\n /* Maximum amount of uSTX that can be locked during this function call /\n maxAmount: IntegerType;\n /* Random integer to prevent signature re-use /\n authId: IntegerType;\n}\n\n/\n Generate a signature (`signer-sig` in PoX-4 stacking operations).\n /\nexport function signPox4SignatureHash({\n topic,\n poxAddress,\n rewardCycle,\n period,\n network,\n privateKey,\n maxAmount,\n authId,\n}: Pox4SignatureOptions & { privateKey: PrivateKey }) {\n return signStructuredData({\n ...pox4SignatureMessage({ topic, poxAddress, rewardCycle, period, network, maxAmount, authId }),\n privateKey,\n });\n}\n\n/\n Verify a signature (`signer-sig` in PoX-4 stacking operations) matches the given\n * public key (`signer-key`) and the structured data of the operation.\n /\nexport function verifyPox4SignatureHash({\n topic,\n poxAddress,\n rewardCycle,\n period,\n network,\n publicKey,\n signature,\n maxAmount,\n authId,\n}: Pox4SignatureOptions & { publicKey: string; signature: string }) {\n return verifyMessageSignatureRsv({\n message: sha256(\n encodeStructuredDataBytes(\n pox4SignatureMessage({ topic, poxAddress, rewardCycle, period, network, maxAmount, authId })\n )\n ),\n publicKey,\n signature,\n });\n}\n\n/\n Helper method used to generate SIP018 `message` and `domain` in\n * {@link signPox4SignatureHash} and {@link verifyPox4SignatureHash}.\n /\nexport function pox4SignatureMessage({\n topic,\n poxAddress,\n rewardCycle,\n period: lockPeriod,\n network: networkOrName,\n maxAmount,\n authId,\n}: Pox4SignatureOptions) {\n const network = networkFrom(networkOrName);\n const message = tupleCV({\n 'pox-addr': poxAddressToTuple(poxAddress),\n 'reward-cycle': uintCV(rewardCycle),\n topic: stringAsciiCV(topic),\n period: uintCV(lockPeriod),\n 'max-amount': uintCV(maxAmount),\n 'auth-id': uintCV(authId),\n });\n const domain = tupleCV({\n name: stringAsciiCV('pox-4-signer'),\n version: stringAsciiCV('1.0.0'),\n 'chain-id': uintCV(network.chainId),\n });\n return { message, domain };\n}\n","import { ClientOpts, IntegerType, PrivateKey, hexToBytes, intToBigInt } from '@stacks/common';\nimport {\n ChainId,\n NetworkClientParam,\n StacksNetwork,\n clientFromNetwork,\n networkFrom,\n} from '@stacks/network';\nimport {\n BurnchainRewardListResponse,\n BurnchainRewardSlotHolderListResponse,\n BurnchainRewardsTotal,\n} from '@stacks/stacks-blockchain-api-types';\nimport type { ContractIdString } from '@stacks/transactions';\nimport {\n BufferCV,\n ClarityType,\n ClarityValue,\n ContractCallOptions,\n ContractCallPayload,\n OptionalCV,\n PrincipalCV,\n ResponseErrorCV,\n StacksTransactionWire,\n TupleCV,\n TxBroadcastResult,\n UIntCV,\n broadcastTransaction,\n bufferCV,\n cvToString,\n fetchCallReadOnlyFunction,\n getFee,\n makeContractCall,\n noneCV,\n principalCV,\n someCV,\n stringAsciiCV,\n uintCV,\n validateStacksAddress,\n} from '@stacks/transactions';\nimport { PoxOperationPeriod, StackingErrors } from './constants';\nimport {\n Pox4SignatureTopic,\n ensureLegacyBtcAddressForPox1,\n ensurePox2Activated,\n ensureSignerArgsReadiness,\n poxAddressToTuple,\n signPox4SignatureHash,\n unwrap,\n unwrapMap,\n} from './utils';\n\nexport from './utils';\n\n/** @internal /\ninterface BaseTxOptions {\n /* the fee for the transaction /\n fee?: IntegerType;\n /* the nonce for the transaction /\n nonce?: IntegerType;\n /* the private key (aka `senderkey`) for the transaction /\n privateKey: string;\n}\n\nexport interface CycleInfo {\n id: number;\n min_threshold_ustx: number;\n stacked_ustx: number;\n is_pox_active: boolean;\n}\n\nexport interface ContractVersion {\n contract_id: string;\n activation_burnchain_block_height: number;\n first_reward_cycle_id: number;\n}\n\nexport interface PoxInfo {\n contract_id: string;\n contract_versions: ContractVersion[];\n current_burnchain_block_height?: number;\n first_burnchain_block_height: number;\n min_amount_ustx: string;\n next_reward_cycle_in: number;\n prepare_cycle_length: number;\n prepare_phase_block_length: number;\n reward_cycle_id: number;\n reward_cycle_length: number;\n reward_phase_block_length: number;\n reward_slots: number;\n current_cycle: CycleInfo;\n next_cycle: CycleInfo & {\n min_increment_ustx: number;\n prepare_phase_start_block_height: number;\n blocks_until_prepare_phase: number;\n reward_phase_start_block_height: number;\n blocks_until_reward_phase: number;\n ustx_until_pox_rejection: number;\n };\n}\n\nexport type PoxOperationInfo = {\n /* @deprecated Period isn't needed anymore after 2.1 fork went live /\n period: PoxOperationPeriod;\n pox1: { contract_id: string };\n pox2: ContractVersion;\n pox3: ContractVersion;\n pox4: ContractVersion;\n current: ContractVersion;\n};\n\nexport type StackerInfo =\n \| {\n stacked: false;\n }\n \| {\n stacked: true;\n details: {\n first_reward_cycle: number;\n lock_period: number;\n unlock_height: number;\n pox_address: {\n version: Uint8Array;\n hashbytes: Uint8Array;\n };\n };\n };\n\nexport type DelegationInfo =\n \| {\n delegated: false;\n }\n \| {\n delegated: true;\n details: {\n amount_micro_stx: bigint;\n delegated_to: string;\n pox_address?: {\n version: number;\n hashbytes: Uint8Array;\n };\n until_burn_ht?: number;\n };\n };\n\nexport interface RewardSetOptions {\n contractId: string;\n rewardCyleId: number;\n rewardSetIndex: number;\n}\n\nexport interface RewardSetInfo {\n pox_address: {\n version: Uint8Array;\n hashbytes: Uint8Array;\n };\n total_ustx: bigint;\n}\n\nexport interface StackingEligibility {\n eligible: boolean;\n reason?: string;\n}\n\n/\n Lock stx check options\n /\nexport interface CanLockStxOptions {\n /* the reward Bitcoin address /\n poxAddress: string;\n /* number of cycles to lock /\n cycles: number;\n}\n\n/\n Lock stx options\n /\nexport interface LockStxOptions {\n /* private key to sign transaction /\n privateKey: string;\n /* number of cycles to lock /\n cycles: number;\n /* the reward Bitcoin address /\n poxAddress: string;\n /* number of microstacks to lock /\n amountMicroStx: IntegerType;\n /* the burnchain block height to begin lock /\n burnBlockHeight: number;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\n/\n Stack extend stx options\n /\nexport interface StackExtendOptions {\n /* private key to sign transaction /\n privateKey: string;\n /* number of cycles to extend by /\n extendCycles: number;\n /* the reward Bitcoin address /\n poxAddress: string;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\n/\n Stack increase stx options\n /\nexport interface StackIncreaseOptions {\n /* private key to sign transaction /\n privateKey: string;\n /* number of ustx to increase by /\n increaseBy: IntegerType;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\n/\n Delegate stx options\n /\nexport interface DelegateStxOptions {\n /* number of microstacks to delegate /\n amountMicroStx: IntegerType;\n /* the STX address of the delegatee /\n delegateTo: string;\n /* the burnchain block height after which delegation is revoked /\n untilBurnBlockHeight?: number;\n /* the reward Bitcoin address of the delegator /\n poxAddress?: string;\n /* private key to sign transaction /\n privateKey: string;\n}\n\n/\n Delegate stack stx options\n /\nexport interface DelegateStackStxOptions {\n /* private key to sign transaction /\n privateKey: string;\n /* the STX address of the delegator /\n stacker: string;\n /* number of microstacks to lock /\n amountMicroStx: IntegerType;\n /* the reward Bitcoin address of the delegator /\n poxAddress: string;\n /* the burnchain block height to begin lock /\n burnBlockHeight: number;\n /* number of cycles to lock /\n cycles: number;\n}\n\n/\n Delegate stack extend options\n /\nexport interface DelegateStackExtendOptions {\n /* the STX address of the delegator /\n stacker: string;\n /* the reward Bitcoin address of the delegator /\n poxAddress: string;\n /* number of cycles to extend by /\n extendCount: number;\n /* private key to sign transaction /\n privateKey: string;\n}\n\n/\n Delegate stack increase options\n /\nexport interface DelegateStackIncreaseOptions {\n /* the STX address of the delegator /\n stacker: string;\n /* the reward Bitcoin address of the delegator /\n poxAddress: string;\n /* number of ustx to increase by /\n increaseBy: IntegerType;\n /* private key to sign transaction /\n privateKey: string;\n /* nonce for the transaction /\n nonce?: IntegerType;\n}\n\nexport interface StackAggregationCommitOptions {\n poxAddress: string;\n rewardCycle: number;\n privateKey: string;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\nexport interface StackAggregationIncreaseOptions {\n poxAddress: string;\n rewardCycle: number;\n rewardIndex: number;\n privateKey: string;\n /* hex-encoded signer key `(buff 33)`, required for >= PoX-4 /\n signerKey?: string;\n /* hex-encoded signature `(buff 65)`, required for >= PoX-4 /\n signerSignature?: string;\n /* Maximum amount of STX that can be locked in this transaction, required for >= PoX-4 /\n maxAmount?: IntegerType;\n /* Random integer to prevent re-use of signer signature, required for >= PoX-4 /\n authId?: IntegerType;\n}\n\nexport class StackingClient {\n public address: string;\n public network: StacksNetwork;\n\n public client: Required<ClientOpts>;\n\n // todo: make more constructor opts optional\n constructor(opts: { address: string } & NetworkClientParam) {\n this.address = opts.address;\n this.network = networkFrom(opts.network ?? 'mainnet');\n this.client = Object.assign({}, clientFromNetwork(this.network), opts.client);\n }\n\n get baseUrl() {\n return this.client.baseUrl;\n }\n\n get fetch() {\n return this.client.fetch;\n }\n\n /* @deprecated Kept for backwards compatibility, may be removed in the future /\n getCoreInfo(): Promise<V2CoreInfoResponse> {\n return this.client.fetch(`${this.client.baseUrl}/v2/info`).then(res => res.json());\n }\n\n /* @deprecated Kept for backwards compatibility, may be removed in the future /\n getPoxInfo(): Promise<V2PoxInfoResponse> {\n return this.client.fetch(`${this.client.baseUrl}/v2/pox`).then(res => res.json());\n }\n\n /* @deprecated Kept for backwards compatibility, may be removed in the future /\n async getTargetBlockTime(): Promise<number> {\n const res = await this.client\n .fetch(`${this.client.baseUrl}/extended/v1/info/network_block_times`)\n .then((res: any): V1InfoBlockTimesResponse => res.json());\n\n if (this.network.chainId === ChainId.Mainnet) return res.mainnet.target_block_time;\n return res.testnet.target_block_time;\n }\n\n /* Get account status /\n async getAccountStatus(): Promise<any> {\n // todo: add types for response\n return this.client\n .fetch(`${this.client.baseUrl}/v2/accounts/${this.address}?proof=0`)\n .then(res => res.json())\n .then(json => {\n json.balance = BigInt(json.balance);\n json.locked = BigInt(json.locked);\n return json;\n });\n }\n\n /* Get account balance /\n async getAccountBalance(): Promise<bigint> {\n return this.getAccountStatus().then(a => a.balance);\n }\n\n /* Get extended account balances /\n async getAccountExtendedBalances(): Promise<ExtendedAccountBalances> {\n return this.client\n .fetch(`${this.client.baseUrl}/extended/v1/address/${this.address}/balances`)\n .then(res => res.json())\n .then(json => {\n json.stx.balance = BigInt(json.stx.balance);\n json.stx.total_sent = BigInt(json.stx.total_sent);\n json.stx.total_received = BigInt(json.stx.total_received);\n json.stx.locked = BigInt(json.stx.locked);\n return json;\n });\n }\n\n /* Get account balance of locked tokens /\n async getAccountBalanceLocked(): Promise<bigint> {\n return this.getAccountStatus().then(a => a.locked);\n }\n\n /* Get reward cycle duration in seconds /\n async getCycleDuration(): Promise<number> {\n const poxInfoPromise = this.getPoxInfo();\n const targetBlockTimePromise = await this.getTargetBlockTime();\n\n return Promise.all([poxInfoPromise, targetBlockTimePromise]).then(\n ([poxInfo, targetBlockTime]) => {\n return poxInfo.reward_cycle_length targetBlockTime;\n }\n );\n }\n\n /** Get the total burnchain rewards total for the set address /\n async getRewardsTotalForBtcAddress(): Promise<BurnchainRewardsTotal \| BaseErrorResponse> {\n return this.client\n .fetch(`${this.client.baseUrl}/extended/v1/burnchain/rewards/${this.address}/total`)\n .then(res => res.json())\n .then(json => {\n json.reward_amount = BigInt(json.reward_amount);\n return json;\n });\n }\n\n /* Get burnchain rewards for the set address /\n async getRewardsForBtcAddress(\n options?: PaginationOptions\n ): Promise<BurnchainRewardListResponse \| BaseErrorResponse> {\n let url = `${this.client.baseUrl}/extended/v1/burnchain/rewards/${this.address}`;\n if (options) url += `?limit=${options.limit}&offset=${options.offset}`;\n\n return this.client.fetch(url).then(res => res.json());\n }\n\n /* Get burnchain rewards holders for the set address /\n async getRewardHoldersForBtcAddress(\n options?: PaginationOptions\n ): Promise<BurnchainRewardSlotHolderListResponse \| BaseErrorResponse> {\n let url = `${this.client.baseUrl}/extended/v1/burnchain/reward_slot_holders/${this.address}`;\n if (options) url += `?limit=${options.limit}&offset=${options.offset}`;\n\n return this.client.fetch(url).then(res => res.json());\n }\n\n /* Get PoX address from reward set by index (if it exists) /\n async getRewardSet(options: RewardSetOptions): Promise<RewardSetInfo \| undefined> {\n const [contractAddress, contractName] = this.parseContractId(options?.contractId);\n const result = await fetchCallReadOnlyFunction({\n client: this.client,\n senderAddress: this.address,\n contractAddress,\n contractName,\n functionArgs: [uintCV(options.rewardCyleId), uintCV(options.rewardSetIndex)],\n functionName: 'get-reward-set-pox-address',\n });\n\n return unwrapMap(result as OptionalCV<TupleCV>, tuple => ({\n pox_address: {\n version: hexToBytes(\n ((tuple.value['pox-addr'] as TupleCV).value['version'] as BufferCV).value\n ),\n hashbytes: hexToBytes(\n ((tuple.value['pox-addr'] as TupleCV).value['hashbytes'] as BufferCV).value\n ),\n },\n total_ustx: BigInt((tuple.value['total-ustx'] as UIntCV).value),\n }));\n }\n\n /\n Get number of seconds until next reward cycle\n * @see {@link getSecondsUntilStackingDeadline}\n /\n async getSecondsUntilNextCycle(): Promise<number> {\n const poxInfoPromise = this.getPoxInfo();\n const targetBlockTimePromise = this.getTargetBlockTime();\n const coreInfoPromise = this.getCoreInfo();\n\n return Promise.all([poxInfoPromise, targetBlockTimePromise, coreInfoPromise]).then(\n ([poxInfo, targetBlockTime, coreInfo]) => {\n const blocksToNextCycle =\n poxInfo.reward_cycle_length -\n ((coreInfo.burn_block_height - poxInfo.first_burnchain_block_height) %\n poxInfo.reward_cycle_length);\n return blocksToNextCycle targetBlockTime;\n }\n );\n }\n\n /*\n Get number of seconds until the end of the stacking deadline.\n * This is the estimated time stackers have to submit their stacking\n * transactions to be included in the upcoming reward cycle.\n * @returns number of seconds\n * ⚠️ Attention: The returned number of seconds can be negative if the deadline has passed and the prepare phase has started.\n * @see {@link getSecondsUntilNextCycle}\n /\n async getSecondsUntilStackingDeadline(): Promise<number> {\n const poxInfoPromise = this.getPoxInfo();\n const targetBlockTimePromise = this.getTargetBlockTime();\n\n return Promise.all([poxInfoPromise, targetBlockTimePromise]).then(\n ([poxInfo, targetBlockTime]) =>\n poxInfo.next_cycle.blocks_until_prepare_phase targetBlockTime\n );\n }\n\n /*\n Get information on current PoX operation\n \n Periods:\n * - Period 1: This is before the 2.1 fork.\n * - Period 2: This is after the 2.1 fork, but before cycle (N+1).\n * - Period 3: This is after cycle (N+1) has begun. Original PoX contract state will no longer have any impact on reward sets, account lock status, etc.\n /\n async getPoxOperationInfo(poxInfo?: V2PoxInfoResponse): Promise<PoxOperationInfo> {\n poxInfo = poxInfo ?? (await this.getPoxInfo());\n\n const poxContractVersions = [...poxInfo.contract_versions].sort(\n (a, b) => a.activation_burnchain_block_height - b.activation_burnchain_block_height\n ); // by activation height ASC (earliest first)\n const [pox1, pox2, pox3, pox4] = poxContractVersions;\n\n const activatedPoxs = poxContractVersions.filter(\n (c: ContractVersionResponse) =>\n (poxInfo?.current_burnchain_block_height as number) >= c.activation_burnchain_block_height\n );\n const current = activatedPoxs[activatedPoxs.length - 1];\n\n return { period: PoxOperationPeriod.Period3, pox1, pox2, pox3, pox4, current };\n }\n\n /\n Check if account has minimum require amount of Stacks for stacking\n * @returns {Promise<boolean>} that resolves to a bool if the operation succeeds\n /\n async hasMinimumStx(): Promise<boolean> {\n const balance = await this.getAccountBalance();\n const min = BigInt((await this.getPoxInfo()).min_amount_ustx);\n return balance >= min;\n }\n\n /\n readonly `can-stack-stx`\n \n Check if account can lock stx\n * @param {CanLockStxOptions} options - a required lock STX options object\n * @returns {Promise<StackingEligibility>} that resolves to a StackingEligibility object if the operation succeeds\n /\n async canStack({ poxAddress, cycles }: CanLockStxOptions): Promise<StackingEligibility> {\n const balancePromise: Promise<bigint> = this.getAccountBalance();\n const poxInfoPromise = this.getPoxInfo();\n\n return Promise.all([balancePromise, poxInfoPromise])\n .then(([balance, poxInfo]) => {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(poxInfo.contract_id);\n\n return fetchCallReadOnlyFunction({\n client: this.client,\n contractName,\n contractAddress,\n functionName: 'can-stack-stx',\n senderAddress: this.address,\n functionArgs: [\n address,\n uintCV(balance.toString()),\n uintCV(poxInfo.reward_cycle_id),\n uintCV(cycles.toString()),\n ],\n });\n })\n .then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.ResponseOk) {\n return {\n eligible: true,\n };\n } else {\n const errorCV = responseCV as ResponseErrorCV;\n return {\n eligible: false,\n reason: StackingErrors[+cvToString(errorCV.value)],\n };\n }\n });\n }\n\n /\n `stack-stx`\n \n Generate and broadcast a stacking transaction to lock STX\n * @param {LockStxOptions} options - a required lock STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async stack({\n amountMicroStx,\n poxAddress,\n cycles,\n burnBlockHeight,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: LockStxOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n\n const contract = await this.getStackingContract(poxOperationInfo);\n\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n ensureSignerArgsReadiness({ contract, signerKey, signerSignature, maxAmount, authId });\n\n const callOptions = this.getStackOptions({\n contract,\n amountMicroStx,\n cycles,\n poxAddress,\n burnBlockHeight,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n `stack-extend`\n \n Generate and broadcast a stacking transaction to extend locked STX (`pox-2.stack-extend`)\n * @category PoX-2\n * @param {StackExtendOptions} - a required extend STX options object\n * @returns a broadcasted txid if the operation succeeds\n /\n async stackExtend({\n extendCycles,\n poxAddress,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackExtendOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n\n ensurePox2Activated(poxOperationInfo);\n ensureSignerArgsReadiness({\n contract: poxInfo.contract_id,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n\n const callOptions = this.getStackExtendOptions({\n contract: poxInfo.contract_id,\n extendCycles,\n poxAddress,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n Generate and broadcast a stacking transaction to increase locked STX (`pox-2.stack-increase`)\n * @category PoX-2\n * @param {StackIncreaseOptions} - a required increase STX options object\n * @returns a broadcasted txid if the operation succeeds\n /\n async stackIncrease({\n increaseBy,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackIncreaseOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n ensurePox2Activated(poxOperationInfo);\n ensureSignerArgsReadiness({\n contract: poxInfo.contract_id,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n\n const callOptions = this.getStackIncreaseOptions({\n contract: poxInfo.contract_id,\n increaseBy,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n `delegate-stx`\n \n As a delegatee, generate and broadcast a transaction to create a delegation relationship\n * @param {DelegateStxOptions} options - a required delegate STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async delegateStx({\n amountMicroStx,\n delegateTo,\n untilBurnBlockHeight,\n poxAddress,\n ...txOptions\n }: // todo: should we provide manual contract definitions? (for users to choose which contract to use)\n DelegateStxOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n\n const contract = await this.getStackingContract(poxOperationInfo);\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n\n const callOptions = this.getDelegateOptions({\n contract,\n amountMicroStx,\n delegateTo,\n untilBurnBlockHeight,\n poxAddress,\n });\n\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n `delegate-stack-stx`\n \n As a delegator, generate and broadcast transactions to stack for multiple delegatees. This will lock up tokens owned by the delegatees.\n * @param {DelegateStackStxOptions} options - a required delegate stack STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async delegateStackStx({\n stacker,\n amountMicroStx,\n poxAddress,\n burnBlockHeight,\n cycles,\n ...txOptions\n }: DelegateStackStxOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n\n const contract = await this.getStackingContract(poxOperationInfo);\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n\n const callOptions = this.getDelegateStackOptions({\n contract,\n stacker,\n amountMicroStx,\n poxAddress,\n burnBlockHeight,\n cycles,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n `delegate-stack-extend`\n \n As a delegator, generate and broadcast transactions to extend stack for multiple delegatees.\n * @category PoX-2\n * @param {DelegateStackExtendOptions} options - a required delegate stack extend STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async delegateStackExtend({\n stacker,\n poxAddress,\n extendCount,\n ...txOptions\n }: DelegateStackExtendOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const contract = poxInfo.contract_id;\n\n const callOptions = this.getDelegateStackExtendOptions({\n contract,\n stacker,\n poxAddress,\n extendCount,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegator, generate and broadcast transactions to stack increase for multiple delegatees.\n * @category PoX-2\n * @param {DelegateStackIncreaseOptions} - a required delegate stack increase STX options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async delegateStackIncrease({\n stacker,\n poxAddress,\n increaseBy,\n ...txOptions\n }: DelegateStackIncreaseOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const poxInfo = await this.getPoxInfo();\n const poxOperationInfo = await this.getPoxOperationInfo(poxInfo);\n ensurePox2Activated(poxOperationInfo);\n\n const callOptions = this.getDelegateStackIncreaseOptions({\n contract: poxInfo.contract_id,\n stacker,\n poxAddress,\n increaseBy,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegator, generate and broadcast a transaction to commit partially committed delegatee tokens\n * @param {StackAggregationCommitOptions} options - a required stack aggregation commit options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async stackAggregationCommit({\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackAggregationCommitOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const contract = await this.getStackingContract();\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n ensureSignerArgsReadiness({ contract, signerKey, signerSignature, maxAmount, authId });\n\n const callOptions = this.getStackAggregationCommitOptions({\n contract,\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegator, generate and broadcast a transaction to commit partially committed delegatee tokens\n \n Commit partially stacked STX and allocate a new PoX reward address slot.\n * This allows a stacker/delegate to lock fewer STX than the minimal threshold in multiple transactions,\n * so long as: 1. The pox-addr is the same.\n * 2. This \"commit\" transaction is called _before_ the PoX anchor block.\n * This ensures that each entry in the reward set returned to the stacks-node is greater than the threshold,\n * but does not require it be all locked up within a single transaction\n \n `stack-aggregation-commit-indexed` returns (ok uint) on success, where the given uint is the reward address's index in the list of reward\n * addresses allocated in this reward cycle. This index can then be passed to `stack-aggregation-increase`\n * to later increment the STX this PoX address represents, in amounts less than the stacking minimum.\n \n @category PoX-2\n * @param {StackAggregationCommitOptions} options - a required stack aggregation commit options object\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async stackAggregationCommitIndexed({\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackAggregationCommitOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n const contract = await this.getStackingContract();\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n ensureSignerArgsReadiness({ contract, signerKey, signerSignature, maxAmount, authId });\n\n const callOptions = this.getStackAggregationCommitOptionsIndexed({\n contract,\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegator, generate and broadcast a transaction to increase partial commitment committed delegatee tokens\n * @param {StackAggregationIncreaseOptions} options - a required stack aggregation increase options object\n * @category PoX-2\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async stackAggregationIncrease({\n poxAddress,\n rewardCycle,\n rewardIndex,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n ...txOptions\n }: StackAggregationIncreaseOptions & BaseTxOptions): Promise<TxBroadcastResult> {\n // todo: deprecate this method in favor of Indexed as soon as PoX-2 is live\n const contract = await this.getStackingContract();\n ensureLegacyBtcAddressForPox1({ contract, poxAddress });\n ensureSignerArgsReadiness({ contract, signerKey, signerSignature, maxAmount, authId });\n\n const callOptions = this.getStackAggregationIncreaseOptions({\n contract,\n poxAddress,\n rewardCycle,\n rewardCycleIndex: rewardIndex,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n });\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(txOptions),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n /\n As a delegatee, generate and broadcast a transaction to terminate the delegation relationship\n * @param {string} privateKey - the private key to be used for the revoke call\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async revokeDelegateStx(privateKey: string): Promise<TxBroadcastResult>;\n /\n As a delegatee, generate and broadcast a transaction to terminate the delegation relationship\n * @param {BaseTxOptions} txOptions - the private key, fee, and nonce to be used for the revoke call\n * @returns {Promise<string>} that resolves to a broadcasted txid if the operation succeeds\n /\n async revokeDelegateStx(txOptions: BaseTxOptions): Promise<TxBroadcastResult>;\n async revokeDelegateStx(arg: string \| BaseTxOptions): Promise<TxBroadcastResult> {\n if (typeof arg === 'string') arg = { privateKey: arg };\n\n const poxInfo = await this.getPoxInfo();\n const contract = poxInfo.contract_id;\n\n const callOptions = this.getRevokeDelegateStxOptions(contract);\n\n const tx = await makeContractCall({\n ...callOptions,\n ...renamePrivateKey(arg),\n });\n\n return broadcastTransaction({ transaction: tx, client: this.client });\n }\n\n getStackOptions({\n amountMicroStx,\n poxAddress,\n cycles,\n contract,\n burnBlockHeight,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n cycles: number;\n poxAddress: string;\n amountMicroStx: IntegerType;\n contract: string;\n burnBlockHeight: number;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [\n uintCV(amountMicroStx),\n address,\n uintCV(burnBlockHeight),\n uintCV(cycles),\n ] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-stx',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getStackExtendOptions({\n extendCycles,\n poxAddress,\n contract,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n extendCycles: number;\n poxAddress: string;\n contract: string;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [uintCV(extendCycles), address] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-extend',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getStackIncreaseOptions({\n increaseBy,\n contract,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n increaseBy: IntegerType;\n contract: string;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [uintCV(increaseBy)] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-increase',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getDelegateOptions({\n contract,\n amountMicroStx,\n delegateTo,\n untilBurnBlockHeight,\n poxAddress,\n }: {\n contract: string;\n amountMicroStx: IntegerType;\n delegateTo: string;\n untilBurnBlockHeight?: number;\n poxAddress?: string;\n }) {\n const address = poxAddress ? someCV(poxAddressToTuple(poxAddress)) : noneCV();\n const [contractAddress, contractName] = this.parseContractId(contract);\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'delegate-stx',\n functionArgs: [\n uintCV(amountMicroStx),\n principalCV(delegateTo),\n untilBurnBlockHeight ? someCV(uintCV(untilBurnBlockHeight)) : noneCV(),\n address,\n ],\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getDelegateStackOptions({\n contract,\n stacker,\n amountMicroStx,\n poxAddress,\n burnBlockHeight,\n cycles,\n }: {\n contract: string;\n stacker: string;\n amountMicroStx: IntegerType;\n poxAddress: string;\n burnBlockHeight: number;\n cycles: number;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'delegate-stack-stx',\n functionArgs: [\n principalCV(stacker),\n uintCV(amountMicroStx),\n address,\n uintCV(burnBlockHeight),\n uintCV(cycles),\n ],\n validateWithAbi: true,\n network: this.network,\n };\n\n return callOptions;\n }\n\n getDelegateStackExtendOptions({\n contract,\n stacker,\n poxAddress,\n extendCount,\n }: {\n contract: string;\n stacker: string;\n poxAddress: string;\n extendCount: number;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'delegate-stack-extend',\n functionArgs: [principalCV(stacker), address, uintCV(extendCount)],\n validateWithAbi: true,\n network: this.network,\n };\n\n return callOptions;\n }\n\n getDelegateStackIncreaseOptions({\n contract,\n stacker,\n poxAddress,\n increaseBy,\n }: {\n contract: string;\n stacker: string;\n poxAddress: string;\n increaseBy: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'delegate-stack-increase',\n functionArgs: [principalCV(stacker), address, uintCV(increaseBy)],\n validateWithAbi: true,\n network: this.network,\n };\n\n return callOptions;\n }\n\n getStackAggregationCommitOptions({\n contract,\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n contract: string;\n poxAddress: string;\n rewardCycle: number;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [address, uintCV(rewardCycle)] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-aggregation-commit',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getStackAggregationIncreaseOptions({\n contract,\n poxAddress,\n rewardCycle,\n rewardCycleIndex,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n contract: string;\n poxAddress: string;\n rewardCycle: number;\n rewardCycleIndex: number;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [address, uintCV(rewardCycle), uintCV(rewardCycleIndex)] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-aggregation-increase',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getStackAggregationCommitOptionsIndexed({\n contract,\n poxAddress,\n rewardCycle,\n signerKey,\n signerSignature,\n maxAmount,\n authId,\n }: {\n contract: string;\n poxAddress: string;\n rewardCycle: number;\n signerKey?: string;\n signerSignature?: string;\n maxAmount?: IntegerType;\n authId?: IntegerType;\n }) {\n const address = poxAddressToTuple(poxAddress);\n const [contractAddress, contractName] = this.parseContractId(contract);\n\n const functionArgs = [address, uintCV(rewardCycle)] as ClarityValue[];\n\n if (signerKey && maxAmount && typeof authId !== 'undefined') {\n functionArgs.push(signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV());\n functionArgs.push(bufferCV(hexToBytes(signerKey)));\n functionArgs.push(uintCV(maxAmount));\n functionArgs.push(uintCV(authId));\n }\n\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'stack-aggregation-commit-indexed',\n functionArgs,\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n getRevokeDelegateStxOptions(contract: string) {\n const [contractAddress, contractName] = this.parseContractId(contract);\n const callOptions: ContractCallOptions = {\n client: this.client,\n contractAddress,\n contractName,\n functionName: 'revoke-delegate-stx',\n functionArgs: [],\n validateWithAbi: true,\n network: this.network,\n };\n return callOptions;\n }\n\n /\n Check stacking status\n \n @returns {Promise<StackerInfo>} that resolves to a StackerInfo object if the operation succeeds\n /\n async getStatus(): Promise<StackerInfo> {\n const poxInfo = await this.getPoxInfo();\n const [contractAddress, contractName] = this.parseContractId(poxInfo.contract_id);\n const account = await this.getAccountStatus();\n const functionName = 'get-stacker-info';\n\n return fetchCallReadOnlyFunction({\n contractAddress,\n contractName,\n functionName,\n senderAddress: this.address,\n functionArgs: [principalCV(this.address)],\n client: this.client,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.OptionalSome) {\n const someCV = responseCV;\n const tupleCV: TupleCV = someCV.value as TupleCV;\n const poxAddress: TupleCV = tupleCV.value['pox-addr'] as TupleCV;\n const firstRewardCycle: UIntCV = tupleCV.value['first-reward-cycle'] as UIntCV;\n const lockPeriod: UIntCV = tupleCV.value['lock-period'] as UIntCV;\n const version: BufferCV = poxAddress.value['version'] as BufferCV;\n const hashbytes: BufferCV = poxAddress.value['hashbytes'] as BufferCV;\n\n return {\n stacked: true,\n details: {\n first_reward_cycle: Number(firstRewardCycle.value),\n lock_period: Number(lockPeriod.value),\n unlock_height: account.unlock_height,\n pox_address: {\n version: hexToBytes(version.value),\n hashbytes: hexToBytes(hashbytes.value),\n },\n },\n };\n } else if (responseCV.type === ClarityType.OptionalNone) {\n return {\n stacked: false,\n };\n } else {\n throw new Error(`Error fetching stacker info`);\n }\n });\n }\n\n /\n Check delegation status\n \n @returns {Promise<DelegationInfo>} that resolves to a DelegationInfo object if the operation succeeds\n /\n async getDelegationStatus(): Promise<DelegationInfo> {\n const poxInfo = await this.getPoxInfo();\n const [contractAddress, contractName] = this.parseContractId(poxInfo.contract_id);\n const functionName = 'get-delegation-info';\n\n return fetchCallReadOnlyFunction({\n contractAddress,\n contractName,\n functionName,\n functionArgs: [principalCV(this.address)],\n senderAddress: this.address,\n client: this.client,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.OptionalSome) {\n const tupleCV = responseCV.value as TupleCV;\n const amountMicroStx = tupleCV.value['amount-ustx'] as UIntCV;\n const delegatedTo = tupleCV.value['delegated-to'] as PrincipalCV;\n\n const poxAddress = unwrapMap(tupleCV.value['pox-addr'] as OptionalCV<TupleCV>, tuple => ({\n version: hexToBytes((tuple.value['version'] as BufferCV).value)[0],\n hashbytes: hexToBytes((tuple.value['hashbytes'] as BufferCV).value),\n }));\n const untilBurnBlockHeight = unwrap(tupleCV.value['until-burn-ht'] as OptionalCV<UIntCV>);\n\n return {\n delegated: true,\n details: {\n amount_micro_stx: BigInt(amountMicroStx.value),\n delegated_to: delegatedTo.value,\n pox_address: poxAddress,\n until_burn_ht: untilBurnBlockHeight ? Number(untilBurnBlockHeight.value) : undefined,\n },\n };\n } else if (responseCV.type === ClarityType.OptionalNone) {\n return {\n delegated: false,\n };\n } else {\n throw new Error(`Error fetching delegation info`);\n }\n });\n }\n\n /\n Call the `verify-signer-key-sig` read-only function on the PoX contract.\n * @returns (async) a boolean indicating if the signature is valid\n /\n async verifySignerKeySignature({\n topic,\n poxAddress,\n rewardCycle,\n period,\n signerSignature,\n signerKey,\n amount,\n maxAmount,\n authId,\n }: {\n topic: string;\n poxAddress: string;\n rewardCycle: number;\n period: number;\n signerSignature?: string;\n signerKey: string;\n amount: IntegerType;\n maxAmount: IntegerType;\n authId: IntegerType;\n }): Promise<boolean> {\n const poxInfo = await this.getPoxInfo();\n\n const [contractAddress, contractName] = this.parseContractId(poxInfo.contract_id);\n const functionName = 'verify-signer-key-sig';\n\n const functionArgs = [\n poxAddressToTuple(poxAddress),\n uintCV(rewardCycle),\n stringAsciiCV(topic),\n uintCV(period),\n signerSignature ? someCV(bufferCV(hexToBytes(signerSignature))) : noneCV(),\n bufferCV(hexToBytes(signerKey)),\n uintCV(amount),\n uintCV(maxAmount),\n uintCV(authId),\n ];\n\n return fetchCallReadOnlyFunction({\n contractAddress,\n contractName,\n functionName,\n functionArgs,\n senderAddress: this.address,\n client: this.client,\n }).then(responseCV => responseCV.type === ClarityType.ResponseOk);\n }\n\n /\n @returns {Promise<string>} that resolves to the contract id (address and name) to use for stacking\n /\n async getStackingContract(poxOperationInfo?: PoxOperationInfo): Promise<string> {\n poxOperationInfo = poxOperationInfo ?? (await this.getPoxOperationInfo());\n switch (poxOperationInfo.period) {\n case PoxOperationPeriod.Period1:\n return poxOperationInfo.pox1.contract_id;\n case PoxOperationPeriod.Period2a:\n case PoxOperationPeriod.Period2b:\n // in the 2.1 fork we can always stack to PoX-2\n return poxOperationInfo.pox2.contract_id;\n case PoxOperationPeriod.Period3:\n default:\n return poxOperationInfo.current.contract_id;\n }\n }\n\n /\n Adjust microstacks amount for locking after taking into account transaction fees\n \n @returns {StacksTransactionWire} that resolves to a transaction object if the operation succeeds\n /\n modifyLockTxFee({\n tx,\n amountMicroStx,\n }: {\n tx: StacksTransactionWire;\n amountMicroStx: IntegerType;\n }) {\n const fee = getFee(tx.auth);\n (tx.payload as ContractCallPayload).functionArgs[0] = uintCV(intToBigInt(amountMicroStx) - fee);\n return tx;\n }\n\n /\n Parses a contract identifier and ensures it is formatted correctly\n \n @returns {Array<string>} a contract address and name\n /\n parseContractId(contract: string): string[] {\n // todo: move this function to a standalone utility, and @ignore deprecate it here\n const parts = contract.split('.');\n\n if (parts.length === 2 && validateStacksAddress(parts[0]) && parts[1].startsWith('pox')) {\n return parts;\n }\n\n throw new Error('Stacking contract ID is malformed');\n }\n\n /\n Generates a `signer-sig` string for the current PoX contract.\n /\n signPoxSignature({\n topic,\n poxAddress,\n rewardCycle,\n period,\n signerPrivateKey,\n authId,\n maxAmount,\n }: {\n topic: `${Pox4SignatureTopic}`;\n poxAddress: string;\n rewardCycle: number;\n period: number;\n signerPrivateKey: PrivateKey;\n maxAmount: IntegerType;\n authId: IntegerType;\n }) {\n // todo: in the future add logic to determine if a later version of pox\n // needs a different domain and thus use a different `signPox4SignatureHash`\n return signPox4SignatureHash({\n topic,\n poxAddress,\n rewardCycle,\n period,\n network: this.network,\n privateKey: signerPrivateKey,\n maxAmount,\n authId,\n });\n }\n}\n\n/* @ignore Rename `privateKey` to `senderKey`, for backwards compatibility /\nfunction renamePrivateKey(txOptions: BaseTxOptions) {\n // @ts-ignore\n txOptions.senderKey = txOptions.privateKey;\n // @ts-ignore\n delete txOptions.privateKey;\n return txOptions as any as {\n fee?: IntegerType;\n nonce?: IntegerType;\n senderKey: string;\n };\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface V2CoreInfoResponse {\n burn_block_height: number;\n stable_pox_consensus: string;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface CycleInfoResponse {\n id: number;\n min_threshold_ustx: number;\n stacked_ustx: number;\n is_pox_active: boolean;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface ContractVersionResponse {\n contract_id: ContractIdString;\n activation_burnchain_block_height: number;\n first_reward_cycle_id: number;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface V2PoxInfoResponse {\n contract_id: string;\n contract_versions: ContractVersionResponse[];\n current_burnchain_block_height?: number;\n first_burnchain_block_height: number;\n min_amount_ustx: string;\n next_reward_cycle_in: number;\n prepare_cycle_length: number;\n prepare_phase_block_length: number;\n rejection_fraction: number;\n rejection_votes_left_required: number;\n reward_cycle_id: number;\n reward_cycle_length: number;\n reward_phase_block_length: number;\n reward_slots: number;\n current_cycle: CycleInfoResponse;\n next_cycle: CycleInfoResponse & {\n min_increment_ustx: number;\n prepare_phase_start_block_height: number;\n blocks_until_prepare_phase: number;\n reward_phase_start_block_height: number;\n blocks_until_reward_phase: number;\n ustx_until_pox_rejection: number;\n };\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface V1InfoBlockTimesResponse {\n mainnet: {\n target_block_time: number;\n };\n testnet: {\n target_block_time: number;\n };\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface ExtendedAccountBalancesResponse {\n stx: {\n balance: string;\n total_sent: string;\n total_received: string;\n locked: string;\n lock_tx_id: string;\n lock_height: number;\n burnchain_lock_height: number;\n burnchain_unlock_height: number;\n };\n fungible_tokens: any;\n non_fungible_tokens: any;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface ExtendedAccountBalances {\n stx: {\n balance: bigint;\n total_sent: bigint;\n total_received: bigint;\n locked: bigint;\n lock_tx_id: string;\n lock_height: number;\n burnchain_lock_height: number;\n burnchain_unlock_height: number;\n };\n fungible_tokens: any;\n non_fungible_tokens: any;\n}\n\n/* @beta @ignore Type export subject to change/\nexport interface PaginationOptions {\n limit: number;\n offset: number;\n}\n\n/* @beta @ignore Type export subject to change*/\nexport interface BaseErrorResponse {\n error: string;\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","basex","address_1","enumerable","get","c32address","c32addressDecode","HASH_UNDEFINED","MAX_SAFE_INTEGER","argsTag","boolTag","dateTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reFlags","reIsHostCtor","reIsUint","cloneableTags","freeGlobal","g","freeSelf","self","Function","freeExports","nodeType","freeModule","moduleExports","addMapEntry","map","pair","addSetEntry","add","arrayReduce","iteratee","accumulator","initAccum","index","isHostObject","e","mapToArray","size","forEach","key","overArg","func","transform","arg","setToArray","uid","arrayProto","funcProto","objectProto","coreJsData","maskSrcKey","exec","keys","IE_PROTO","funcToString","hasOwnProperty","objectToString","reIsNative","RegExp","replace","Buffer","Symbol","getPrototype","getPrototypeOf","objectCreate","propertyIsEnumerable","splice","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeKeys","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","entries","clear","entry","ListCache","MapCache","Stack","__data__","assignValue","object","objValue","eq","assocIndexOf","baseClone","isDeep","isFull","customizer","stack","isObject","isArr","isArray","input","initCloneArray","source","copyArray","tag","getTag","isFunc","copy","cloneBuffer","isPrototype","proto","initCloneObject","copyObject","getSymbols","copySymbols","baseAssign","cloneFunc","symbol","Ctor","cloneArrayBuffer","dataView","cloneDataView","typedArray","cloneTypedArray","cloneMap","regexp","lastIndex","cloneRegExp","cloneSet","initCloneByTag","stacked","props","keysFunc","symbolsFunc","values","offset","arrayPush","baseGetAllKeys","getAllKeys","arrayEach","subValue","arrayBuffer","newValue","getMapData","type","getValue","isFunction","test","baseIsNative","has","pop","push","cache","pairs","LARGE_ARRAY_SIZE","isIndex","other","ArrayBuffer","resolve","ctorString","isArrayLike","isLength","inherited","isObjectLike","isArrayLikeObject","isArguments","n","baseTimes","String","skipIndexes","arrayLikeKeys","baseKeys","ALPHABET","BASE_MAP","x","charAt","xc","charCodeAt","BASE","LEADER","FACTOR","log","iFACTOR","decodeUnsafe","psz","zeroes","b256","charCode","carry","it3","it4","vch","isView","pbegin","pend","b58","it1","it2","repeat","decode","string","sha256_1","utils_1","prefix","dataBytes","prefixBytes","checksum","sha256","bytes","check","number","isSafeInteger","bool","b","lengths","includes","hash","exists","instance","checkFinished","destroyed","finished","output","out","min","assert","SHA2","_assert_js_1","utils_js_1","padOffset","super","pos","view","default","len","take","process","subarray","roundClean","digestInto","fill","setBigUint64","_32n","BigInt","_u32_max","wh","wl","h","l","setUint32","oview","outLen","state","res","destroy","to","c32checkDecode","c32checkEncode","encoding_1","c32checksum","dataHex","dataHash","version","match","toLowerCase","versionHex","checksumHex","c32str","c32encode","c32","c32data","c32normalize","c32decode","versionChar","indexOf","substring","c32input","toUpperCase","inputHex","minLength","currentCode","nextCode","nextBits","nextLowBits","curC32Digit","unshift","C32leadingZeros","zeroPrefix","TextDecoder","numLeadingZeroBytesInHex","count","join","numLeadingZeroBytes","carryBits","currentValue","currentHexDigit","hexLeadingZeros","hexStr","sha224","_sha2_js_1","Chi","c","Maj","SHA256_K","IV","SHA256_W","SHA256","A","B","C","D","E","F","G","H","getUint32","W15","W2","s0","s1","T1","T2","SHA224","c32ToB58","b58ToC32","versions","checksum_1","base58check","mainnet","p2pkh","p2sh","testnet","ADDR_BITCOIN_TO_STACKS","ADDR_STACKS_TO_BITCOIN","hash160hex","c32addr","b58check","addrInfo","hash160String","addrVersion","stacksVersion","c32string","bitcoinVersion","lookup","revLookup","code","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","getter","__esModule","d","t","mode","then","ns","r","def","current","getOwnPropertyNames","definition","o","globalThis","window","prop","toStringTag","nmd","paths","children","intToBytes","isInteger","RangeError","without0x","hexToBigInt","intToHex","integer","bytesToTwosBigInt","width","nthBit","_","u","asciiToBytes","byteArray","bytesToAscii","fromCharCode","apply","isNotOctet","octet","octetsToBytes","numbers","some","elements","clazz","name","defaultFetchOpts","referrerPolicy","headers","fetchWrapper","init","fetchOpts","fetch","args","fetchLib","middlewares","argsForCreateFetchFn","url","fetchParams","middleware","pre","response","post","ChainId","PeerNetworkId","AddressVersion","TransactionVersion","Mainnet","chainId","transactionVersion","peerNetworkId","magicBytes","bootAddress","addressVersion","singleSig","MainnetSingleSig","multiSig","MainnetMultiSig","client","baseUrl","STACKS_TESTNET","Testnet","TestnetSingleSig","TestnetMultiSig","STACKS_DEVNET","STACKS_MOCKNET","StacksNetworks","network","networkFromName","TransactionError","captureStackTrace","SerializationError","NoEstimateAvailableError","SigningError","writeUInt8","destination","writeUInt32BE","writeUInt32LE","enumCheckFunctions","isEnum","enumVariable","checker","newChecker","enumValues","filter","enumValueSet","createEnumChecker","consumed","readBytes","readUInt32BE","readUInt8","readUInt16BE","readBigUIntLE","reverse","readBigUIntBE","readOffset","val","internalBytes","readUInt8Enum","invalidEnumErrorFormatter","num","MAX_STRING_LENGTH_BYTES","CLARITY_INT_SIZE","CLARITY_INT_BYTE_SIZE","AnchorMode","ClarityVersion","PayloadType","FungibleConditionCode","NonFungibleConditionCode","AssetType","TxRejectedReason","AuthFieldType","TenureChangeCause","PostConditionPrincipalId","PubKeyEncoding","AddressHashMode","AuthType","PostConditionType","PostConditionMode","OnChainOnly","OffChainOnly","Any","Rho","Id","Pi","idxL","idxR","k","shifts","shiftsL","idx","shiftsR","Kl","Kr","rotl","f","group","y","z","BUF","RIPEMD160","h0","h1","h2","h3","h4","al","ar","bl","br","cl","cr","dl","dr","el","er","rGroup","hbl","hbr","rl","rr","sl","sr","tl","tr","ripemd160","U32_MASK64","fromBig","le","lst","Ah","Al","s","Bh","Bl","Cl","low","Ch","Dl","Dh","Eh","El","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","s0l","W2h","W2l","s1h","s1l","SUMl","SUMh","sigma1h","sigma1l","CHIh","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","All","SHA512_224","SHA512_256","SHA384","sha512_256","_0n","_1n","_2n","_3n","_8n","CURVE","freeze","P","Gx","Gy","beta","divNearest","endo","splitScalar","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","JacobianPoint","fromAffine","p","equals","ZERO","toAffineBatch","points","toInv","nums","scratch","inverted","invert","acc","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","windowSize","mask","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","_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","sum","sliceDER","parseDERInt","Signature","fromCompact","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","hmac","hmacSha256","hmacSync","checkSync","incr","reseed","seed","reseedSync","generate","generateSync","kmdToSig","kBytes","lowS","kinv","sig","error","bits2int","bits2octets","z1","z2","int2octets","vopts","strict","publicKey","normalizePublicKey","sinv","TAGGED_HASH_PREFIXES","isValidPrivateKey","_bigintTo32Bytes","_normalizePrivateKey","hashToPrivateKey","minLen","randomPrivateKey","precompute","cached","messages","subtle","createHash","ckey","importKey","sign","createHmac","sha256Sync","hmacSha256Sync","taggedHash","tagP","tagH","taggedHashSync","_JacobianPoint","defineProperties","configurable","ClarityWireType","ClarityType","clarityTypeToByte","MAX_U128","MIN_U128","MAX_I128","MIN_I128","bigInt","UInt","StacksWireType","lengthPrefixBytes","LengthPrefixedList","MessageSignature","createLPString","content","maxLengthBytes","prefixLength","maxLength","LengthPrefixedString","c32AddressString","addressData","Address","hash160","pubKeyEncoding","contents","TransactionAuthField","HMAC","_key","iHash","oHash","buf","COORDINATE_BYTES","parseRecoverableSignatureVrs","recoveryIdHex","recoveryId","privateKeyBuffer","PublicKey","msgs","privateKeyIsCompressed","startsWith","signWithKey","messageHash","rawSignature","privKey","extraEntropy","seedArgs","initSigArgs","drbg","canonical","recSig","der","recovered","hashed","finalizeSig","addressFromPublicKeys","hashMode","numSigs","publicKeys","P2PKH","P2WPKH","P2WSH","P2WSHNonSequential","hashP2WPKH","P2SH","P2SHNonSequential","hashP2SH","serializePublicKeyBytes","hashP2WSH","address","parseAssetString","assetAddress","assetContractName","assetTokenName","split","addressString","contractName","assetName","Asset","parsePrincipalString","principalString","addr","Principal","Contract","createContractPrincipal","Standard","createStandardPrincipal","principal","contractPrincipalCVFromAddress","PrincipalStandard","PrincipalContract","OptionalNone","OptionalSome","tupleCV","isClarityName","Tuple","StringASCII","serializedClarityValue","bytesReader","hasHexPrefix","int","Int","uint","bufferLength","true","BoolTrue","false","BoolFalse","deserializeAddress","contract","deserializeLPString","ok","ResponseOk","err","ResponseErr","responseErrorCV","none","list","listLength","listContents","List","tuple","tupleLength","tupleContents","clarityName","ascii","asciiStrLen","asciiStr","utf8","utf8StrLen","utf8Str","StringUTF8","cloneDeep","txidFromData","keyHash","redeemScript","pubKeys","bytesArray","pubKey","scriptArray","script","parseReadOnlyResponse","okay","cause","bytesWithTypeID","typeId","serializeStringCV","cv","encoding","serializeBoolCV","ceil","serializeBufferCV","serializeUIntCV","toTwos","serializeIntCV","serializeAddressBytes","serializeStandardPrincipalCV","contractId","parseContractId","serializeLPStringBytes","serializeContractPrincipalCV","serializeResponseCV","serializedValue","serializeListCV","lexicographicOrder","sort","localeCompare","nameWithLength","serializeTupleCV","serializeStringAsciiCV","serializeStringUtf8CV","serializeStacksWireBytes","wire","serializePrincipalBytes","MemoString","memoString","contentBytes","paddedContent","hexString","padEnd","serializeMemoStringBytes","serializeAssetBytes","PostCondition","postCondition","conditionType","Fungible","NonFungible","asset","conditionCode","STX","amount","serializePostConditionWireBytes","serializeLPListBytes","Payload","serializePayloadBytes","field","Compressed","PublicKeyCompressed","PublicKeyUncompressed","SignatureCompressed","SignatureUncompressed","serializeMessageSignatureBytes","serializeTransactionAuthFieldBytes","serialized","lps","info","deserializeAsset","lpList","postConditionType","Origin","deserializePrincipal","payload","payloadType","TokenTransfer","recipient","memo","ContractCall","contractAddress","functionName","numArgs","functionArgs","SmartContract","codeBody","VersionedSmartContract","clarityVersion","PoisonMicroblock","Coinbase","coinbaseBytes","CoinbaseToAltRecipient","NakamotoCoinbase","vrfProof","TenureChange","tenureHash","previousTenureHash","burnViewHash","previousTenureEnd","previousTenureBlocks","publicKeyHash","messageSignature","emptyMessageSignature","nonce","fee","signer","keyEncoding","Uncompressed","isSingleSig","isSequentialMultiSig","isNonSequentialMultiSig","clearCondition","cloned","fields","serializeSpendingConditionBytes","serializeSingleSigSpendingConditionBytes","writeUInt16BE","signaturesRequired","serializeMultiSigSpendingConditionBytes","sigHashPreSign","curSigHash","authType","sigHash","sigHashPostSign","sigHashBytes","nextVerification","initialSigHash","sigHashPre","parsedSignature","compressed","publicKeyFromSignatureVrs","nextSigHash","spendingCondition","sponsorSpendingCondition","Sponsored","intoInitialSighashAuth","auth","newInitialSigHash","postConditions","postConditionMode","Deny","anchorMode","signBegin","tx","txid","verifyBegin","verifyOrigin","addrBytes","verifySingleSig","haveUncompressed","verifyMultiSig","signNextOrigin","signAndAppend","signNextSponsor","appendPubkey","cond","nextSig","nextSignature","serializeBytes","setSponsor","setFee","setNonce","setSponsorNonce","serialize","chainIdBytes","serializeAuthorizationBytes","transaction","broadcastTransaction","txOpt","attachment","attachOpt","_network","_client","json","options","method","body","JSON","stringify","text","fetchCallReadOnlyFunction","senderAddress","sender","arguments","encodeURIComponent","catch","status","statusText","cvToString","getCVTypeString","ClarityAbiTypeId","isClarityAbiPrimitive","isClarityAbiBuffer","isClarityAbiStringAscii","isClarityAbiStringUtf8","isClarityAbiResponse","isClarityAbiOptional","optional","isClarityAbiTuple","isClarityAbiList","getTypeString","matchType","abiType","union","ClarityAbiTypeUInt128","ClarityAbiTypeInt128","ClarityAbiTypeBool","ClarityAbiTypePrincipal","ClarityAbiTypeTraitReference","ClarityAbiTypeNone","ClarityAbiTypeBuffer","ClarityAbiTypeResponse","ClarityAbiTypeOptional","ClarityAbiTypeTuple","ClarityAbiTypeList","ClarityAbiTypeStringAscii","ClarityAbiTypeStringUtf8","getTypeUnion","abiTupleEntry","PostConditionCodeWireType","conditionTypeToByte","originDone","checkOversign","checkOverlap","nextVerify","createSponsorSigner","originSigHash","signOrigin","nextSighash","appendOrigin","signSponsor","getTxInComplete","resume","makeUnsignedContractCall","txOptions","defaultOptions","sponsored","Allow","validateWithAbi","abi","parse","fetchAbi","filtered","functions","fn","abiArgs","payloadArg","abiArg","argNum","validateContractCall","useNonSequentialMultiSig","sortPublicKeysForAddress","numSignatures","authorization","lpPostConditions","pc","postcondition","assetId","estimatedLength","multiSigSpendingCondition","existingSignatures","totalSignatureLength","estimateTransactionByteLength","transaction_payload","estimated_len","reason_data","estimations","fetchFeeEstimateTransaction","Accept","feeRateResult","txBytes","fetchFeeEstimateTransfer","txNonce","possible_next_nonce","_getNonceApi","makeContractCall","senderKey","signerKeys","pubs","signerKey","find","mutatingSignAppendMultiSig","publicKeysSorted","PoXAddressVersion","BitcoinNetworkVersion","devnet","mocknet","B58_ADDR_PREFIXES","SEGWIT_V0_ADDR_PREFIX","SEGWIT_V1_ADDR_PREFIX","SegwitPrefix","SEGWIT_ADDR_PREFIXES","SEGWIT_V0","SEGWIT_V1","PoxOperationPeriod","StackingErrors","assertNumber","chain","wrap","alphabet","digits","letter","separator","padding","bits","chr","end","normalize","convertRadix","done","digit","digitBase","gcd","radix2carry","convertRadix2","radix2","revPadding","unsafeWrapper","genBase58","abc","BECH_ALPHABET","POLYMOD_GENERATORS","bech32Polymod","chk","bechChecksum","words","encodingConst","genBech32","ENCODING_CONST","_words","fromWords","toWords","fromWordsUnsafe","limit","lowered","sepIndex","lastIndexOf","endsWith","actualLength","decodeToBytes","bech32","bech32m","ensureUInt53","chainPrefix","encodeMessage","messageBytes","encodedLength","writeUInt16LE","InvalidPublicKeyReason","STRUCTURED_DATA_PREFIX","hashStructuredDataBytes","structuredData","encodeStructuredDataBytes","domain","structuredDataHash","domainHash","InvalidAddressError","innerError","btcAddressVersionToLegacyHashMode","btcAddressVersion","decodeBtcAddress","btcAddress","decodeBtcAddressBytes","newChecksum","base58CheckDecode","b32","bech32Words","witnessVersion","bech32Decode","bech32MWords","bech32MDecode","decodeNativeSegwitBtcAddress","dataLength","P2TR","nativeAddressToSegwitVersion","extractPoxAddressFromClarityValue","poxAddrClarityValue","clarityValue","versionCV","hashBytesCV","hashBytes","getErrorString","ERR_STACKING_UNREACHABLE","ERR_STACKING_CORRUPTED_STATE","ERR_STACKING_INSUFFICIENT_FUNDS","ERR_STACKING_INVALID_LOCK_PERIOD","ERR_STACKING_ALREADY_STACKED","ERR_STACKING_NO_SUCH_PRINCIPAL","ERR_STACKING_EXPIRED","ERR_STACKING_STX_LOCKED","ERR_STACKING_PERMISSION_DENIED","ERR_STACKING_THRESHOLD_NOT_MET","ERR_STACKING_POX_ADDRESS_IN_USE","ERR_STACKING_INVALID_POX_ADDRESS","ERR_STACKING_ALREADY_REJECTED","ERR_STACKING_INVALID_AMOUNT","ERR_NOT_ALLOWED","ERR_STACKING_ALREADY_DELEGATED","ERR_DELEGATION_EXPIRES_DURING_LOCK","ERR_DELEGATION_TOO_MUCH_LOCKED","ERR_DELEGATION_POX_ADDR_REQUIRED","ERR_INVALID_START_BURN_HEIGHT","ERR_NOT_CURRENT_STACKER","ERR_STACK_EXTEND_NOT_LOCKED","ERR_STACK_INCREASE_NOT_LOCKED","ERR_DELEGATION_NO_REWARD_SLOT","ERR_DELEGATION_WRONG_REWARD_SLOT","ERR_STACKING_IS_DELEGATED","ERR_STACKING_NOT_DELEGATED","poxAddressToTuple","poxAddress","hashbytes","_poxAddressToBtcAddress_Values","P2SHP2WPKH","P2SHP2WSH","btcAddrVersion","legacyHashModeToBtcAddressVersion","base58Encode","base58CheckEncode","poxAddressToBtcAddress","poxAddr","_poxAddressToBtcAddress_ClarityValue","unwrap","unwrapMap","ensurePox2Activated","operationInfo","period","Period1","ensureLegacyBtcAddressForPox1","ensureSignerArgsReadiness","signerSignature","maxAmount","authId","hasMaxAmount","hasAuthId","Pox4SignatureTopic","signPox4SignatureHash","topic","rewardCycle","signMessageHashRsv","signStructuredData","pox4SignatureMessage","verifyPox4SignatureHash","verificationResult","hashMessage","verifyMessageSignature","verifyMessageSignatureRsv","lockPeriod","networkOrName","StackingClient","getCoreInfo","getPoxInfo","getTargetBlockTime","target_block_time","getAccountStatus","balance","locked","getAccountBalance","getAccountExtendedBalances","stx","total_sent","total_received","getAccountBalanceLocked","getCycleDuration","poxInfoPromise","targetBlockTimePromise","all","poxInfo","targetBlockTime","reward_cycle_length","getRewardsTotalForBtcAddress","reward_amount","getRewardsForBtcAddress","getRewardHoldersForBtcAddress","getRewardSet","rewardCyleId","rewardSetIndex","pox_address","total_ustx","getSecondsUntilNextCycle","coreInfoPromise","coreInfo","burn_block_height","first_burnchain_block_height","getSecondsUntilStackingDeadline","next_cycle","blocks_until_prepare_phase","getPoxOperationInfo","poxContractVersions","contract_versions","activation_burnchain_block_height","pox1","pox2","pox3","pox4","activatedPoxs","current_burnchain_block_height","Period3","hasMinimumStx","min_amount_ustx","canStack","cycles","balancePromise","contract_id","reward_cycle_id","responseCV","eligible","reason","amountMicroStx","burnBlockHeight","poxOperationInfo","getStackingContract","callOptions","getStackOptions","renamePrivateKey","stackExtend","extendCycles","getStackExtendOptions","stackIncrease","increaseBy","getStackIncreaseOptions","delegateStx","delegateTo","untilBurnBlockHeight","getDelegateOptions","delegateStackStx","stacker","getDelegateStackOptions","delegateStackExtend","extendCount","getDelegateStackExtendOptions","delegateStackIncrease","getDelegateStackIncreaseOptions","stackAggregationCommit","getStackAggregationCommitOptions","stackAggregationCommitIndexed","getStackAggregationCommitOptionsIndexed","stackAggregationIncrease","rewardIndex","getStackAggregationIncreaseOptions","rewardCycleIndex","revokeDelegateStx","getRevokeDelegateStxOptions","getStatus","account","firstRewardCycle","details","first_reward_cycle","lock_period","unlock_height","getDelegationStatus","delegatedTo","delegated","amount_micro_stx","delegated_to","until_burn_ht","verifySignerKeySignature","Period2a","Period2b","modifyLockTxFee","getFee","parts","validateStacksAddress","signPoxSignature","signerPrivateKey"],"sourceRoot":""}