{"version":3,"file":"index-Bcw7mvX2.mjs","sources":["../src/utils/createAdapterAvailability.ts","../src/adapters/BitgetWalletAdapter.ts","../src/adapters/LeatherWalletAdapter.ts","../src/adapters/MagicEdenWalletAdapter.ts","../node_modules/.pnpm/@scure+base@2.0.0/node_modules/@scure/base/index.js","../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/utils.js","../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_md.js","../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/sha2.js","../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/utils.js","../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/modular.js","../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/curve.js","../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/hmac.js","../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/weierstrass.js","../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/secp256k1.js","../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/legacy.js","../node_modules/.pnpm/micro-packed@0.8.0/node_modules/micro-packed/index.js","../node_modules/.pnpm/@scure+btc-signer@2.0.1/node_modules/@scure/btc-signer/utils.js","../node_modules/.pnpm/@scure+btc-signer@2.0.1/node_modules/@scure/btc-signer/script.js","../node_modules/.pnpm/@scure+btc-signer@2.0.1/node_modules/@scure/btc-signer/payment.js","../src/utils/bitcoinNetworkHelpers.ts","../src/utils/bitcoinAddressHelpers.ts","../src/utils/error.ts","../src/adapters/MockAddressWalletAdapter.ts","../src/adapters/OkxWalletAdapter.ts","../src/adapters/UnisatWalletAdapter.ts","../src/adapters/XverseWalletAdapter.ts"],"sourcesContent":["export type GetPreconditionFn = () => null | { value: T }\n\nexport type InitializerFn = (precondition: I) => T | Promise\n\nexport interface AvailabilitySubscription {\n unsubscribe: () => void\n}\n\nexport interface Availability {\n subscribe: (listener: (adapter: T) => void) => AvailabilitySubscription\n}\n\nexport function createAvailability({\n getPrecondition,\n initializer,\n pollIntervalMs = 300,\n}: {\n getPrecondition: GetPreconditionFn\n initializer: InitializerFn\n pollIntervalMs?: number\n}): Availability {\n let cachedAdapter: T | null = null\n let polling: ReturnType | null = null\n let creating = false\n\n const listeners = new Set<(adapter: T) => void>()\n\n const stopPolling = (): void => {\n if (polling != null) {\n clearInterval(polling)\n polling = null\n }\n }\n\n const emit = (adapter: T): void => {\n cachedAdapter = adapter\n for (const listener of listeners) {\n listener(adapter)\n }\n }\n\n const attemptCreate = async (): Promise => {\n if (cachedAdapter != null || creating) return\n const precondition = getPrecondition()\n if (precondition == null) return\n\n creating = true\n try {\n const adapter = await initializer(precondition.value)\n emit(adapter)\n stopPolling()\n } catch (error) {\n console.warn(\"[WalletAdapter] Failed to initialize adapter\", error)\n } finally {\n creating = false\n }\n }\n\n const ensurePolling = (): void => {\n if (cachedAdapter != null) return\n\n void attemptCreate()\n if (cachedAdapter != null || polling != null) return\n\n polling = setInterval(() => {\n void attemptCreate()\n }, pollIntervalMs)\n }\n\n return {\n subscribe: listener => {\n if (cachedAdapter != null) {\n listener(cachedAdapter)\n return { unsubscribe: () => {} }\n }\n\n listeners.add(listener)\n ensurePolling()\n\n const subscription: AvailabilitySubscription = {\n unsubscribe: () => {\n listeners.delete(listener)\n if (listeners.size === 0) {\n stopPolling()\n }\n },\n }\n\n return subscription\n },\n }\n}\n","import { createAvailability } from \"../utils/createAdapterAvailability\"\nimport type { UnisatCompatibleProviderAPI } from \"../utils/UnisatCompatibleWalletAdapterImpl\"\nimport type {\n WalletAdapter,\n WalletAdapterMetadata,\n WalletAdapterFactory,\n} from \"../WalletAdapters.types\"\n\n/**\n * Derivation path (BIP-44): m/44'/0'/0'/0/ address_index\n */\n\nconst adapterId = \"bitget.bitcoin\"\n\n/**\n * https://web3.bitget.com/en/docs/wallet/brand-assets.html\n */\nexport const metadata: WalletAdapterMetadata = {\n name: \"Bitget\",\n iconUrl: () => import(\"../_/bitget.png\").then(m => m.default),\n websiteUrl: \"https://web3.bitget.com/\",\n downloadUrl: \"https://web3.bitget.com/en/wallet-download\",\n}\n\nconst availability = createAvailability<\n UnisatCompatibleProviderAPI,\n WalletAdapter\n>({\n getPrecondition: () =>\n (window as any).bitkeep?.unisat == null\n ? null\n : { value: (window as any).bitkeep.unisat },\n initializer: async provider => {\n const { BitgetWalletAdapterImpl } =\n await import(\"./BitgetWalletAdapter.impl\")\n return new BitgetWalletAdapterImpl(provider)\n },\n})\n\nexport function BitgetWalletAdapterFactory(): WalletAdapterFactory {\n return {\n adapterId,\n metadata,\n getAdapter: () => availability,\n }\n}\n","import type { RequestFn } from \"@leather.io/rpc\"\nimport { createAvailability } from \"../utils/createAdapterAvailability\"\nimport type {\n WalletAdapter,\n WalletAdapterFactory,\n WalletAdapterMetadata,\n} from \"../WalletAdapters.types\"\n\nexport const adapterId = \"LeatherProvider.BitcoinProvider\"\n\nexport const metadata: WalletAdapterMetadata = {\n name: \"Leather\",\n iconUrl: () => import(\"../_/leather.svg\").then(m => m.default),\n websiteUrl: \"https://leather.io/\",\n downloadUrl: \"https://leather.io/wallet\",\n}\n\nconst availability = createAvailability({\n getPrecondition: () => {\n const request = (window as any).LeatherProvider?.request as\n | RequestFn\n | undefined\n return request == null ? null : { value: request }\n },\n initializer: async request => {\n const { LeatherWalletAdapterImpl } =\n await import(\"./LeatherWalletAdapter.impl\")\n return new LeatherWalletAdapterImpl(request)\n },\n})\n\nexport function LeatherWalletAdapterFactory(): WalletAdapterFactory {\n return {\n adapterId,\n metadata,\n getAdapter: () => availability,\n }\n}\n","import type {\n WalletAdapter,\n WalletAdapterBitcoinNetwork,\n WalletAdapterFactory,\n WalletAdapterMetadata,\n} from \"../WalletAdapters.types\"\nimport { createAvailability } from \"../utils/createAdapterAvailability\"\nimport type { MagicEdenBitcoinProvider } from \"./MagicEdenWalletAdapter.impl\"\n\ndeclare global {\n interface Window {\n magicEden?: {\n bitcoin?: MagicEdenBitcoinProvider\n }\n }\n}\n\nexport const MAGICEDEN_PROVIDER_ID = \"magiceden.bitcoin\"\n\nexport const metadata: WalletAdapterMetadata = {\n name: \"Magic Eden\",\n /**\n * https://docs-wallet.magiceden.io/resources/logos-and-brand-assets\n */\n iconUrl: () => import(\"../_/magiceden.png\").then(m => m.default),\n websiteUrl: \"https://wallet.magiceden.io/\",\n downloadUrl: \"https://wallet.magiceden.io/download\",\n}\n\n// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\nconst buildAvailability = (network: WalletAdapterBitcoinNetwork) =>\n createAvailability({\n getPrecondition: () => {\n const provider = window.magicEden?.bitcoin\n return provider?.isMagicEden ? { value: provider } : null\n },\n initializer: async provider => {\n const { MagicEdenWalletAdapterImpl } =\n await import(\"./MagicEdenWalletAdapter.impl\")\n return new MagicEdenWalletAdapterImpl(network, provider)\n },\n })\n\nexport const MagicEdenWalletAdapterFactory = (options: {\n network: WalletAdapterBitcoinNetwork\n}): WalletAdapterFactory => {\n const availability = buildAvailability(options.network)\n\n return {\n adapterId: MAGICEDEN_PROVIDER_ID,\n metadata,\n getAdapter: () => availability,\n }\n}\n","/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nfunction isBytes(a) {\n return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is Uint8Array. */\nfunction abytes(b) {\n if (!isBytes(b))\n throw new Error('Uint8Array expected');\n}\nfunction isArrayOf(isString, arr) {\n if (!Array.isArray(arr))\n return false;\n if (arr.length === 0)\n return true;\n if (isString) {\n return arr.every((item) => typeof item === 'string');\n }\n else {\n return arr.every((item) => Number.isSafeInteger(item));\n }\n}\nfunction afn(input) {\n if (typeof input !== 'function')\n throw new Error('function expected');\n return true;\n}\nfunction astr(label, input) {\n if (typeof input !== 'string')\n throw new Error(`${label}: string expected`);\n return true;\n}\nfunction anumber(n) {\n if (!Number.isSafeInteger(n))\n throw new Error(`invalid integer: ${n}`);\n}\nfunction aArr(input) {\n if (!Array.isArray(input))\n throw new Error('array expected');\n}\nfunction astrArr(label, input) {\n if (!isArrayOf(true, input))\n throw new Error(`${label}: array of strings expected`);\n}\nfunction anumArr(label, input) {\n if (!isArrayOf(false, input))\n throw new Error(`${label}: array of numbers expected`);\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction chain(...args) {\n const id = (a) => a;\n // Wrap call in closure so JIT can inline calls\n const wrap = (a, b) => (c) => a(b(c));\n // Construct chain of args[-1].encode(args[-2].encode([...]))\n const encode = args.map((x) => x.encode).reduceRight(wrap, id);\n // Construct chain of args[0].decode(args[1].decode(...))\n const decode = args.map((x) => x.decode).reduce(wrap, id);\n return { encode, decode };\n}\n/**\n * Encodes integer radix representation to array of strings using alphabet and back.\n * Could also be array of strings.\n * @__NO_SIDE_EFFECTS__\n */\nfunction alphabet(letters) {\n // mapping 1 to \"b\"\n const lettersA = typeof letters === 'string' ? letters.split('') : letters;\n const len = lettersA.length;\n astrArr('alphabet', lettersA);\n // mapping \"b\" to 1\n const indexes = new Map(lettersA.map((l, i) => [l, i]));\n return {\n encode: (digits) => {\n aArr(digits);\n return digits.map((i) => {\n if (!Number.isSafeInteger(i) || i < 0 || i >= len)\n throw new Error(`alphabet.encode: digit index outside alphabet \"${i}\". Allowed: ${letters}`);\n return lettersA[i];\n });\n },\n decode: (input) => {\n aArr(input);\n return input.map((letter) => {\n astr('alphabet.decode', letter);\n const i = indexes.get(letter);\n if (i === undefined)\n throw new Error(`Unknown letter: \"${letter}\". Allowed: ${letters}`);\n return i;\n });\n },\n };\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction join(separator = '') {\n astr('join', separator);\n return {\n encode: (from) => {\n astrArr('join.decode', from);\n return from.join(separator);\n },\n decode: (to) => {\n astr('join.decode', to);\n return to.split(separator);\n },\n };\n}\n/**\n * Pad strings array so it has integer number of bits\n * @__NO_SIDE_EFFECTS__\n */\nfunction padding(bits, chr = '=') {\n anumber(bits);\n astr('padding', chr);\n return {\n encode(data) {\n astrArr('padding.encode', data);\n while ((data.length * bits) % 8)\n data.push(chr);\n return data;\n },\n decode(input) {\n astrArr('padding.decode', input);\n let end = input.length;\n if ((end * bits) % 8)\n throw new Error('padding: invalid, string should have whole number of bytes');\n for (; end > 0 && input[end - 1] === chr; end--) {\n const last = end - 1;\n const byte = last * bits;\n if (byte % 8 === 0)\n throw new Error('padding: invalid, string has too much padding');\n }\n return input.slice(0, end);\n },\n };\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction normalize(fn) {\n afn(fn);\n return { encode: (from) => from, decode: (to) => fn(to) };\n}\n/**\n * Slow: O(n^2) time complexity\n */\nfunction convertRadix(data, from, to) {\n // base 1 is impossible\n if (from < 2)\n throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);\n if (to < 2)\n throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);\n aArr(data);\n if (!data.length)\n return [];\n let pos = 0;\n const res = [];\n const digits = Array.from(data, (d) => {\n anumber(d);\n if (d < 0 || d >= from)\n throw new Error(`invalid integer: ${d}`);\n return d;\n });\n const dlen = digits.length;\n while (true) {\n let carry = 0;\n let done = true;\n for (let i = pos; i < dlen; i++) {\n const digit = digits[i];\n const fromCarry = from * carry;\n const digitBase = fromCarry + digit;\n if (!Number.isSafeInteger(digitBase) ||\n fromCarry / from !== carry ||\n digitBase - digit !== fromCarry) {\n throw new Error('convertRadix: carry overflow');\n }\n const div = digitBase / to;\n carry = digitBase % to;\n const rounded = Math.floor(div);\n digits[i] = rounded;\n if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)\n throw new Error('convertRadix: carry overflow');\n if (!done)\n continue;\n else if (!rounded)\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 === 0 ? a : gcd(b, a % b));\nconst radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));\nconst powers = /* @__PURE__ */ (() => {\n let res = [];\n for (let i = 0; i < 40; i++)\n res.push(2 ** i);\n return res;\n})();\n/**\n * Implemented with numbers, because BigInt is 5x slower\n */\nfunction convertRadix2(data, from, to, padding) {\n aArr(data);\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; // bitwise position in current element\n const max = powers[from];\n const mask = powers[to] - 1;\n const res = [];\n for (const n of data) {\n anumber(n);\n if (n >= max)\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 const pow = powers[pos];\n if (pow === undefined)\n throw new Error('invalid carry');\n carry &= pow - 1; // clean carry, otherwise it will cause overflow\n }\n carry = (carry << (to - pos)) & mask;\n if (!padding && pos >= from)\n throw new Error('Excess padding');\n if (!padding && carry > 0)\n throw new Error(`Non-zero padding: ${carry}`);\n if (padding && pos > 0)\n res.push(carry >>> 0);\n return res;\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction radix(num) {\n anumber(num);\n const _256 = 2 ** 8;\n return {\n encode: (bytes) => {\n if (!isBytes(bytes))\n throw new Error('radix.encode input should be Uint8Array');\n return convertRadix(Array.from(bytes), _256, num);\n },\n decode: (digits) => {\n anumArr('radix.decode', digits);\n return Uint8Array.from(convertRadix(digits, num, _256));\n },\n };\n}\n/**\n * If both bases are power of same number (like `2**8 <-> 2**64`),\n * there is a linear algorithm. For now we have implementation for power-of-two bases only.\n * @__NO_SIDE_EFFECTS__\n */\nfunction radix2(bits, revPadding = false) {\n anumber(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 (!isBytes(bytes))\n throw new Error('radix2.encode input should be Uint8Array');\n return convertRadix2(Array.from(bytes), 8, bits, !revPadding);\n },\n decode: (digits) => {\n anumArr('radix2.decode', digits);\n return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));\n },\n };\n}\nfunction unsafeWrapper(fn) {\n afn(fn);\n return function (...args) {\n try {\n return fn.apply(null, args);\n }\n catch (e) { }\n };\n}\nfunction checksum(len, fn) {\n anumber(len);\n afn(fn);\n return {\n encode(data) {\n if (!isBytes(data))\n throw new Error('checksum.encode: input should be Uint8Array');\n const sum = fn(data).slice(0, len);\n const res = new Uint8Array(data.length + len);\n res.set(data);\n res.set(sum, data.length);\n return res;\n },\n decode(data) {\n if (!isBytes(data))\n throw new Error('checksum.decode: input should be Uint8Array');\n const payload = data.slice(0, -len);\n const oldChecksum = data.slice(-len);\n const newChecksum = fn(payload).slice(0, 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}\n// prettier-ignore\nexport const utils = {\n alphabet, chain, checksum, convertRadix, convertRadix2, radix, radix2, join, padding,\n};\n// RFC 4648 aka RFC 3548\n// ---------------------\n/**\n * base16 encoding from RFC 4648.\n * @example\n * ```js\n * base16.encode(Uint8Array.from([0x12, 0xab]));\n * // => '12AB'\n * ```\n */\nexport const base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));\n/**\n * base32 encoding from RFC 4648. Has padding.\n * Use `base32nopad` for unpadded version.\n * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.\n * @example\n * ```js\n * base32.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'CKVQ===='\n * base32.decode('CKVQ====');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));\n/**\n * base32 encoding from RFC 4648. No padding.\n * Use `base32` for padded version.\n * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.\n * @example\n * ```js\n * base32nopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'CKVQ'\n * base32nopad.decode('CKVQ');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32nopad = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), join(''));\n/**\n * base32 encoding from RFC 4648. Padded. Compared to ordinary `base32`, slightly different alphabet.\n * Use `base32hexnopad` for unpadded version.\n * @example\n * ```js\n * base32hex.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ALG===='\n * base32hex.decode('2ALG====');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));\n/**\n * base32 encoding from RFC 4648. No padding. Compared to ordinary `base32`, slightly different alphabet.\n * Use `base32hex` for padded version.\n * @example\n * ```js\n * base32hexnopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ALG'\n * base32hexnopad.decode('2ALG');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32hexnopad = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), join(''));\n/**\n * base32 encoding from RFC 4648. Doug Crockford's version.\n * https://www.crockford.com/base32.html\n * @example\n * ```js\n * base32crockford.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ANG'\n * base32crockford.decode('2ANG');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));\n// Built-in base64 conversion https://caniuse.com/mdn-javascript_builtins_uint8array_frombase64\n// prettier-ignore\nconst hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === 'function' &&\n typeof Uint8Array.fromBase64 === 'function')();\nconst decodeBase64Builtin = (s, isUrl) => {\n astr('base64', s);\n const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;\n const alphabet = isUrl ? 'base64url' : 'base64';\n if (s.length > 0 && !re.test(s))\n throw new Error('invalid base64');\n return Uint8Array.fromBase64(s, { alphabet, lastChunkHandling: 'strict' });\n};\n/**\n * base64 from RFC 4648. Padded.\n * Use `base64nopad` for unpadded version.\n * Also check out `base64url`, `base64urlnopad`.\n * Falls back to built-in function, when available.\n * @example\n * ```js\n * base64.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs='\n * base64.decode('Eqs=');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\n// prettier-ignore\nexport const base64 = hasBase64Builtin ? {\n encode(b) { abytes(b); return b.toBase64(); },\n decode(s) { return decodeBase64Builtin(s, false); },\n} : chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));\n/**\n * base64 from RFC 4648. No padding.\n * Use `base64` for padded version.\n * @example\n * ```js\n * base64nopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs'\n * base64nopad.decode('Eqs');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base64nopad = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), join(''));\n/**\n * base64 from RFC 4648, using URL-safe alphabet. Padded.\n * Use `base64urlnopad` for unpadded version.\n * Falls back to built-in function, when available.\n * @example\n * ```js\n * base64url.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs='\n * base64url.decode('Eqs=');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\n// prettier-ignore\nexport const base64url = hasBase64Builtin ? {\n encode(b) { abytes(b); return b.toBase64({ alphabet: 'base64url' }); },\n decode(s) { return decodeBase64Builtin(s, true); },\n} : chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));\n/**\n * base64 from RFC 4648, using URL-safe alphabet. No padding.\n * Use `base64url` for padded version.\n * @example\n * ```js\n * base64urlnopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs'\n * base64urlnopad.decode('Eqs');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base64urlnopad = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), join(''));\n// base58 code\n// -----------\nconst genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => chain(radix(58), alphabet(abc), join(''));\n/**\n * base58: base64 without ambigous characters +, /, 0, O, I, l.\n * Quadratic (O(n^2)) - so, can't be used on large inputs.\n * @example\n * ```js\n * base58.decode('01abcdef');\n * // => '3UhJW'\n * ```\n */\nexport const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');\n/**\n * base58: flickr version. Check out `base58`.\n */\nexport const base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');\n/**\n * base58: XRP version. Check out `base58`.\n */\nexport const base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz');\n// Data len (index) -> encoded block len\nconst XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11];\n/**\n * base58: XMR version. Check out `base58`.\n * Done in 8-byte blocks (which equals 11 chars in decoding). Last (non-full) block padded with '1' to size in XMR_BLOCK_LEN.\n * Block encoding significantly reduces quadratic complexity of base58.\n */\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};\n/**\n * Method, which creates base58check encoder.\n * Requires function, calculating sha256.\n */\nexport const createBase58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);\n/**\n * Use `createBase58check` instead.\n * @deprecated\n */\nexport const base58check = createBase58check;\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 % powers[30]], 30, 5, false));\n}\n/**\n * @__NO_SIDE_EFFECTS__\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 astr('bech32.encode prefix', prefix);\n if (isBytes(words))\n words = Array.from(words);\n anumArr('bech32.encode', words);\n const plen = prefix.length;\n if (plen === 0)\n throw new TypeError(`Invalid prefix length ${plen}`);\n const actualLength = plen + 7 + words.length;\n if (limit !== false && actualLength > limit)\n throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);\n const lowered = prefix.toLowerCase();\n const sum = bechChecksum(lowered, words, ENCODING_CONST);\n return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;\n }\n function decode(str, limit = 90) {\n astr('bech32.decode input', str);\n const slen = str.length;\n if (slen < 8 || (limit !== false && slen > limit))\n throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);\n // don't allow mixed case\n const lowered = str.toLowerCase();\n if (str !== lowered && str !== str.toUpperCase())\n throw new Error(`String must be lowercase or uppercase`);\n const sepIndex = lowered.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 = lowered.slice(0, sepIndex);\n const data = lowered.slice(sepIndex + 1);\n if (data.length < 6)\n throw new Error('Data must be at least 6 characters long');\n const words = BECH_ALPHABET.decode(data).slice(0, -6);\n const sum = bechChecksum(prefix, words, ENCODING_CONST);\n if (!data.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 function encodeFromBytes(prefix, bytes) {\n return encode(prefix, toWords(bytes));\n }\n return {\n encode,\n decode,\n encodeFromBytes,\n decodeToBytes,\n decodeUnsafe,\n fromWords,\n fromWordsUnsafe,\n toWords,\n };\n}\n/**\n * bech32 from BIP 173. Operates on words.\n * For high-level, check out scure-btc-signer:\n * https://github.com/paulmillr/scure-btc-signer.\n */\nexport const bech32 = genBech32('bech32');\n/**\n * bech32m from BIP 350. Operates on words.\n * It was to mitigate `bech32` weaknesses.\n * For high-level, check out scure-btc-signer:\n * https://github.com/paulmillr/scure-btc-signer.\n */\nexport const bech32m = genBech32('bech32m');\n/**\n * UTF-8-to-byte decoder. Uses built-in TextDecoder / TextEncoder.\n * @example\n * ```js\n * const b = utf8.decode(\"hey\"); // => new Uint8Array([ 104, 101, 121 ])\n * const str = utf8.encode(b); // \"hey\"\n * ```\n */\nexport const utf8 = {\n encode: (data) => new TextDecoder().decode(data),\n decode: (str) => new TextEncoder().encode(str),\n};\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\n// prettier-ignore\nconst hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === 'function' &&\n typeof Uint8Array.fromHex === 'function')();\n// prettier-ignore\nconst hexBuiltin = {\n encode(data) { abytes(data); return data.toHex(); },\n decode(s) { astr('hex', s); return Uint8Array.fromHex(s); },\n};\n/**\n * hex string decoder. Uses built-in function, when available.\n * @example\n * ```js\n * const b = hex.decode(\"0102ff\"); // => new Uint8Array([ 1, 2, 255 ])\n * const str = hex.encode(b); // \"0102ff\"\n * ```\n */\nexport const hex = hasHexBuiltin\n ? hexBuiltin\n : chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize((s) => {\n if (typeof s !== 'string' || s.length % 2 !== 0)\n throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);\n return s.toLowerCase();\n }));\n// prettier-ignore\nconst CODERS = {\n utf8, hex, base16, base32, base64, base64url, base58, base58xmr\n};\nconst coderTypeError = 'Invalid encoding type. Available types: utf8, hex, base16, base32, base64, base64url, base58, base58xmr';\n/** @deprecated */\nexport const bytesToString = (type, bytes) => {\n if (typeof type !== 'string' || !CODERS.hasOwnProperty(type))\n throw new TypeError(coderTypeError);\n if (!isBytes(bytes))\n throw new TypeError('bytesToString() expects Uint8Array');\n return CODERS[type].encode(bytes);\n};\n/** @deprecated */\nexport const str = bytesToString; // as in python, but for bytes only\n/** @deprecated */\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};\n/** @deprecated */\nexport const bytes = stringToBytes;\n//# sourceMappingURL=index.js.map","/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */\nexport function isBytes(a) {\n return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is positive integer. */\nexport function anumber(n, title = '') {\n if (!Number.isSafeInteger(n) || n < 0) {\n const prefix = title && `\"${title}\" `;\n throw new Error(`${prefix}expected integer >= 0, got ${n}`);\n }\n}\n/** Asserts something is Uint8Array. */\nexport function abytes(value, length, title = '') {\n const bytes = isBytes(value);\n const len = value?.length;\n const needsLen = length !== undefined;\n if (!bytes || (needsLen && len !== length)) {\n const prefix = title && `\"${title}\" `;\n const ofLen = needsLen ? ` of length ${length}` : '';\n const got = bytes ? `length=${len}` : `type=${typeof value}`;\n throw new Error(prefix + 'expected Uint8Array' + ofLen + ', got ' + got);\n }\n return value;\n}\n/** Asserts something is hash */\nexport function ahash(h) {\n if (typeof h !== 'function' || typeof h.create !== 'function')\n throw new Error('Hash must wrapped by utils.createHasher');\n anumber(h.outputLen);\n anumber(h.blockLen);\n}\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(instance, checkFinished = true) {\n if (instance.destroyed)\n throw new Error('Hash instance has been destroyed');\n if (checkFinished && instance.finished)\n throw new Error('Hash#digest() has already been called');\n}\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out, instance) {\n abytes(out, undefined, 'digestInto() output');\n const min = instance.outputLen;\n if (out.length < min) {\n throw new Error('\"digestInto() output\" expected to be of length >=' + min);\n }\n}\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr) {\n return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr) {\n return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays) {\n for (let i = 0; i < arrays.length; i++) {\n arrays[i].fill(0);\n }\n}\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr) {\n return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word, shift) {\n return (word << (32 - shift)) | (word >>> shift);\n}\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word, shift) {\n return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/** The byte swap operation for uint32 */\nexport function byteSwap(word) {\n return (((word << 24) & 0xff000000) |\n ((word << 8) & 0xff0000) |\n ((word >>> 8) & 0xff00) |\n ((word >>> 24) & 0xff));\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const swap8IfBE = isLE\n ? (n) => n\n : (n) => byteSwap(n);\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr) {\n for (let i = 0; i < arr.length; i++) {\n arr[i] = byteSwap(arr[i]);\n }\n return arr;\n}\nexport const swap32IfBE = isLE\n ? (u) => u\n : byteSwap32;\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = /* @__PURE__ */ (() => \n// @ts-ignore\ntypeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n abytes(bytes);\n // @ts-ignore\n if (hasHexBuiltin)\n return bytes.toHex();\n // pre-caching improves the speed 6x\n let hex = '';\n for (let i = 0; i < bytes.length; i++) {\n hex += hexes[bytes[i]];\n }\n return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n if (ch >= asciis._0 && ch <= asciis._9)\n return ch - asciis._0; // '2' => 50-48\n if (ch >= asciis.A && ch <= asciis.F)\n return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n if (ch >= asciis.a && ch <= asciis.f)\n return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n return;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n if (typeof hex !== 'string')\n throw new Error('hex string expected, got ' + typeof hex);\n // @ts-ignore\n if (hasHexBuiltin)\n return Uint8Array.fromHex(hex);\n const hl = hex.length;\n const al = hl / 2;\n if (hl % 2)\n throw new Error('hex string expected, got unpadded hex of length ' + hl);\n const array = new Uint8Array(al);\n for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n const n1 = asciiToBase16(hex.charCodeAt(hi));\n const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n if (n1 === undefined || n2 === undefined) {\n const char = hex[hi] + hex[hi + 1];\n throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n }\n array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n }\n return array;\n}\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * Call of async fn will return Promise, which will be fullfiled only on\n * next scheduler queue processing step and this is exactly what we need.\n */\nexport const nextTick = async () => { };\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async function asyncLoop(iters, tick, cb) {\n let ts = Date.now();\n for (let i = 0; i < iters; i++) {\n cb(i);\n // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n const diff = Date.now() - ts;\n if (diff >= 0 && diff < tick)\n continue;\n await nextTick();\n ts += diff;\n }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * Built-in doesn't validate input to be string: we do the check.\n * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n if (typeof str !== 'string')\n throw new Error('string expected');\n return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Helper for KDFs: consumes uint8array or string.\n * When string is passed, does utf8 decoding, using TextDecoder.\n */\nexport function kdfInputToBytes(data, errorTitle = '') {\n if (typeof data === 'string')\n return utf8ToBytes(data);\n return abytes(data, undefined, errorTitle);\n}\n/** Copies several Uint8Arrays into one. */\nexport function concatBytes(...arrays) {\n let sum = 0;\n for (let i = 0; i < arrays.length; i++) {\n const a = arrays[i];\n abytes(a);\n sum += a.length;\n }\n const res = new Uint8Array(sum);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const a = arrays[i];\n res.set(a, pad);\n pad += a.length;\n }\n return res;\n}\n/** Merges default options and passed options. */\nexport function checkOpts(defaults, opts) {\n if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n throw new Error('options must be object or undefined');\n const merged = Object.assign(defaults, opts);\n return merged;\n}\n/** Creates function with outputLen, blockLen, create properties from a class constructor. */\nexport function createHasher(hashCons, info = {}) {\n const hashC = (msg, opts) => hashCons(opts).update(msg).digest();\n const tmp = hashCons(undefined);\n hashC.outputLen = tmp.outputLen;\n hashC.blockLen = tmp.blockLen;\n hashC.create = (opts) => hashCons(opts);\n Object.assign(hashC, info);\n return Object.freeze(hashC);\n}\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n const cr = typeof globalThis === 'object' ? globalThis.crypto : null;\n if (typeof cr?.getRandomValues !== 'function')\n throw new Error('crypto.getRandomValues must be defined');\n return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n/** Creates OID opts for NIST hashes, with prefix 06 09 60 86 48 01 65 03 04 02. */\nexport const oidNist = (suffix) => ({\n oid: Uint8Array.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, suffix]),\n});\n//# sourceMappingURL=utils.js.map","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { abytes, aexists, aoutput, clean, createView } from \"./utils.js\";\n/** Choice: a ? b : c */\nexport function Chi(a, b, c) {\n return (a & b) ^ (~a & c);\n}\n/** Majority function, true if any two inputs is true. */\nexport function Maj(a, b, c) {\n return (a & b) ^ (a & c) ^ (b & c);\n}\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n */\nexport class HashMD {\n blockLen;\n outputLen;\n padOffset;\n isLE;\n // For partial updates less than block size\n buffer;\n view;\n finished = false;\n length = 0;\n pos = 0;\n destroyed = false;\n constructor(blockLen, outputLen, padOffset, isLE) {\n this.blockLen = blockLen;\n this.outputLen = outputLen;\n this.padOffset = padOffset;\n this.isLE = isLE;\n this.buffer = new Uint8Array(blockLen);\n this.view = createView(this.buffer);\n }\n update(data) {\n aexists(this);\n abytes(data);\n const { view, buffer, blockLen } = this;\n const len = data.length;\n for (let pos = 0; pos < len;) {\n const take = Math.min(blockLen - this.pos, len - pos);\n // Fast path: we have at least one block in input, cast it to view and process\n if (take === blockLen) {\n const dataView = createView(data);\n for (; blockLen <= len - pos; pos += blockLen)\n this.process(dataView, pos);\n continue;\n }\n buffer.set(data.subarray(pos, pos + take), this.pos);\n this.pos += take;\n pos += take;\n if (this.pos === blockLen) {\n this.process(view, 0);\n this.pos = 0;\n }\n }\n this.length += data.length;\n this.roundClean();\n return this;\n }\n digestInto(out) {\n aexists(this);\n aoutput(out, this);\n this.finished = true;\n // Padding\n // We can avoid allocation of buffer for padding completely if it\n // was previously not allocated here. But it won't change performance.\n const { buffer, view, blockLen, isLE } = this;\n let { pos } = this;\n // append the bit '1' to the message\n buffer[pos++] = 0b10000000;\n clean(this.buffer.subarray(pos));\n // we have less than padOffset left in buffer, so we cannot put length in\n // current block, need process it and pad again\n if (this.padOffset > blockLen - pos) {\n this.process(view, 0);\n pos = 0;\n }\n // Pad until full block byte with zeros\n for (let i = pos; i < blockLen; i++)\n buffer[i] = 0;\n // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n // So we just write lowest 64 bits of that value.\n view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);\n this.process(view, 0);\n const oview = createView(out);\n const len = this.outputLen;\n // NOTE: we do division by 4 later, which must be fused in single op with modulo by JIT\n if (len % 4)\n throw new Error('_sha2: outputLen must be aligned to 32bit');\n const outLen = len / 4;\n const state = this.get();\n if (outLen > state.length)\n throw new Error('_sha2: outputLen bigger than state');\n for (let i = 0; i < outLen; i++)\n oview.setUint32(4 * i, state[i], isLE);\n }\n digest() {\n const { buffer, outputLen } = this;\n this.digestInto(buffer);\n const res = buffer.slice(0, outputLen);\n this.destroy();\n return res;\n }\n _cloneInto(to) {\n to ||= new this.constructor();\n to.set(...this.get());\n const { blockLen, buffer, length, finished, destroyed, pos } = this;\n to.destroyed = destroyed;\n to.finished = finished;\n to.length = length;\n to.pos = pos;\n if (length % blockLen)\n to.buffer.set(buffer);\n return to;\n }\n clone() {\n return this._cloneInto();\n }\n}\n/**\n * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.\n * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.\n */\n/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */\nexport const SHA256_IV = /* @__PURE__ */ Uint32Array.from([\n 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */\nexport const SHA224_IV = /* @__PURE__ */ Uint32Array.from([\n 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */\nexport const SHA384_IV = /* @__PURE__ */ Uint32Array.from([\n 0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,\n 0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,\n]);\n/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */\nexport const SHA512_IV = /* @__PURE__ */ Uint32Array.from([\n 0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,\n 0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,\n]);\n//# sourceMappingURL=_md.js.map","/**\n * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.\n * SHA256 is the fastest hash implementable in JS, even faster than Blake3.\n * Check out [RFC 4634](https://www.rfc-editor.org/rfc/rfc4634) and\n * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\nimport { clean, createHasher, oidNist, rotr } from \"./utils.js\";\n/**\n * Round constants:\n * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)\n */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ Uint32Array.from([\n 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n/** Reusable temporary buffer. \"W\" comes straight from spec. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\n/** Internal 32-byte base SHA2 hash class. */\nclass SHA2_32B extends HashMD {\n constructor(outputLen) {\n super(64, outputLen, 8, false);\n }\n get() {\n const { A, B, C, D, E, F, G, H } = this;\n return [A, B, C, D, E, F, G, H];\n }\n // prettier-ignore\n set(A, B, C, D, E, F, G, H) {\n this.A = A | 0;\n this.B = B | 0;\n this.C = C | 0;\n this.D = D | 0;\n this.E = E | 0;\n this.F = F | 0;\n this.G = G | 0;\n this.H = H | 0;\n }\n process(view, offset) {\n // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n for (let i = 0; i < 16; i++, offset += 4)\n SHA256_W[i] = view.getUint32(offset, false);\n for (let i = 16; i < 64; i++) {\n const W15 = SHA256_W[i - 15];\n const W2 = SHA256_W[i - 2];\n const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n }\n // Compression function main loop, 64 rounds\n let { A, B, C, D, E, F, G, H } = this;\n for (let i = 0; i < 64; i++) {\n const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n const T2 = (sigma0 + Maj(A, B, C)) | 0;\n H = G;\n G = F;\n F = E;\n E = (D + T1) | 0;\n D = C;\n C = B;\n B = A;\n A = (T1 + T2) | 0;\n }\n // Add the compressed chunk to the current hash value\n A = (A + this.A) | 0;\n B = (B + this.B) | 0;\n C = (C + this.C) | 0;\n D = (D + this.D) | 0;\n E = (E + this.E) | 0;\n F = (F + this.F) | 0;\n G = (G + this.G) | 0;\n H = (H + this.H) | 0;\n this.set(A, B, C, D, E, F, G, H);\n }\n roundClean() {\n clean(SHA256_W);\n }\n destroy() {\n this.set(0, 0, 0, 0, 0, 0, 0, 0);\n clean(this.buffer);\n }\n}\n/** Internal SHA2-256 hash class. */\nexport class _SHA256 extends SHA2_32B {\n // We cannot use array here since array allows indexing by variable\n // which means optimizer/compiler cannot use registers.\n A = SHA256_IV[0] | 0;\n B = SHA256_IV[1] | 0;\n C = SHA256_IV[2] | 0;\n D = SHA256_IV[3] | 0;\n E = SHA256_IV[4] | 0;\n F = SHA256_IV[5] | 0;\n G = SHA256_IV[6] | 0;\n H = SHA256_IV[7] | 0;\n constructor() {\n super(32);\n }\n}\n/** Internal SHA2-224 hash class. */\nexport class _SHA224 extends SHA2_32B {\n A = SHA224_IV[0] | 0;\n B = SHA224_IV[1] | 0;\n C = SHA224_IV[2] | 0;\n D = SHA224_IV[3] | 0;\n E = SHA224_IV[4] | 0;\n F = SHA224_IV[5] | 0;\n G = SHA224_IV[6] | 0;\n H = SHA224_IV[7] | 0;\n constructor() {\n super(28);\n }\n}\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n// Round contants\n// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409\n// prettier-ignore\nconst K512 = /* @__PURE__ */ (() => u64.split([\n '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\nconst SHA512_Kh = /* @__PURE__ */ (() => K512[0])();\nconst SHA512_Kl = /* @__PURE__ */ (() => K512[1])();\n// Reusable temporary buffers\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\n/** Internal 64-byte base SHA2 hash class. */\nclass SHA2_64B extends HashMD {\n constructor(outputLen) {\n super(128, outputLen, 16, false);\n }\n // prettier-ignore\n get() {\n const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n }\n // prettier-ignore\n set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n this.Ah = Ah | 0;\n this.Al = Al | 0;\n this.Bh = Bh | 0;\n this.Bl = Bl | 0;\n this.Ch = Ch | 0;\n this.Cl = Cl | 0;\n this.Dh = Dh | 0;\n this.Dl = Dl | 0;\n this.Eh = Eh | 0;\n this.El = El | 0;\n this.Fh = Fh | 0;\n this.Fl = Fl | 0;\n this.Gh = Gh | 0;\n this.Gl = Gl | 0;\n this.Hh = Hh | 0;\n this.Hl = Hl | 0;\n }\n process(view, offset) {\n // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n for (let i = 0; i < 16; i++, offset += 4) {\n SHA512_W_H[i] = view.getUint32(offset);\n SHA512_W_L[i] = view.getUint32((offset += 4));\n }\n for (let i = 16; i < 80; i++) {\n // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n const W15h = SHA512_W_H[i - 15] | 0;\n const W15l = SHA512_W_L[i - 15] | 0;\n const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n const W2h = SHA512_W_H[i - 2] | 0;\n const W2l = SHA512_W_L[i - 2] | 0;\n const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n SHA512_W_H[i] = SUMh | 0;\n SHA512_W_L[i] = SUMl | 0;\n }\n let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n // Compression function main loop, 80 rounds\n for (let i = 0; i < 80; i++) {\n // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n const CHIl = (El & Fl) ^ (~El & Gl);\n // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n // prettier-ignore\n const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n const T1l = T1ll | 0;\n // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n Hh = Gh | 0;\n Hl = Gl | 0;\n Gh = Fh | 0;\n Gl = Fl | 0;\n Fh = Eh | 0;\n Fl = El | 0;\n ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n Dh = Ch | 0;\n Dl = Cl | 0;\n Ch = Bh | 0;\n Cl = Bl | 0;\n Bh = Ah | 0;\n Bl = Al | 0;\n const All = u64.add3L(T1l, sigma0l, MAJl);\n Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n Al = All | 0;\n }\n // Add the compressed chunk to the current hash value\n ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n }\n roundClean() {\n clean(SHA512_W_H, SHA512_W_L);\n }\n destroy() {\n clean(this.buffer);\n this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n }\n}\n/** Internal SHA2-512 hash class. */\nexport class _SHA512 extends SHA2_64B {\n Ah = SHA512_IV[0] | 0;\n Al = SHA512_IV[1] | 0;\n Bh = SHA512_IV[2] | 0;\n Bl = SHA512_IV[3] | 0;\n Ch = SHA512_IV[4] | 0;\n Cl = SHA512_IV[5] | 0;\n Dh = SHA512_IV[6] | 0;\n Dl = SHA512_IV[7] | 0;\n Eh = SHA512_IV[8] | 0;\n El = SHA512_IV[9] | 0;\n Fh = SHA512_IV[10] | 0;\n Fl = SHA512_IV[11] | 0;\n Gh = SHA512_IV[12] | 0;\n Gl = SHA512_IV[13] | 0;\n Hh = SHA512_IV[14] | 0;\n Hl = SHA512_IV[15] | 0;\n constructor() {\n super(64);\n }\n}\n/** Internal SHA2-384 hash class. */\nexport class _SHA384 extends SHA2_64B {\n Ah = SHA384_IV[0] | 0;\n Al = SHA384_IV[1] | 0;\n Bh = SHA384_IV[2] | 0;\n Bl = SHA384_IV[3] | 0;\n Ch = SHA384_IV[4] | 0;\n Cl = SHA384_IV[5] | 0;\n Dh = SHA384_IV[6] | 0;\n Dl = SHA384_IV[7] | 0;\n Eh = SHA384_IV[8] | 0;\n El = SHA384_IV[9] | 0;\n Fh = SHA384_IV[10] | 0;\n Fl = SHA384_IV[11] | 0;\n Gh = SHA384_IV[12] | 0;\n Gl = SHA384_IV[13] | 0;\n Hh = SHA384_IV[14] | 0;\n Hl = SHA384_IV[15] | 0;\n constructor() {\n super(48);\n }\n}\n/**\n * Truncated SHA512/256 and SHA512/224.\n * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as \"intermediary\" IV of SHA512/t.\n * Then t hashes string to produce result IV.\n * See `test/misc/sha2-gen-iv.js`.\n */\n/** SHA512/224 IV */\nconst T224_IV = /* @__PURE__ */ Uint32Array.from([\n 0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,\n 0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,\n]);\n/** SHA512/256 IV */\nconst T256_IV = /* @__PURE__ */ Uint32Array.from([\n 0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,\n 0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,\n]);\n/** Internal SHA2-512/224 hash class. */\nexport class _SHA512_224 extends SHA2_64B {\n Ah = T224_IV[0] | 0;\n Al = T224_IV[1] | 0;\n Bh = T224_IV[2] | 0;\n Bl = T224_IV[3] | 0;\n Ch = T224_IV[4] | 0;\n Cl = T224_IV[5] | 0;\n Dh = T224_IV[6] | 0;\n Dl = T224_IV[7] | 0;\n Eh = T224_IV[8] | 0;\n El = T224_IV[9] | 0;\n Fh = T224_IV[10] | 0;\n Fl = T224_IV[11] | 0;\n Gh = T224_IV[12] | 0;\n Gl = T224_IV[13] | 0;\n Hh = T224_IV[14] | 0;\n Hl = T224_IV[15] | 0;\n constructor() {\n super(28);\n }\n}\n/** Internal SHA2-512/256 hash class. */\nexport class _SHA512_256 extends SHA2_64B {\n Ah = T256_IV[0] | 0;\n Al = T256_IV[1] | 0;\n Bh = T256_IV[2] | 0;\n Bl = T256_IV[3] | 0;\n Ch = T256_IV[4] | 0;\n Cl = T256_IV[5] | 0;\n Dh = T256_IV[6] | 0;\n Dl = T256_IV[7] | 0;\n Eh = T256_IV[8] | 0;\n El = T256_IV[9] | 0;\n Fh = T256_IV[10] | 0;\n Fl = T256_IV[11] | 0;\n Gh = T256_IV[12] | 0;\n Gl = T256_IV[13] | 0;\n Hh = T256_IV[14] | 0;\n Hl = T256_IV[15] | 0;\n constructor() {\n super(32);\n }\n}\n/**\n * SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:\n *\n * - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.\n * - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n * - Each sha256 hash is executing 2^18 bit operations.\n * - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new _SHA256(), \n/* @__PURE__ */ oidNist(0x01));\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new _SHA224(), \n/* @__PURE__ */ oidNist(0x04));\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new _SHA512(), \n/* @__PURE__ */ oidNist(0x03));\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new _SHA384(), \n/* @__PURE__ */ oidNist(0x02));\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_256 = /* @__PURE__ */ createHasher(() => new _SHA512_256(), \n/* @__PURE__ */ oidNist(0x06));\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_224 = /* @__PURE__ */ createHasher(() => new _SHA512_224(), \n/* @__PURE__ */ oidNist(0x05));\n//# sourceMappingURL=sha2.js.map","/**\n * Hex, bytes and number utilities.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { abytes as abytes_, anumber, bytesToHex as bytesToHex_, concatBytes as concatBytes_, hexToBytes as hexToBytes_, } from '@noble/hashes/utils.js';\nexport { abytes, anumber, bytesToHex, concatBytes, hexToBytes, isBytes, randomBytes, } from '@noble/hashes/utils.js';\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function abool(value, title = '') {\n if (typeof value !== 'boolean') {\n const prefix = title && `\"${title}\" `;\n throw new Error(prefix + 'expected boolean, got type=' + typeof value);\n }\n return value;\n}\n// Used in weierstrass, der\nfunction abignumber(n) {\n if (typeof n === 'bigint') {\n if (!isPosBig(n))\n throw new Error('positive bigint expected, got ' + n);\n }\n else\n anumber(n);\n return n;\n}\nexport function asafenumber(value, title = '') {\n if (!Number.isSafeInteger(value)) {\n const prefix = title && `\"${title}\" `;\n throw new Error(prefix + 'expected safe integer, got type=' + typeof value);\n }\n}\nexport function numberToHexUnpadded(num) {\n const hex = abignumber(num).toString(16);\n return hex.length & 1 ? '0' + hex : hex;\n}\nexport function hexToNumber(hex) {\n if (typeof hex !== 'string')\n throw new Error('hex string expected, got ' + typeof hex);\n return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n return hexToNumber(bytesToHex_(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n return hexToNumber(bytesToHex_(copyBytes(abytes_(bytes)).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n anumber(len);\n n = abignumber(n);\n const res = hexToBytes_(n.toString(16).padStart(len * 2, '0'));\n if (res.length !== len)\n throw new Error('number too large');\n return res;\n}\nexport function numberToBytesLE(n, len) {\n return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n return hexToBytes_(numberToHexUnpadded(abignumber(n)));\n}\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a, b) {\n if (a.length !== b.length)\n return false;\n let diff = 0;\n for (let i = 0; i < a.length; i++)\n diff |= a[i] ^ b[i];\n return diff === 0;\n}\n/**\n * Copies Uint8Array. We can't use u8a.slice(), because u8a can be Buffer,\n * and Buffer#slice creates mutable copy. Never use Buffers!\n */\nexport function copyBytes(bytes) {\n return Uint8Array.from(bytes);\n}\n/**\n * Decodes 7-bit ASCII string to Uint8Array, throws on non-ascii symbols\n * Should be safe to use for things expected to be ASCII.\n * Returns exact same result as `TextEncoder` for ASCII or throws.\n */\nexport function asciiToBytes(ascii) {\n return Uint8Array.from(ascii, (c, i) => {\n const charCode = c.charCodeAt(0);\n if (c.length !== 1 || charCode > 127) {\n throw new Error(`string contains non-ASCII character \"${ascii[i]}\" with code ${charCode} at position ${i}`);\n }\n return charCode;\n });\n}\n// Is positive bigint\nconst isPosBig = (n) => typeof n === 'bigint' && _0n <= n;\nexport function inRange(n, min, max) {\n return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;\n}\n/**\n * Asserts min <= n < max. NOTE: It's < max and not <= max.\n * @example\n * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)\n */\nexport function aInRange(title, n, min, max) {\n // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?\n // consider P=256n, min=0n, max=P\n // - a for min=0 would require -1: `inRange('x', x, -1n, P)`\n // - b would commonly require subtraction: `inRange('x', x, 0n, P - 1n)`\n // - our way is the cleanest: `inRange('x', x, 0n, P)\n if (!inRange(n, min, max))\n throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n * TODO: merge with nLength in modular\n */\nexport function bitLen(n) {\n let len;\n for (len = 0; n > _0n; n >>= _1n, len += 1)\n ;\n return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport function bitSet(n, pos, value) {\n return n | ((value ? _1n : _0n) << BigInt(pos));\n}\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_1n << BigInt(n)) - _1n;\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n * const drbg = createHmacDRBG(32, 32, hmac);\n * drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n anumber(hashLen, 'hashLen');\n anumber(qByteLen, 'qByteLen');\n if (typeof hmacFn !== 'function')\n throw new Error('hmacFn must be a function');\n const u8n = (len) => new Uint8Array(len); // creates Uint8Array\n const NULL = Uint8Array.of();\n const byte0 = Uint8Array.of(0x00);\n const byte1 = Uint8Array.of(0x01);\n const _maxDrbgIters = 1000;\n // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n let i = 0; // Iterations counter, will throw when over 1000\n const reset = () => {\n v.fill(1);\n k.fill(0);\n i = 0;\n };\n const h = (...msgs) => hmacFn(k, concatBytes_(v, ...msgs)); // hmac(k)(v, ...values)\n const reseed = (seed = NULL) => {\n // HMAC-DRBG reseed() function. Steps D-G\n k = h(byte0, seed); // k = hmac(k || v || 0x00 || seed)\n v = h(); // v = hmac(k || v)\n if (seed.length === 0)\n return;\n k = h(byte1, seed); // k = hmac(k || v || 0x01 || seed)\n v = h(); // v = hmac(k || v)\n };\n const gen = () => {\n // HMAC-DRBG generate() function\n if (i++ >= _maxDrbgIters)\n throw new Error('drbg: tried max amount of iterations');\n let len = 0;\n const out = [];\n while (len < qByteLen) {\n v = h();\n const sl = v.slice();\n out.push(sl);\n len += v.length;\n }\n return concatBytes_(...out);\n };\n const genUntil = (seed, pred) => {\n reset();\n reseed(seed); // Steps D-G\n let res = undefined; // Step H: grind until k is in [1..n-1]\n while (!(res = pred(gen())))\n reseed();\n reset();\n return res;\n };\n return genUntil;\n}\nexport function validateObject(object, fields = {}, optFields = {}) {\n if (!object || typeof object !== 'object')\n throw new Error('expected valid options object');\n function checkField(fieldName, expectedType, isOpt) {\n const val = object[fieldName];\n if (isOpt && val === undefined)\n return;\n const current = typeof val;\n if (current !== expectedType || val === null)\n throw new Error(`param \"${fieldName}\" is invalid: expected ${expectedType}, got ${current}`);\n }\n const iter = (f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));\n iter(fields, false);\n iter(optFields, true);\n}\n/**\n * throws not implemented error\n */\nexport const notImplemented = () => {\n throw new Error('not implemented');\n};\n/**\n * Memoizes (caches) computation result.\n * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.\n */\nexport function memoized(fn) {\n const map = new WeakMap();\n return (arg, ...args) => {\n const val = map.get(arg);\n if (val !== undefined)\n return val;\n const computed = fn(arg, ...args);\n map.set(arg, computed);\n return computed;\n };\n}\n//# sourceMappingURL=utils.js.map","/**\n * Utils for modular division and fields.\n * Field over 11 is a finite (Galois) field is integer number operations `mod 11`.\n * There is no division: it is replaced by modular multiplicative inverse.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { abytes, anumber, bytesToNumberBE, bytesToNumberLE, numberToBytesBE, numberToBytesLE, validateObject, } from \"../utils.js\";\n// Numbers aren't used in x25519 / x448 builds\n// prettier-ignore\nconst _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2);\n// prettier-ignore\nconst _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5);\n// prettier-ignore\nconst _7n = /* @__PURE__ */ BigInt(7), _8n = /* @__PURE__ */ BigInt(8), _9n = /* @__PURE__ */ BigInt(9);\nconst _16n = /* @__PURE__ */ BigInt(16);\n// Calculates a modulo b\nexport function mod(a, b) {\n const result = a % b;\n return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\nexport function pow(num, power, modulo) {\n return FpPow(Field(modulo), num, power);\n}\n/** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */\nexport function pow2(x, power, modulo) {\n let res = x;\n while (power-- > _0n) {\n res *= res;\n res %= modulo;\n }\n return res;\n}\n/**\n * Inverses number over modulo.\n * Implemented using [Euclidean GCD](https://brilliant.org/wiki/extended-euclidean-algorithm/).\n */\nexport function invert(number, modulo) {\n if (number === _0n)\n throw new Error('invert: expected non-zero number');\n if (modulo <= _0n)\n throw new Error('invert: expected positive modulus, got ' + modulo);\n // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n let a = mod(number, modulo);\n let b = modulo;\n // prettier-ignore\n let x = _0n, y = _1n, u = _1n, v = _0n;\n while (a !== _0n) {\n // JIT applies optimization if those two lines follow each other\n const q = b / a;\n const r = b % a;\n const m = x - u * q;\n const n = y - v * q;\n // prettier-ignore\n b = a, a = r, x = u, y = v, u = m, v = n;\n }\n const gcd = b;\n if (gcd !== _1n)\n throw new Error('invert: does not exist');\n return mod(x, modulo);\n}\nfunction assertIsSquare(Fp, root, n) {\n if (!Fp.eql(Fp.sqr(root), n))\n throw new Error('Cannot find square root');\n}\n// Not all roots are possible! Example which will throw:\n// const NUM =\n// n = 72057594037927816n;\n// Fp = Field(BigInt('0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'));\nfunction sqrt3mod4(Fp, n) {\n const p1div4 = (Fp.ORDER + _1n) / _4n;\n const root = Fp.pow(n, p1div4);\n assertIsSquare(Fp, root, n);\n return root;\n}\nfunction sqrt5mod8(Fp, n) {\n const p5div8 = (Fp.ORDER - _5n) / _8n;\n const n2 = Fp.mul(n, _2n);\n const v = Fp.pow(n2, p5div8);\n const nv = Fp.mul(n, v);\n const i = Fp.mul(Fp.mul(nv, _2n), v);\n const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n assertIsSquare(Fp, root, n);\n return root;\n}\n// Based on RFC9380, Kong algorithm\n// prettier-ignore\nfunction sqrt9mod16(P) {\n const Fp_ = Field(P);\n const tn = tonelliShanks(P);\n const c1 = tn(Fp_, Fp_.neg(Fp_.ONE)); // 1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n const c2 = tn(Fp_, c1); // 2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n const c3 = tn(Fp_, Fp_.neg(c1)); // 3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n const c4 = (P + _7n) / _16n; // 4. c4 = (q + 7) / 16 # Integer arithmetic\n return (Fp, n) => {\n let tv1 = Fp.pow(n, c4); // 1. tv1 = x^c4\n let tv2 = Fp.mul(tv1, c1); // 2. tv2 = c1 * tv1\n const tv3 = Fp.mul(tv1, c2); // 3. tv3 = c2 * tv1\n const tv4 = Fp.mul(tv1, c3); // 4. tv4 = c3 * tv1\n const e1 = Fp.eql(Fp.sqr(tv2), n); // 5. e1 = (tv2^2) == x\n const e2 = Fp.eql(Fp.sqr(tv3), n); // 6. e2 = (tv3^2) == x\n tv1 = Fp.cmov(tv1, tv2, e1); // 7. tv1 = CMOV(tv1, tv2, e1) # Select tv2 if (tv2^2) == x\n tv2 = Fp.cmov(tv4, tv3, e2); // 8. tv2 = CMOV(tv4, tv3, e2) # Select tv3 if (tv3^2) == x\n const e3 = Fp.eql(Fp.sqr(tv2), n); // 9. e3 = (tv2^2) == x\n const root = Fp.cmov(tv1, tv2, e3); // 10. z = CMOV(tv1, tv2, e3) # Select sqrt from tv1 & tv2\n assertIsSquare(Fp, root, n);\n return root;\n };\n}\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P) {\n // Initialization (precomputation).\n // Caching initialization could boost perf by 7%.\n if (P < _3n)\n throw new Error('sqrt is not defined for small field');\n // Factor P - 1 = Q * 2^S, where Q is odd\n let Q = P - _1n;\n let S = 0;\n while (Q % _2n === _0n) {\n Q /= _2n;\n S++;\n }\n // Find the first quadratic non-residue Z >= 2\n let Z = _2n;\n const _Fp = Field(P);\n while (FpLegendre(_Fp, Z) === 1) {\n // Basic primality test for P. After x iterations, chance of\n // not finding quadratic non-residue is 2^x, so 2^1000.\n if (Z++ > 1000)\n throw new Error('Cannot find square root: probably non-prime P');\n }\n // Fast-path; usually done before Z, but we do \"primality test\".\n if (S === 1)\n return sqrt3mod4;\n // Slow-path\n // TODO: test on Fp2 and others\n let cc = _Fp.pow(Z, Q); // c = z^Q\n const Q1div2 = (Q + _1n) / _2n;\n return function tonelliSlow(Fp, n) {\n if (Fp.is0(n))\n return n;\n // Check if n is a quadratic residue using Legendre symbol\n if (FpLegendre(Fp, n) !== 1)\n throw new Error('Cannot find square root');\n // Initialize variables for the main loop\n let M = S;\n let c = Fp.mul(Fp.ONE, cc); // c = z^Q, move cc from field _Fp into field Fp\n let t = Fp.pow(n, Q); // t = n^Q, first guess at the fudge factor\n let R = Fp.pow(n, Q1div2); // R = n^((Q+1)/2), first guess at the square root\n // Main loop\n // while t != 1\n while (!Fp.eql(t, Fp.ONE)) {\n if (Fp.is0(t))\n return Fp.ZERO; // if t=0 return R=0\n let i = 1;\n // Find the smallest i >= 1 such that t^(2^i) ≡ 1 (mod P)\n let t_tmp = Fp.sqr(t); // t^(2^1)\n while (!Fp.eql(t_tmp, Fp.ONE)) {\n i++;\n t_tmp = Fp.sqr(t_tmp); // t^(2^2)...\n if (i === M)\n throw new Error('Cannot find square root');\n }\n // Calculate the exponent for b: 2^(M - i - 1)\n const exponent = _1n << BigInt(M - i - 1); // bigint is important\n const b = Fp.pow(c, exponent); // b = 2^(M - i - 1)\n // Update variables\n M = i;\n c = Fp.sqr(b); // c = b^2\n t = Fp.mul(t, c); // t = (t * b^2)\n R = Fp.mul(R, b); // R = R*b\n }\n return R;\n };\n}\n/**\n * Square root for a finite field. Will try optimized versions first:\n *\n * 1. P ≡ 3 (mod 4)\n * 2. P ≡ 5 (mod 8)\n * 3. P ≡ 9 (mod 16)\n * 4. Tonelli-Shanks algorithm\n *\n * Different algorithms can give different roots, it is up to user to decide which one they want.\n * For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n */\nexport function FpSqrt(P) {\n // P ≡ 3 (mod 4) => √n = n^((P+1)/4)\n if (P % _4n === _3n)\n return sqrt3mod4;\n // P ≡ 5 (mod 8) => Atkin algorithm, page 10 of https://eprint.iacr.org/2012/685.pdf\n if (P % _8n === _5n)\n return sqrt5mod8;\n // P ≡ 9 (mod 16) => Kong algorithm, page 11 of https://eprint.iacr.org/2012/685.pdf (algorithm 4)\n if (P % _16n === _9n)\n return sqrt9mod16(P);\n // Tonelli-Shanks algorithm\n return tonelliShanks(P);\n}\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;\n// prettier-ignore\nconst FIELD_FIELDS = [\n 'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n 'eql', 'add', 'sub', 'mul', 'pow', 'div',\n 'addN', 'subN', 'mulN', 'sqrN'\n];\nexport function validateField(field) {\n const initial = {\n ORDER: 'bigint',\n BYTES: 'number',\n BITS: 'number',\n };\n const opts = FIELD_FIELDS.reduce((map, val) => {\n map[val] = 'function';\n return map;\n }, initial);\n validateObject(field, opts);\n // const max = 16384;\n // if (field.BYTES < 1 || field.BYTES > max) throw new Error('invalid field');\n // if (field.BITS < 1 || field.BITS > 8 * max) throw new Error('invalid field');\n return field;\n}\n// Generic field functions\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow(Fp, num, power) {\n if (power < _0n)\n throw new Error('invalid exponent, negatives unsupported');\n if (power === _0n)\n return Fp.ONE;\n if (power === _1n)\n return num;\n let p = Fp.ONE;\n let d = num;\n while (power > _0n) {\n if (power & _1n)\n p = Fp.mul(p, d);\n d = Fp.sqr(d);\n power >>= _1n;\n }\n return p;\n}\n/**\n * Efficiently invert an array of Field elements.\n * Exception-free. Will return `undefined` for 0 elements.\n * @param passZero map 0 to 0 (instead of undefined)\n */\nexport function FpInvertBatch(Fp, nums, passZero = false) {\n const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : undefined);\n // Walk from first to last, multiply them by each other MOD p\n const multipliedAcc = nums.reduce((acc, num, i) => {\n if (Fp.is0(num))\n return acc;\n inverted[i] = acc;\n return Fp.mul(acc, num);\n }, Fp.ONE);\n // Invert last element\n const invertedAcc = Fp.inv(multipliedAcc);\n // Walk from last to first, multiply them by inverted each other MOD p\n nums.reduceRight((acc, num, i) => {\n if (Fp.is0(num))\n return acc;\n inverted[i] = Fp.mul(acc, inverted[i]);\n return Fp.mul(acc, num);\n }, invertedAcc);\n return inverted;\n}\n// TODO: remove\nexport function FpDiv(Fp, lhs, rhs) {\n return Fp.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, Fp.ORDER) : Fp.inv(rhs));\n}\n/**\n * Legendre symbol.\n * Legendre constant is used to calculate Legendre symbol (a | p)\n * which denotes the value of a^((p-1)/2) (mod p).\n *\n * * (a | p) ≡ 1 if a is a square (mod p), quadratic residue\n * * (a | p) ≡ -1 if a is not a square (mod p), quadratic non residue\n * * (a | p) ≡ 0 if a ≡ 0 (mod p)\n */\nexport function FpLegendre(Fp, n) {\n // We can use 3rd argument as optional cache of this value\n // but seems unneeded for now. The operation is very fast.\n const p1mod2 = (Fp.ORDER - _1n) / _2n;\n const powered = Fp.pow(n, p1mod2);\n const yes = Fp.eql(powered, Fp.ONE);\n const zero = Fp.eql(powered, Fp.ZERO);\n const no = Fp.eql(powered, Fp.neg(Fp.ONE));\n if (!yes && !zero && !no)\n throw new Error('invalid Legendre symbol result');\n return yes ? 1 : zero ? 0 : -1;\n}\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare(Fp, n) {\n const l = FpLegendre(Fp, n);\n return l === 1;\n}\n// CURVE.n lengths\nexport function nLength(n, nBitLength) {\n // Bit size, byte size of CURVE.n\n if (nBitLength !== undefined)\n anumber(nBitLength);\n const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n const nByteLength = Math.ceil(_nBitLength / 8);\n return { nBitLength: _nBitLength, nByteLength };\n}\nclass _Field {\n ORDER;\n BITS;\n BYTES;\n isLE;\n ZERO = _0n;\n ONE = _1n;\n _lengths;\n _sqrt; // cached sqrt\n _mod;\n constructor(ORDER, opts = {}) {\n if (ORDER <= _0n)\n throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);\n let _nbitLength = undefined;\n this.isLE = false;\n if (opts != null && typeof opts === 'object') {\n if (typeof opts.BITS === 'number')\n _nbitLength = opts.BITS;\n if (typeof opts.sqrt === 'function')\n this.sqrt = opts.sqrt;\n if (typeof opts.isLE === 'boolean')\n this.isLE = opts.isLE;\n if (opts.allowedLengths)\n this._lengths = opts.allowedLengths?.slice();\n if (typeof opts.modFromBytes === 'boolean')\n this._mod = opts.modFromBytes;\n }\n const { nBitLength, nByteLength } = nLength(ORDER, _nbitLength);\n if (nByteLength > 2048)\n throw new Error('invalid field: expected ORDER of <= 2048 bytes');\n this.ORDER = ORDER;\n this.BITS = nBitLength;\n this.BYTES = nByteLength;\n this._sqrt = undefined;\n Object.preventExtensions(this);\n }\n create(num) {\n return mod(num, this.ORDER);\n }\n isValid(num) {\n if (typeof num !== 'bigint')\n throw new Error('invalid field element: expected bigint, got ' + typeof num);\n return _0n <= num && num < this.ORDER; // 0 is valid element, but it's not invertible\n }\n is0(num) {\n return num === _0n;\n }\n // is valid and invertible\n isValidNot0(num) {\n return !this.is0(num) && this.isValid(num);\n }\n isOdd(num) {\n return (num & _1n) === _1n;\n }\n neg(num) {\n return mod(-num, this.ORDER);\n }\n eql(lhs, rhs) {\n return lhs === rhs;\n }\n sqr(num) {\n return mod(num * num, this.ORDER);\n }\n add(lhs, rhs) {\n return mod(lhs + rhs, this.ORDER);\n }\n sub(lhs, rhs) {\n return mod(lhs - rhs, this.ORDER);\n }\n mul(lhs, rhs) {\n return mod(lhs * rhs, this.ORDER);\n }\n pow(num, power) {\n return FpPow(this, num, power);\n }\n div(lhs, rhs) {\n return mod(lhs * invert(rhs, this.ORDER), this.ORDER);\n }\n // Same as above, but doesn't normalize\n sqrN(num) {\n return num * num;\n }\n addN(lhs, rhs) {\n return lhs + rhs;\n }\n subN(lhs, rhs) {\n return lhs - rhs;\n }\n mulN(lhs, rhs) {\n return lhs * rhs;\n }\n inv(num) {\n return invert(num, this.ORDER);\n }\n sqrt(num) {\n // Caching _sqrt speeds up sqrt9mod16 by 5x and tonneli-shanks by 10%\n if (!this._sqrt)\n this._sqrt = FpSqrt(this.ORDER);\n return this._sqrt(this, num);\n }\n toBytes(num) {\n return this.isLE ? numberToBytesLE(num, this.BYTES) : numberToBytesBE(num, this.BYTES);\n }\n fromBytes(bytes, skipValidation = false) {\n abytes(bytes);\n const { _lengths: allowedLengths, BYTES, isLE, ORDER, _mod: modFromBytes } = this;\n if (allowedLengths) {\n if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {\n throw new Error('Field.fromBytes: expected ' + allowedLengths + ' bytes, got ' + bytes.length);\n }\n const padded = new Uint8Array(BYTES);\n // isLE add 0 to right, !isLE to the left.\n padded.set(bytes, isLE ? 0 : padded.length - bytes.length);\n bytes = padded;\n }\n if (bytes.length !== BYTES)\n throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);\n let scalar = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n if (modFromBytes)\n scalar = mod(scalar, ORDER);\n if (!skipValidation)\n if (!this.isValid(scalar))\n throw new Error('invalid field element: outside of range 0..ORDER');\n // NOTE: we don't validate scalar here, please use isValid. This done such way because some\n // protocol may allow non-reduced scalar that reduced later or changed some other way.\n return scalar;\n }\n // TODO: we don't need it here, move out to separate fn\n invertBatch(lst) {\n return FpInvertBatch(this, lst);\n }\n // We can't move this out because Fp6, Fp12 implement it\n // and it's unclear what to return in there.\n cmov(a, b, condition) {\n return condition ? b : a;\n }\n}\n/**\n * Creates a finite field. Major performance optimizations:\n * * 1. Denormalized operations like mulN instead of mul.\n * * 2. Identical object shape: never add or remove keys.\n * * 3. `Object.freeze`.\n * Fragile: always run a benchmark on a change.\n * Security note: operations don't check 'isValid' for all elements for performance reasons,\n * it is caller responsibility to check this.\n * This is low-level code, please make sure you know what you're doing.\n *\n * Note about field properties:\n * * CHARACTERISTIC p = prime number, number of elements in main subgroup.\n * * ORDER q = similar to cofactor in curves, may be composite `q = p^m`.\n *\n * @param ORDER field order, probably prime, or could be composite\n * @param bitLen how many bits the field consumes\n * @param isLE (default: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER, opts = {}) {\n return new _Field(ORDER, opts);\n}\n// Generic random scalar, we can do same for other fields if via Fp2.mul(Fp2.ONE, Fp2.random)?\n// This allows unsafe methods like ignore bias or zero. These unsafe, but often used in different protocols (if deterministic RNG).\n// which mean we cannot force this via opts.\n// Not sure what to do with randomBytes, we can accept it inside opts if wanted.\n// Probably need to export getMinHashLength somewhere?\n// random(bytes?: Uint8Array, unsafeAllowZero = false, unsafeAllowBias = false) {\n// const LEN = !unsafeAllowBias ? getMinHashLength(ORDER) : BYTES;\n// if (bytes === undefined) bytes = randomBytes(LEN); // _opts.randomBytes?\n// const num = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n// // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n// const reduced = unsafeAllowZero ? mod(num, ORDER) : mod(num, ORDER - _1n) + _1n;\n// return reduced;\n// },\nexport function FpSqrtOdd(Fp, elm) {\n if (!Fp.isOdd)\n throw new Error(\"Field doesn't have isOdd\");\n const root = Fp.sqrt(elm);\n return Fp.isOdd(root) ? root : Fp.neg(root);\n}\nexport function FpSqrtEven(Fp, elm) {\n if (!Fp.isOdd)\n throw new Error(\"Field doesn't have isOdd\");\n const root = Fp.sqrt(elm);\n return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder) {\n if (typeof fieldOrder !== 'bigint')\n throw new Error('field order must be bigint');\n const bitLength = fieldOrder.toString(2).length;\n return Math.ceil(bitLength / 8);\n}\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder) {\n const length = getFieldBytesLength(fieldOrder);\n return length + Math.ceil(length / 2);\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.Point.Fn.ORDER)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n abytes(key);\n const len = key.length;\n const fieldLen = getFieldBytesLength(fieldOrder);\n const minLen = getMinHashLength(fieldOrder);\n // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n if (len < 16 || len < minLen || len > 1024)\n throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);\n const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);\n // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n const reduced = mod(num, fieldOrder - _1n) + _1n;\n return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n//# sourceMappingURL=modular.js.map","/**\n * Methods for elliptic curve multiplication by scalars.\n * Contains wNAF, pippenger.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { bitLen, bitMask } from \"../utils.js\";\nimport { Field, FpInvertBatch, validateField } from \"./modular.js\";\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function negateCt(condition, item) {\n const neg = item.negate();\n return condition ? neg : item;\n}\n/**\n * Takes a bunch of Projective Points but executes only one\n * inversion on all of them. Inversion is very slow operation,\n * so this improves performance massively.\n * Optimization: converts a list of projective points to a list of identical points with Z=1.\n */\nexport function normalizeZ(c, points) {\n const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));\n return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));\n}\nfunction validateW(W, bits) {\n if (!Number.isSafeInteger(W) || W <= 0 || W > bits)\n throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);\n}\nfunction calcWOpts(W, scalarBits) {\n validateW(W, scalarBits);\n const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero\n const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero\n const maxNumber = 2 ** W; // W=8 256\n const mask = bitMask(W); // W=8 255 == mask 0b11111111\n const shiftBy = BigInt(W); // W=8 8\n return { windows, windowSize, mask, maxNumber, shiftBy };\n}\nfunction calcOffsets(n, window, wOpts) {\n const { windowSize, mask, maxNumber, shiftBy } = wOpts;\n let wbits = Number(n & mask); // extract W bits.\n let nextN = n >> shiftBy; // shift number by W bits.\n // What actually happens here:\n // const highestBit = Number(mask ^ (mask >> 1n));\n // let wbits2 = wbits - 1; // skip zero\n // if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);\n // split if bits > max: +224 => 256-32\n if (wbits > windowSize) {\n // we skip zero, which means instead of `>= size-1`, we do `> size`\n wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.\n nextN += _1n; // +256 (carry)\n }\n const offsetStart = window * windowSize;\n const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero\n const isZero = wbits === 0; // is current window slice a 0?\n const isNeg = wbits < 0; // is current window slice negative?\n const isNegF = window % 2 !== 0; // fake random statement for noise\n const offsetF = offsetStart; // fake offset for noise\n return { nextN, offset, isZero, isNeg, isNegF, offsetF };\n}\nfunction validateMSMPoints(points, c) {\n if (!Array.isArray(points))\n throw new Error('array expected');\n points.forEach((p, i) => {\n if (!(p instanceof c))\n throw new Error('invalid point at index ' + i);\n });\n}\nfunction validateMSMScalars(scalars, field) {\n if (!Array.isArray(scalars))\n throw new Error('array of scalars expected');\n scalars.forEach((s, i) => {\n if (!field.isValid(s))\n throw new Error('invalid scalar at index ' + i);\n });\n}\n// Since points in different groups cannot be equal (different object constructor),\n// we can have single place to store precomputes.\n// Allows to make points frozen / immutable.\nconst pointPrecomputes = new WeakMap();\nconst pointWindowSizes = new WeakMap();\nfunction getW(P) {\n // To disable precomputes:\n // return 1;\n return pointWindowSizes.get(P) || 1;\n}\nfunction assert0(n) {\n if (n !== _0n)\n throw new Error('invalid wNAF');\n}\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Table generation takes **30MB of ram and 10ms on high-end CPU**,\n * but may take much longer on slow devices. Actual generation will happen on\n * first call of `multiply()`. By default, `BASE` point is precomputed.\n *\n * Scalars should always be less than curve order: this should be checked inside of a curve itself.\n * Creates precomputation tables for fast multiplication:\n * - private scalar is split by fixed size windows of W bits\n * - every window point is collected from window's table & added to accumulator\n * - since windows are different, same point inside tables won't be accessed more than once per calc\n * - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n * - +1 window is neccessary for wNAF\n * - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n *\n * @todo Research returning 2d JS array of windows, instead of a single window.\n * This would allow windows to be in different memory locations\n */\nexport class wNAF {\n BASE;\n ZERO;\n Fn;\n bits;\n // Parametrized with a given Point class (not individual point)\n constructor(Point, bits) {\n this.BASE = Point.BASE;\n this.ZERO = Point.ZERO;\n this.Fn = Point.Fn;\n this.bits = bits;\n }\n // non-const time multiplication ladder\n _unsafeLadder(elm, n, p = this.ZERO) {\n let d = elm;\n while (n > _0n) {\n if (n & _1n)\n p = p.add(d);\n d = d.double();\n n >>= _1n;\n }\n return p;\n }\n /**\n * Creates a wNAF precomputation window. Used for caching.\n * Default window size is set by `utils.precompute()` and is equal to 8.\n * Number of precomputed points depends on the curve size:\n * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n * - 𝑊 is the window size\n * - 𝑛 is the bitlength of the curve order.\n * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n * @param point Point instance\n * @param W window size\n * @returns precomputed point tables flattened to a single array\n */\n precomputeWindow(point, W) {\n const { windows, windowSize } = calcWOpts(W, this.bits);\n const points = [];\n let p = point;\n let base = p;\n for (let window = 0; window < windows; window++) {\n base = p;\n points.push(base);\n // i=1, bc we skip 0\n for (let i = 1; i < windowSize; i++) {\n base = base.add(p);\n points.push(base);\n }\n p = base.double();\n }\n return points;\n }\n /**\n * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n * More compact implementation:\n * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541\n * @returns real and fake (for const-time) points\n */\n wNAF(W, precomputes, n) {\n // Scalar should be smaller than field order\n if (!this.Fn.isValid(n))\n throw new Error('invalid scalar');\n // Accumulators\n let p = this.ZERO;\n let f = this.BASE;\n // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n // there is negate now: it is possible that negated element from low value\n // would be the same as high element, which will create carry into next window.\n // It's not obvious how this can fail, but still worth investigating later.\n const wo = calcWOpts(W, this.bits);\n for (let window = 0; window < wo.windows; window++) {\n // (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise\n const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);\n n = nextN;\n if (isZero) {\n // bits are 0: add garbage to fake point\n // Important part for const-time getPublicKey: add random \"noise\" point to f.\n f = f.add(negateCt(isNegF, precomputes[offsetF]));\n }\n else {\n // bits are 1: add to result point\n p = p.add(negateCt(isNeg, precomputes[offset]));\n }\n }\n assert0(n);\n // Return both real and fake points: JIT won't eliminate f.\n // At this point there is a way to F be infinity-point even if p is not,\n // which makes it less const-time: around 1 bigint multiply.\n return { p, f };\n }\n /**\n * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.\n * @param acc accumulator point to add result of multiplication\n * @returns point\n */\n wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {\n const wo = calcWOpts(W, this.bits);\n for (let window = 0; window < wo.windows; window++) {\n if (n === _0n)\n break; // Early-exit, skip 0 value\n const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);\n n = nextN;\n if (isZero) {\n // Window bits are 0: skip processing.\n // Move to next window.\n continue;\n }\n else {\n const item = precomputes[offset];\n acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM\n }\n }\n assert0(n);\n return acc;\n }\n getPrecomputes(W, point, transform) {\n // Calculate precomputes on a first run, reuse them after\n let comp = pointPrecomputes.get(point);\n if (!comp) {\n comp = this.precomputeWindow(point, W);\n if (W !== 1) {\n // Doing transform outside of if brings 15% perf hit\n if (typeof transform === 'function')\n comp = transform(comp);\n pointPrecomputes.set(point, comp);\n }\n }\n return comp;\n }\n cached(point, scalar, transform) {\n const W = getW(point);\n return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);\n }\n unsafe(point, scalar, transform, prev) {\n const W = getW(point);\n if (W === 1)\n return this._unsafeLadder(point, scalar, prev); // For W=1 ladder is ~x2 faster\n return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);\n }\n // We calculate precomputes for elliptic curve point multiplication\n // using windowed method. This specifies window size and\n // stores precomputed values. Usually only base point would be precomputed.\n createCache(P, W) {\n validateW(W, this.bits);\n pointWindowSizes.set(P, W);\n pointPrecomputes.delete(P);\n }\n hasCache(elm) {\n return getW(elm) !== 1;\n }\n}\n/**\n * Endomorphism-specific multiplication for Koblitz curves.\n * Cost: 128 dbl, 0-256 adds.\n */\nexport function mulEndoUnsafe(Point, point, k1, k2) {\n let acc = point;\n let p1 = Point.ZERO;\n let p2 = Point.ZERO;\n while (k1 > _0n || k2 > _0n) {\n if (k1 & _1n)\n p1 = p1.add(acc);\n if (k2 & _1n)\n p2 = p2.add(acc);\n acc = acc.double();\n k1 >>= _1n;\n k2 >>= _1n;\n }\n return { p1, p2 };\n}\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster than precomputes.\n * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.\n * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @param scalars array of L scalars (aka secret keys / bigints)\n */\nexport function pippenger(c, points, scalars) {\n // If we split scalars by some window (let's say 8 bits), every chunk will only\n // take 256 buckets even if there are 4096 scalars, also re-uses double.\n // TODO:\n // - https://eprint.iacr.org/2024/750.pdf\n // - https://tches.iacr.org/index.php/TCHES/article/view/10287\n // 0 is accepted in scalars\n const fieldN = c.Fn;\n validateMSMPoints(points, c);\n validateMSMScalars(scalars, fieldN);\n const plength = points.length;\n const slength = scalars.length;\n if (plength !== slength)\n throw new Error('arrays of points and scalars must have equal length');\n // if (plength === 0) throw new Error('array must be of length >= 2');\n const zero = c.ZERO;\n const wbits = bitLen(BigInt(plength));\n let windowSize = 1; // bits\n if (wbits > 12)\n windowSize = wbits - 3;\n else if (wbits > 4)\n windowSize = wbits - 2;\n else if (wbits > 0)\n windowSize = 2;\n const MASK = bitMask(windowSize);\n const buckets = new Array(Number(MASK) + 1).fill(zero); // +1 for zero array\n const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;\n let sum = zero;\n for (let i = lastBits; i >= 0; i -= windowSize) {\n buckets.fill(zero);\n for (let j = 0; j < slength; j++) {\n const scalar = scalars[j];\n const wbits = Number((scalar >> BigInt(i)) & MASK);\n buckets[wbits] = buckets[wbits].add(points[j]);\n }\n let resI = zero; // not using this will do small speed-up, but will lose ct\n // Skip first bucket, because it is zero\n for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {\n sumI = sumI.add(buckets[j]);\n resI = resI.add(sumI);\n }\n sum = sum.add(resI);\n if (i !== 0)\n for (let j = 0; j < windowSize; j++)\n sum = sum.double();\n }\n return sum;\n}\n/**\n * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @returns function which multiplies points with scaars\n */\nexport function precomputeMSMUnsafe(c, points, windowSize) {\n /**\n * Performance Analysis of Window-based Precomputation\n *\n * Base Case (256-bit scalar, 8-bit window):\n * - Standard precomputation requires:\n * - 31 additions per scalar × 256 scalars = 7,936 ops\n * - Plus 255 summary additions = 8,191 total ops\n * Note: Summary additions can be optimized via accumulator\n *\n * Chunked Precomputation Analysis:\n * - Using 32 chunks requires:\n * - 255 additions per chunk\n * - 256 doublings\n * - Total: (255 × 32) + 256 = 8,416 ops\n *\n * Memory Usage Comparison:\n * Window Size | Standard Points | Chunked Points\n * ------------|-----------------|---------------\n * 4-bit | 520 | 15\n * 8-bit | 4,224 | 255\n * 10-bit | 13,824 | 1,023\n * 16-bit | 557,056 | 65,535\n *\n * Key Advantages:\n * 1. Enables larger window sizes due to reduced memory overhead\n * 2. More efficient for smaller scalar counts:\n * - 16 chunks: (16 × 255) + 256 = 4,336 ops\n * - ~2x faster than standard 8,191 ops\n *\n * Limitations:\n * - Not suitable for plain precomputes (requires 256 constant doublings)\n * - Performance degrades with larger scalar counts:\n * - Optimal for ~256 scalars\n * - Less efficient for 4096+ scalars (Pippenger preferred)\n */\n const fieldN = c.Fn;\n validateW(windowSize, fieldN.BITS);\n validateMSMPoints(points, c);\n const zero = c.ZERO;\n const tableSize = 2 ** windowSize - 1; // table size (without zero)\n const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item\n const MASK = bitMask(windowSize);\n const tables = points.map((p) => {\n const res = [];\n for (let i = 0, acc = p; i < tableSize; i++) {\n res.push(acc);\n acc = acc.add(p);\n }\n return res;\n });\n return (scalars) => {\n validateMSMScalars(scalars, fieldN);\n if (scalars.length > points.length)\n throw new Error('array of scalars must be smaller than array of points');\n let res = zero;\n for (let i = 0; i < chunks; i++) {\n // No need to double if accumulator is still zero.\n if (res !== zero)\n for (let j = 0; j < windowSize; j++)\n res = res.double();\n const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);\n for (let j = 0; j < scalars.length; j++) {\n const n = scalars[j];\n const curr = Number((n >> shiftBy) & MASK);\n if (!curr)\n continue; // skip zero scalars chunks\n res = res.add(tables[j][curr - 1]);\n }\n }\n return res;\n };\n}\nfunction createField(order, field, isLE) {\n if (field) {\n if (field.ORDER !== order)\n throw new Error('Field.ORDER must match order: Fp == p, Fn == n');\n validateField(field);\n return field;\n }\n else {\n return Field(order, { isLE });\n }\n}\n/** Validates CURVE opts and creates fields */\nexport function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {\n if (FpFnLE === undefined)\n FpFnLE = type === 'edwards';\n if (!CURVE || typeof CURVE !== 'object')\n throw new Error(`expected valid ${type} CURVE object`);\n for (const p of ['p', 'n', 'h']) {\n const val = CURVE[p];\n if (!(typeof val === 'bigint' && val > _0n))\n throw new Error(`CURVE.${p} must be positive bigint`);\n }\n const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);\n const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);\n const _b = type === 'weierstrass' ? 'b' : 'd';\n const params = ['Gx', 'Gy', 'a', _b];\n for (const p of params) {\n // @ts-ignore\n if (!Fp.isValid(CURVE[p]))\n throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);\n }\n CURVE = Object.freeze(Object.assign({}, CURVE));\n return { CURVE, Fp, Fn };\n}\nexport function createKeygen(randomSecretKey, getPublicKey) {\n return function keygen(seed) {\n const secretKey = randomSecretKey(seed);\n return { secretKey, publicKey: getPublicKey(secretKey) };\n };\n}\n//# sourceMappingURL=curve.js.map","/**\n * HMAC: RFC2104 message authentication code.\n * @module\n */\nimport { abytes, aexists, ahash, clean } from \"./utils.js\";\n/** Internal class for HMAC. */\nexport class _HMAC {\n oHash;\n iHash;\n blockLen;\n outputLen;\n finished = false;\n destroyed = false;\n constructor(hash, key) {\n ahash(hash);\n abytes(key, undefined, 'key');\n this.iHash = hash.create();\n if (typeof this.iHash.update !== 'function')\n throw new Error('Expected instance of class which extends utils.Hash');\n this.blockLen = this.iHash.blockLen;\n this.outputLen = this.iHash.outputLen;\n const blockLen = this.blockLen;\n const pad = new Uint8Array(blockLen);\n // blockLen can be bigger than outputLen\n pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n for (let i = 0; i < pad.length; i++)\n pad[i] ^= 0x36;\n this.iHash.update(pad);\n // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n this.oHash = hash.create();\n // Undo internal XOR && apply outer XOR\n for (let i = 0; i < pad.length; i++)\n pad[i] ^= 0x36 ^ 0x5c;\n this.oHash.update(pad);\n clean(pad);\n }\n update(buf) {\n aexists(this);\n this.iHash.update(buf);\n return this;\n }\n digestInto(out) {\n aexists(this);\n abytes(out, this.outputLen, 'output');\n this.finished = true;\n this.iHash.digestInto(out);\n this.oHash.update(out);\n this.oHash.digestInto(out);\n this.destroy();\n }\n digest() {\n const out = new Uint8Array(this.oHash.outputLen);\n this.digestInto(out);\n return out;\n }\n _cloneInto(to) {\n // Create new instance without calling constructor since key already in state and we don't know it.\n to ||= Object.create(Object.getPrototypeOf(this), {});\n const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n to = to;\n to.finished = finished;\n to.destroyed = destroyed;\n to.blockLen = blockLen;\n to.outputLen = outputLen;\n to.oHash = oHash._cloneInto(to.oHash);\n to.iHash = iHash._cloneInto(to.iHash);\n return to;\n }\n clone() {\n return this._cloneInto();\n }\n destroy() {\n this.destroyed = true;\n this.oHash.destroy();\n this.iHash.destroy();\n }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n * @example\n * import { hmac } from '@noble/hashes/hmac';\n * import { sha256 } from '@noble/hashes/sha2';\n * const mac1 = hmac(sha256, 'key', 'message');\n */\nexport const hmac = (hash, key, message) => new _HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new _HMAC(hash, key);\n//# sourceMappingURL=hmac.js.map","/**\n * Short Weierstrass curve methods. The formula is: y² = x³ + ax + b.\n *\n * ### Design rationale for types\n *\n * * Interaction between classes from different curves should fail:\n * `k256.Point.BASE.add(p256.Point.BASE)`\n * * For this purpose we want to use `instanceof` operator, which is fast and works during runtime\n * * Different calls of `curve()` would return different classes -\n * `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,\n * it won't affect others\n *\n * TypeScript can't infer types for classes created inside a function. Classes is one instance\n * of nominative types in TypeScript and interfaces only check for shape, so it's hard to create\n * unique type for every function call.\n *\n * We can use generic types via some param, like curve opts, but that would:\n * 1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)\n * which is hard to debug.\n * 2. Params can be generic and we can't enforce them to be constant value:\n * if somebody creates curve from non-constant params,\n * it would be allowed to interact with other curves with non-constant params\n *\n * @todo https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac as nobleHmac } from '@noble/hashes/hmac.js';\nimport { ahash } from '@noble/hashes/utils.js';\nimport { abool, abytes, aInRange, bitLen, bitMask, bytesToHex, bytesToNumberBE, concatBytes, createHmacDrbg, hexToBytes, isBytes, memoized, numberToHexUnpadded, validateObject, randomBytes as wcRandomBytes, } from \"../utils.js\";\nimport { createCurveFields, createKeygen, mulEndoUnsafe, negateCt, normalizeZ, wNAF, } from \"./curve.js\";\nimport { FpInvertBatch, getMinHashLength, mapHashToField, validateField, } from \"./modular.js\";\n// We construct basis in such way that den is always positive and equals n, but num sign depends on basis (not on secret value)\nconst divNearest = (num, den) => (num + (num >= 0 ? den : -den) / _2n) / den;\n/**\n * Splits scalar for GLV endomorphism.\n */\nexport function _splitEndoScalar(k, basis, n) {\n // Split scalar into two such that part is ~half bits: `abs(part) < sqrt(N)`\n // Since part can be negative, we need to do this on point.\n // TODO: verifyScalar function which consumes lambda\n const [[a1, b1], [a2, b2]] = basis;\n const c1 = divNearest(b2 * k, n);\n const c2 = divNearest(-b1 * k, n);\n // |k1|/|k2| is < sqrt(N), but can be negative.\n // If we do `k1 mod N`, we'll get big scalar (`> sqrt(N)`): so, we do cheaper negation instead.\n let k1 = k - c1 * a1 - c2 * a2;\n let k2 = -c1 * b1 - c2 * b2;\n const k1neg = k1 < _0n;\n const k2neg = k2 < _0n;\n if (k1neg)\n k1 = -k1;\n if (k2neg)\n k2 = -k2;\n // Double check that resulting scalar less than half bits of N: otherwise wNAF will fail.\n // This should only happen on wrong basises. Also, math inside is too complex and I don't trust it.\n const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n; // Half bits of N\n if (k1 < _0n || k1 >= MAX_NUM || k2 < _0n || k2 >= MAX_NUM) {\n throw new Error('splitScalar (endomorphism): failed, k=' + k);\n }\n return { k1neg, k1, k2neg, k2 };\n}\nfunction validateSigFormat(format) {\n if (!['compact', 'recovered', 'der'].includes(format))\n throw new Error('Signature format must be \"compact\", \"recovered\", or \"der\"');\n return format;\n}\nfunction validateSigOpts(opts, def) {\n const optsn = {};\n for (let optName of Object.keys(def)) {\n // @ts-ignore\n optsn[optName] = opts[optName] === undefined ? def[optName] : opts[optName];\n }\n abool(optsn.lowS, 'lowS');\n abool(optsn.prehash, 'prehash');\n if (optsn.format !== undefined)\n validateSigFormat(optsn.format);\n return optsn;\n}\nexport class DERErr extends Error {\n constructor(m = '') {\n super(m);\n }\n}\n/**\n * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:\n *\n * [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]\n *\n * Docs: https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/, https://luca.ntop.org/Teaching/Appunti/asn1.html\n */\nexport const DER = {\n // asn.1 DER encoding utils\n Err: DERErr,\n // Basic building block is TLV (Tag-Length-Value)\n _tlv: {\n encode: (tag, data) => {\n const { Err: E } = DER;\n if (tag < 0 || tag > 256)\n throw new E('tlv.encode: wrong tag');\n if (data.length & 1)\n throw new E('tlv.encode: unpadded data');\n const dataLen = data.length / 2;\n const len = numberToHexUnpadded(dataLen);\n if ((len.length / 2) & 0b1000_0000)\n throw new E('tlv.encode: long form length too big');\n // length of length with long form flag\n const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 0b1000_0000) : '';\n const t = numberToHexUnpadded(tag);\n return t + lenLen + len + data;\n },\n // v - value, l - left bytes (unparsed)\n decode(tag, data) {\n const { Err: E } = DER;\n let pos = 0;\n if (tag < 0 || tag > 256)\n throw new E('tlv.encode: wrong tag');\n if (data.length < 2 || data[pos++] !== tag)\n throw new E('tlv.decode: wrong tlv');\n const first = data[pos++];\n const isLong = !!(first & 0b1000_0000); // First bit of first length byte is flag for short/long form\n let length = 0;\n if (!isLong)\n length = first;\n else {\n // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]\n const lenLen = first & 0b0111_1111;\n if (!lenLen)\n throw new E('tlv.decode(long): indefinite length not supported');\n if (lenLen > 4)\n throw new E('tlv.decode(long): byte length is too big'); // this will overflow u32 in js\n const lengthBytes = data.subarray(pos, pos + lenLen);\n if (lengthBytes.length !== lenLen)\n throw new E('tlv.decode: length bytes not complete');\n if (lengthBytes[0] === 0)\n throw new E('tlv.decode(long): zero leftmost byte');\n for (const b of lengthBytes)\n length = (length << 8) | b;\n pos += lenLen;\n if (length < 128)\n throw new E('tlv.decode(long): not minimal encoding');\n }\n const v = data.subarray(pos, pos + length);\n if (v.length !== length)\n throw new E('tlv.decode: wrong value length');\n return { v, l: data.subarray(pos + length) };\n },\n },\n // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n // since we always use positive integers here. It must always be empty:\n // - add zero byte if exists\n // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n _int: {\n encode(num) {\n const { Err: E } = DER;\n if (num < _0n)\n throw new E('integer: negative integers are not allowed');\n let hex = numberToHexUnpadded(num);\n // Pad with zero byte if negative flag is present\n if (Number.parseInt(hex[0], 16) & 0b1000)\n hex = '00' + hex;\n if (hex.length & 1)\n throw new E('unexpected DER parsing assertion: unpadded hex');\n return hex;\n },\n decode(data) {\n const { Err: E } = DER;\n if (data[0] & 0b1000_0000)\n throw new E('invalid signature integer: negative');\n if (data[0] === 0x00 && !(data[1] & 0b1000_0000))\n throw new E('invalid signature integer: unnecessary leading zero');\n return bytesToNumberBE(data);\n },\n },\n toSig(bytes) {\n // parse DER signature\n const { Err: E, _int: int, _tlv: tlv } = DER;\n const data = abytes(bytes, undefined, 'signature');\n const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);\n if (seqLeftBytes.length)\n throw new E('invalid signature: left bytes after parsing');\n const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);\n const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);\n if (sLeftBytes.length)\n throw new E('invalid signature: left bytes after parsing');\n return { r: int.decode(rBytes), s: int.decode(sBytes) };\n },\n hexFromSig(sig) {\n const { _tlv: tlv, _int: int } = DER;\n const rs = tlv.encode(0x02, int.encode(sig.r));\n const ss = tlv.encode(0x02, int.encode(sig.s));\n const seq = rs + ss;\n return tlv.encode(0x30, seq);\n },\n};\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\n/**\n * Creates weierstrass Point constructor, based on specified curve options.\n *\n * See {@link WeierstrassOpts}.\n *\n * @example\n```js\nconst opts = {\n p: 0xfffffffffffffffffffffffffffffffeffffac73n,\n n: 0x100000000000000000001b8fa16dfab9aca16b6b3n,\n h: 1n,\n a: 0n,\n b: 7n,\n Gx: 0x3b4c382ce37aa192a4019e763036f4f5dd4d7ebbn,\n Gy: 0x938cf935318fdced6bc28286531733c3f03c4feen,\n};\nconst secp160k1_Point = weierstrass(opts);\n```\n */\nexport function weierstrass(params, extraOpts = {}) {\n const validated = createCurveFields('weierstrass', params, extraOpts);\n const { Fp, Fn } = validated;\n let CURVE = validated.CURVE;\n const { h: cofactor, n: CURVE_ORDER } = CURVE;\n validateObject(extraOpts, {}, {\n allowInfinityPoint: 'boolean',\n clearCofactor: 'function',\n isTorsionFree: 'function',\n fromBytes: 'function',\n toBytes: 'function',\n endo: 'object',\n });\n const { endo } = extraOpts;\n if (endo) {\n // validateObject(endo, { beta: 'bigint', splitScalar: 'function' });\n if (!Fp.is0(CURVE.a) || typeof endo.beta !== 'bigint' || !Array.isArray(endo.basises)) {\n throw new Error('invalid endo: expected \"beta\": bigint and \"basises\": array');\n }\n }\n const lengths = getWLengths(Fp, Fn);\n function assertCompressionIsSupported() {\n if (!Fp.isOdd)\n throw new Error('compression is not supported: Field does not have .isOdd()');\n }\n // Implements IEEE P1363 point encoding\n function pointToBytes(_c, point, isCompressed) {\n const { x, y } = point.toAffine();\n const bx = Fp.toBytes(x);\n abool(isCompressed, 'isCompressed');\n if (isCompressed) {\n assertCompressionIsSupported();\n const hasEvenY = !Fp.isOdd(y);\n return concatBytes(pprefix(hasEvenY), bx);\n }\n else {\n return concatBytes(Uint8Array.of(0x04), bx, Fp.toBytes(y));\n }\n }\n function pointFromBytes(bytes) {\n abytes(bytes, undefined, 'Point');\n const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths; // e.g. for 32-byte: 33, 65\n const length = bytes.length;\n const head = bytes[0];\n const tail = bytes.subarray(1);\n // No actual validation is done here: use .assertValidity()\n if (length === comp && (head === 0x02 || head === 0x03)) {\n const x = Fp.fromBytes(tail);\n if (!Fp.isValid(x))\n throw new Error('bad point: is not on curve, wrong x');\n const y2 = weierstrassEquation(x); // y² = x³ + ax + b\n let y;\n try {\n y = Fp.sqrt(y2); // y = y² ^ (p+1)/4\n }\n catch (sqrtError) {\n const err = sqrtError instanceof Error ? ': ' + sqrtError.message : '';\n throw new Error('bad point: is not on curve, sqrt error' + err);\n }\n assertCompressionIsSupported();\n const evenY = Fp.isOdd(y);\n const evenH = (head & 1) === 1; // ECDSA-specific\n if (evenH !== evenY)\n y = Fp.neg(y);\n return { x, y };\n }\n else if (length === uncomp && head === 0x04) {\n // TODO: more checks\n const L = Fp.BYTES;\n const x = Fp.fromBytes(tail.subarray(0, L));\n const y = Fp.fromBytes(tail.subarray(L, L * 2));\n if (!isValidXY(x, y))\n throw new Error('bad point: is not on curve');\n return { x, y };\n }\n else {\n throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);\n }\n }\n const encodePoint = extraOpts.toBytes || pointToBytes;\n const decodePoint = extraOpts.fromBytes || pointFromBytes;\n function weierstrassEquation(x) {\n const x2 = Fp.sqr(x); // x * x\n const x3 = Fp.mul(x2, x); // x² * x\n return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b); // x³ + a * x + b\n }\n // TODO: move top-level\n /** Checks whether equation holds for given x, y: y² == x³ + ax + b */\n function isValidXY(x, y) {\n const left = Fp.sqr(y); // y²\n const right = weierstrassEquation(x); // x³ + ax + b\n return Fp.eql(left, right);\n }\n // Validate whether the passed curve params are valid.\n // Test 1: equation y² = x³ + ax + b should work for generator point.\n if (!isValidXY(CURVE.Gx, CURVE.Gy))\n throw new Error('bad curve params: generator point');\n // Test 2: discriminant Δ part should be non-zero: 4a³ + 27b² != 0.\n // Guarantees curve is genus-1, smooth (non-singular).\n const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n), _4n);\n const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));\n if (Fp.is0(Fp.add(_4a3, _27b2)))\n throw new Error('bad curve params: a or b');\n /** Asserts coordinate is valid: 0 <= n < Fp.ORDER. */\n function acoord(title, n, banZero = false) {\n if (!Fp.isValid(n) || (banZero && Fp.is0(n)))\n throw new Error(`bad point coordinate ${title}`);\n return n;\n }\n function aprjpoint(other) {\n if (!(other instanceof Point))\n throw new Error('Weierstrass Point expected');\n }\n function splitEndoScalarN(k) {\n if (!endo || !endo.basises)\n throw new Error('no endo');\n return _splitEndoScalar(k, endo.basises, Fn.ORDER);\n }\n // Memoized toAffine / validity check. They are heavy. Points are immutable.\n // Converts Projective point to affine (x, y) coordinates.\n // Can accept precomputed Z^-1 - for example, from invertBatch.\n // (X, Y, Z) ∋ (x=X/Z, y=Y/Z)\n const toAffineMemo = memoized((p, iz) => {\n const { X, Y, Z } = p;\n // Fast-path for normalized points\n if (Fp.eql(Z, Fp.ONE))\n return { x: X, y: Y };\n const is0 = p.is0();\n // If invZ was 0, we return zero point. However we still want to execute\n // all operations, so we replace invZ with a random number, 1.\n if (iz == null)\n iz = is0 ? Fp.ONE : Fp.inv(Z);\n const x = Fp.mul(X, iz);\n const y = Fp.mul(Y, iz);\n const zz = Fp.mul(Z, iz);\n if (is0)\n return { x: Fp.ZERO, y: Fp.ZERO };\n if (!Fp.eql(zz, Fp.ONE))\n throw new Error('invZ was invalid');\n return { x, y };\n });\n // NOTE: on exception this will crash 'cached' and no value will be set.\n // Otherwise true will be return\n const assertValidMemo = memoized((p) => {\n if (p.is0()) {\n // (0, 1, 0) aka ZERO is invalid in most contexts.\n // In BLS, ZERO can be serialized, so we allow it.\n // (0, 0, 0) is invalid representation of ZERO.\n if (extraOpts.allowInfinityPoint && !Fp.is0(p.Y))\n return;\n throw new Error('bad point: ZERO');\n }\n // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`\n const { x, y } = p.toAffine();\n if (!Fp.isValid(x) || !Fp.isValid(y))\n throw new Error('bad point: x or y not field elements');\n if (!isValidXY(x, y))\n throw new Error('bad point: equation left != right');\n if (!p.isTorsionFree())\n throw new Error('bad point: not in prime-order subgroup');\n return true;\n });\n function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {\n k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);\n k1p = negateCt(k1neg, k1p);\n k2p = negateCt(k2neg, k2p);\n return k1p.add(k2p);\n }\n /**\n * Projective Point works in 3d / projective (homogeneous) coordinates:(X, Y, Z) ∋ (x=X/Z, y=Y/Z).\n * Default Point works in 2d / affine coordinates: (x, y).\n * We're doing calculations in projective, because its operations don't require costly inversion.\n */\n class Point {\n // base / generator point\n static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n // zero / infinity / identity point\n static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO); // 0, 1, 0\n // math field\n static Fp = Fp;\n // scalar field\n static Fn = Fn;\n X;\n Y;\n Z;\n /** Does NOT validate if the point is valid. Use `.assertValidity()`. */\n constructor(X, Y, Z) {\n this.X = acoord('x', X);\n this.Y = acoord('y', Y, true);\n this.Z = acoord('z', Z);\n Object.freeze(this);\n }\n static CURVE() {\n return CURVE;\n }\n /** Does NOT validate if the point is valid. Use `.assertValidity()`. */\n static fromAffine(p) {\n const { x, y } = p || {};\n if (!p || !Fp.isValid(x) || !Fp.isValid(y))\n throw new Error('invalid affine point');\n if (p instanceof Point)\n throw new Error('projective point not allowed');\n // (0, 0) would've produced (0, 0, 1) - instead, we need (0, 1, 0)\n if (Fp.is0(x) && Fp.is0(y))\n return Point.ZERO;\n return new Point(x, y, Fp.ONE);\n }\n static fromBytes(bytes) {\n const P = Point.fromAffine(decodePoint(abytes(bytes, undefined, 'point')));\n P.assertValidity();\n return P;\n }\n static fromHex(hex) {\n return Point.fromBytes(hexToBytes(hex));\n }\n get x() {\n return this.toAffine().x;\n }\n get y() {\n return this.toAffine().y;\n }\n /**\n *\n * @param windowSize\n * @param isLazy true will defer table computation until the first multiplication\n * @returns\n */\n precompute(windowSize = 8, isLazy = true) {\n wnaf.createCache(this, windowSize);\n if (!isLazy)\n this.multiply(_3n); // random number\n return this;\n }\n // TODO: return `this`\n /** A point on curve is valid if it conforms to equation. */\n assertValidity() {\n assertValidMemo(this);\n }\n hasEvenY() {\n const { y } = this.toAffine();\n if (!Fp.isOdd)\n throw new Error(\"Field doesn't support isOdd\");\n return !Fp.isOdd(y);\n }\n /** Compare one point to another. */\n equals(other) {\n aprjpoint(other);\n const { X: X1, Y: Y1, Z: Z1 } = this;\n const { X: X2, Y: Y2, Z: Z2 } = other;\n const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));\n const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));\n return U1 && U2;\n }\n /** Flips point to one corresponding to (x, -y) in Affine coordinates. */\n negate() {\n return new Point(this.X, Fp.neg(this.Y), this.Z);\n }\n // Renes-Costello-Batina exception-free doubling formula.\n // There is 30% faster Jacobian formula, but it is not complete.\n // https://eprint.iacr.org/2015/1060, algorithm 3\n // Cost: 8M + 3S + 3*a + 2*b3 + 15add.\n double() {\n const { a, b } = CURVE;\n const b3 = Fp.mul(b, _3n);\n const { X: X1, Y: Y1, Z: Z1 } = this;\n let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n let t0 = Fp.mul(X1, X1); // step 1\n let t1 = Fp.mul(Y1, Y1);\n let t2 = Fp.mul(Z1, Z1);\n let t3 = Fp.mul(X1, Y1);\n t3 = Fp.add(t3, t3); // step 5\n Z3 = Fp.mul(X1, Z1);\n Z3 = Fp.add(Z3, Z3);\n X3 = Fp.mul(a, Z3);\n Y3 = Fp.mul(b3, t2);\n Y3 = Fp.add(X3, Y3); // step 10\n X3 = Fp.sub(t1, Y3);\n Y3 = Fp.add(t1, Y3);\n Y3 = Fp.mul(X3, Y3);\n X3 = Fp.mul(t3, X3);\n Z3 = Fp.mul(b3, Z3); // step 15\n t2 = Fp.mul(a, t2);\n t3 = Fp.sub(t0, t2);\n t3 = Fp.mul(a, t3);\n t3 = Fp.add(t3, Z3);\n Z3 = Fp.add(t0, t0); // step 20\n t0 = Fp.add(Z3, t0);\n t0 = Fp.add(t0, t2);\n t0 = Fp.mul(t0, t3);\n Y3 = Fp.add(Y3, t0);\n t2 = Fp.mul(Y1, Z1); // step 25\n t2 = Fp.add(t2, t2);\n t0 = Fp.mul(t2, t3);\n X3 = Fp.sub(X3, t0);\n Z3 = Fp.mul(t2, t1);\n Z3 = Fp.add(Z3, Z3); // step 30\n Z3 = Fp.add(Z3, Z3);\n return new Point(X3, Y3, Z3);\n }\n // Renes-Costello-Batina exception-free addition formula.\n // There is 30% faster Jacobian formula, but it is not complete.\n // https://eprint.iacr.org/2015/1060, algorithm 1\n // Cost: 12M + 0S + 3*a + 3*b3 + 23add.\n add(other) {\n aprjpoint(other);\n const { X: X1, Y: Y1, Z: Z1 } = this;\n const { X: X2, Y: Y2, Z: Z2 } = other;\n let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n const a = CURVE.a;\n const b3 = Fp.mul(CURVE.b, _3n);\n let t0 = Fp.mul(X1, X2); // step 1\n let t1 = Fp.mul(Y1, Y2);\n let t2 = Fp.mul(Z1, Z2);\n let t3 = Fp.add(X1, Y1);\n let t4 = Fp.add(X2, Y2); // step 5\n t3 = Fp.mul(t3, t4);\n t4 = Fp.add(t0, t1);\n t3 = Fp.sub(t3, t4);\n t4 = Fp.add(X1, Z1);\n let t5 = Fp.add(X2, Z2); // step 10\n t4 = Fp.mul(t4, t5);\n t5 = Fp.add(t0, t2);\n t4 = Fp.sub(t4, t5);\n t5 = Fp.add(Y1, Z1);\n X3 = Fp.add(Y2, Z2); // step 15\n t5 = Fp.mul(t5, X3);\n X3 = Fp.add(t1, t2);\n t5 = Fp.sub(t5, X3);\n Z3 = Fp.mul(a, t4);\n X3 = Fp.mul(b3, t2); // step 20\n Z3 = Fp.add(X3, Z3);\n X3 = Fp.sub(t1, Z3);\n Z3 = Fp.add(t1, Z3);\n Y3 = Fp.mul(X3, Z3);\n t1 = Fp.add(t0, t0); // step 25\n t1 = Fp.add(t1, t0);\n t2 = Fp.mul(a, t2);\n t4 = Fp.mul(b3, t4);\n t1 = Fp.add(t1, t2);\n t2 = Fp.sub(t0, t2); // step 30\n t2 = Fp.mul(a, t2);\n t4 = Fp.add(t4, t2);\n t0 = Fp.mul(t1, t4);\n Y3 = Fp.add(Y3, t0);\n t0 = Fp.mul(t5, t4); // step 35\n X3 = Fp.mul(t3, X3);\n X3 = Fp.sub(X3, t0);\n t0 = Fp.mul(t3, t1);\n Z3 = Fp.mul(t5, Z3);\n Z3 = Fp.add(Z3, t0); // step 40\n return new Point(X3, Y3, Z3);\n }\n subtract(other) {\n return this.add(other.negate());\n }\n is0() {\n return this.equals(Point.ZERO);\n }\n /**\n * Constant time multiplication.\n * Uses wNAF method. Windowed method may be 10% faster,\n * but takes 2x longer to generate and consumes 2x memory.\n * Uses precomputes when available.\n * Uses endomorphism for Koblitz curves.\n * @param scalar by which the point would be multiplied\n * @returns New point\n */\n multiply(scalar) {\n const { endo } = extraOpts;\n if (!Fn.isValidNot0(scalar))\n throw new Error('invalid scalar: out of range'); // 0 is invalid\n let point, fake; // Fake point is used to const-time mult\n const mul = (n) => wnaf.cached(this, n, (p) => normalizeZ(Point, p));\n /** See docs for {@link EndomorphismOpts} */\n if (endo) {\n const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);\n const { p: k1p, f: k1f } = mul(k1);\n const { p: k2p, f: k2f } = mul(k2);\n fake = k1f.add(k2f);\n point = finishEndo(endo.beta, k1p, k2p, k1neg, k2neg);\n }\n else {\n const { p, f } = mul(scalar);\n point = p;\n fake = f;\n }\n // Normalize `z` for both points, but return only real one\n return normalizeZ(Point, [point, fake])[0];\n }\n /**\n * Non-constant-time multiplication. Uses double-and-add algorithm.\n * It's faster, but should only be used when you don't care about\n * an exposed secret key e.g. sig verification, which works over *public* keys.\n */\n multiplyUnsafe(sc) {\n const { endo } = extraOpts;\n const p = this;\n if (!Fn.isValid(sc))\n throw new Error('invalid scalar: out of range'); // 0 is valid\n if (sc === _0n || p.is0())\n return Point.ZERO; // 0\n if (sc === _1n)\n return p; // 1\n if (wnaf.hasCache(this))\n return this.multiply(sc); // precomputes\n // We don't have method for double scalar multiplication (aP + bQ):\n // Even with using Strauss-Shamir trick, it's 35% slower than naïve mul+add.\n if (endo) {\n const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);\n const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2); // 30% faster vs wnaf.unsafe\n return finishEndo(endo.beta, p1, p2, k1neg, k2neg);\n }\n else {\n return wnaf.unsafe(p, sc);\n }\n }\n /**\n * Converts Projective point to affine (x, y) coordinates.\n * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch\n */\n toAffine(invertedZ) {\n return toAffineMemo(this, invertedZ);\n }\n /**\n * Checks whether Point is free of torsion elements (is in prime subgroup).\n * Always torsion-free for cofactor=1 curves.\n */\n isTorsionFree() {\n const { isTorsionFree } = extraOpts;\n if (cofactor === _1n)\n return true;\n if (isTorsionFree)\n return isTorsionFree(Point, this);\n return wnaf.unsafe(this, CURVE_ORDER).is0();\n }\n clearCofactor() {\n const { clearCofactor } = extraOpts;\n if (cofactor === _1n)\n return this; // Fast-path\n if (clearCofactor)\n return clearCofactor(Point, this);\n return this.multiplyUnsafe(cofactor);\n }\n isSmallOrder() {\n // can we use this.clearCofactor()?\n return this.multiplyUnsafe(cofactor).is0();\n }\n toBytes(isCompressed = true) {\n abool(isCompressed, 'isCompressed');\n this.assertValidity();\n return encodePoint(Point, this, isCompressed);\n }\n toHex(isCompressed = true) {\n return bytesToHex(this.toBytes(isCompressed));\n }\n toString() {\n return ``;\n }\n }\n const bits = Fn.BITS;\n const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits);\n Point.BASE.precompute(8); // Enable precomputes. Slows down first publicKey computation by 20ms.\n return Point;\n}\n// Points start with byte 0x02 when y is even; otherwise 0x03\nfunction pprefix(hasEvenY) {\n return Uint8Array.of(hasEvenY ? 0x02 : 0x03);\n}\n/**\n * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.\n * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.\n * b = True and y = sqrt(u / v) if (u / v) is square in F, and\n * b = False and y = sqrt(Z * (u / v)) otherwise.\n * @param Fp\n * @param Z\n * @returns\n */\nexport function SWUFpSqrtRatio(Fp, Z) {\n // Generic implementation\n const q = Fp.ORDER;\n let l = _0n;\n for (let o = q - _1n; o % _2n === _0n; o /= _2n)\n l += _1n;\n const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.\n // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.\n // 2n ** c1 == 2n << (c1-1)\n const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);\n const _2n_pow_c1 = _2n_pow_c1_1 * _2n;\n const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1) # Integer arithmetic\n const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2 # Integer arithmetic\n const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1 # Integer arithmetic\n const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1) # Integer arithmetic\n const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2\n const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)\n let sqrtRatio = (u, v) => {\n let tv1 = c6; // 1. tv1 = c6\n let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4\n let tv3 = Fp.sqr(tv2); // 3. tv3 = tv2^2\n tv3 = Fp.mul(tv3, v); // 4. tv3 = tv3 * v\n let tv5 = Fp.mul(u, tv3); // 5. tv5 = u * tv3\n tv5 = Fp.pow(tv5, c3); // 6. tv5 = tv5^c3\n tv5 = Fp.mul(tv5, tv2); // 7. tv5 = tv5 * tv2\n tv2 = Fp.mul(tv5, v); // 8. tv2 = tv5 * v\n tv3 = Fp.mul(tv5, u); // 9. tv3 = tv5 * u\n let tv4 = Fp.mul(tv3, tv2); // 10. tv4 = tv3 * tv2\n tv5 = Fp.pow(tv4, c5); // 11. tv5 = tv4^c5\n let isQR = Fp.eql(tv5, Fp.ONE); // 12. isQR = tv5 == 1\n tv2 = Fp.mul(tv3, c7); // 13. tv2 = tv3 * c7\n tv5 = Fp.mul(tv4, tv1); // 14. tv5 = tv4 * tv1\n tv3 = Fp.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)\n tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)\n // 17. for i in (c1, c1 - 1, ..., 2):\n for (let i = c1; i > _1n; i--) {\n let tv5 = i - _2n; // 18. tv5 = i - 2\n tv5 = _2n << (tv5 - _1n); // 19. tv5 = 2^tv5\n let tvv5 = Fp.pow(tv4, tv5); // 20. tv5 = tv4^tv5\n const e1 = Fp.eql(tvv5, Fp.ONE); // 21. e1 = tv5 == 1\n tv2 = Fp.mul(tv3, tv1); // 22. tv2 = tv3 * tv1\n tv1 = Fp.mul(tv1, tv1); // 23. tv1 = tv1 * tv1\n tvv5 = Fp.mul(tv4, tv1); // 24. tv5 = tv4 * tv1\n tv3 = Fp.cmov(tv2, tv3, e1); // 25. tv3 = CMOV(tv2, tv3, e1)\n tv4 = Fp.cmov(tvv5, tv4, e1); // 26. tv4 = CMOV(tv5, tv4, e1)\n }\n return { isValid: isQR, value: tv3 };\n };\n if (Fp.ORDER % _4n === _3n) {\n // sqrt_ratio_3mod4(u, v)\n const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4 # Integer arithmetic\n const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)\n sqrtRatio = (u, v) => {\n let tv1 = Fp.sqr(v); // 1. tv1 = v^2\n const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n };\n }\n // No curves uses that\n // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n return sqrtRatio;\n}\n/**\n * Simplified Shallue-van de Woestijne-Ulas Method\n * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2\n */\nexport function mapToCurveSimpleSWU(Fp, opts) {\n validateField(Fp);\n const { A, B, Z } = opts;\n if (!Fp.isValid(A) || !Fp.isValid(B) || !Fp.isValid(Z))\n throw new Error('mapToCurveSimpleSWU: invalid opts');\n const sqrtRatio = SWUFpSqrtRatio(Fp, Z);\n if (!Fp.isOdd)\n throw new Error('Field does not have .isOdd()');\n // Input: u, an element of F.\n // Output: (x, y), a point on E.\n return (u) => {\n // prettier-ignore\n let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n tv1 = Fp.sqr(u); // 1. tv1 = u^2\n tv1 = Fp.mul(tv1, Z); // 2. tv1 = Z * tv1\n tv2 = Fp.sqr(tv1); // 3. tv2 = tv1^2\n tv2 = Fp.add(tv2, tv1); // 4. tv2 = tv2 + tv1\n tv3 = Fp.add(tv2, Fp.ONE); // 5. tv3 = tv2 + 1\n tv3 = Fp.mul(tv3, B); // 6. tv3 = B * tv3\n tv4 = Fp.cmov(Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7. tv4 = CMOV(Z, -tv2, tv2 != 0)\n tv4 = Fp.mul(tv4, A); // 8. tv4 = A * tv4\n tv2 = Fp.sqr(tv3); // 9. tv2 = tv3^2\n tv6 = Fp.sqr(tv4); // 10. tv6 = tv4^2\n tv5 = Fp.mul(tv6, A); // 11. tv5 = A * tv6\n tv2 = Fp.add(tv2, tv5); // 12. tv2 = tv2 + tv5\n tv2 = Fp.mul(tv2, tv3); // 13. tv2 = tv2 * tv3\n tv6 = Fp.mul(tv6, tv4); // 14. tv6 = tv6 * tv4\n tv5 = Fp.mul(tv6, B); // 15. tv5 = B * tv6\n tv2 = Fp.add(tv2, tv5); // 16. tv2 = tv2 + tv5\n x = Fp.mul(tv1, tv3); // 17. x = tv1 * tv3\n const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)\n y = Fp.mul(tv1, u); // 19. y = tv1 * u -> Z * u^3 * y1\n y = Fp.mul(y, value); // 20. y = y * y1\n x = Fp.cmov(x, tv3, isValid); // 21. x = CMOV(x, tv3, is_gx1_square)\n y = Fp.cmov(y, value, isValid); // 22. y = CMOV(y, y1, is_gx1_square)\n const e1 = Fp.isOdd(u) === Fp.isOdd(y); // 23. e1 = sgn0(u) == sgn0(y)\n y = Fp.cmov(Fp.neg(y), y, e1); // 24. y = CMOV(-y, y, e1)\n const tv4_inv = FpInvertBatch(Fp, [tv4], true)[0];\n x = Fp.mul(x, tv4_inv); // 25. x = x / tv4\n return { x, y };\n };\n}\nfunction getWLengths(Fp, Fn) {\n return {\n secretKey: Fn.BYTES,\n publicKey: 1 + Fp.BYTES,\n publicKeyUncompressed: 1 + 2 * Fp.BYTES,\n publicKeyHasPrefix: true,\n signature: 2 * Fn.BYTES,\n };\n}\n/**\n * Sometimes users only need getPublicKey, getSharedSecret, and secret key handling.\n * This helper ensures no signature functionality is present. Less code, smaller bundle size.\n */\nexport function ecdh(Point, ecdhOpts = {}) {\n const { Fn } = Point;\n const randomBytes_ = ecdhOpts.randomBytes || wcRandomBytes;\n const lengths = Object.assign(getWLengths(Point.Fp, Fn), { seed: getMinHashLength(Fn.ORDER) });\n function isValidSecretKey(secretKey) {\n try {\n const num = Fn.fromBytes(secretKey);\n return Fn.isValidNot0(num);\n }\n catch (error) {\n return false;\n }\n }\n function isValidPublicKey(publicKey, isCompressed) {\n const { publicKey: comp, publicKeyUncompressed } = lengths;\n try {\n const l = publicKey.length;\n if (isCompressed === true && l !== comp)\n return false;\n if (isCompressed === false && l !== publicKeyUncompressed)\n return false;\n return !!Point.fromBytes(publicKey);\n }\n catch (error) {\n return false;\n }\n }\n /**\n * Produces cryptographically secure secret key from random of size\n * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.\n */\n function randomSecretKey(seed = randomBytes_(lengths.seed)) {\n return mapHashToField(abytes(seed, lengths.seed, 'seed'), Fn.ORDER);\n }\n /**\n * Computes public key for a secret key. Checks for validity of the secret key.\n * @param isCompressed whether to return compact (default), or full key\n * @returns Public key, full when isCompressed=false; short when isCompressed=true\n */\n function getPublicKey(secretKey, isCompressed = true) {\n return Point.BASE.multiply(Fn.fromBytes(secretKey)).toBytes(isCompressed);\n }\n /**\n * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n */\n function isProbPub(item) {\n const { secretKey, publicKey, publicKeyUncompressed } = lengths;\n if (!isBytes(item))\n return undefined;\n if (('_lengths' in Fn && Fn._lengths) || secretKey === publicKey)\n return undefined;\n const l = abytes(item, undefined, 'key').length;\n return l === publicKey || l === publicKeyUncompressed;\n }\n /**\n * ECDH (Elliptic Curve Diffie Hellman).\n * Computes shared public key from secret key A and public key B.\n * Checks: 1) secret key validity 2) shared key is on-curve.\n * Does NOT hash the result.\n * @param isCompressed whether to return compact (default), or full key\n * @returns shared public key\n */\n function getSharedSecret(secretKeyA, publicKeyB, isCompressed = true) {\n if (isProbPub(secretKeyA) === true)\n throw new Error('first arg must be private key');\n if (isProbPub(publicKeyB) === false)\n throw new Error('second arg must be public key');\n const s = Fn.fromBytes(secretKeyA);\n const b = Point.fromBytes(publicKeyB); // checks for being on-curve\n return b.multiply(s).toBytes(isCompressed);\n }\n const utils = {\n isValidSecretKey,\n isValidPublicKey,\n randomSecretKey,\n };\n const keygen = createKeygen(randomSecretKey, getPublicKey);\n return Object.freeze({ getPublicKey, getSharedSecret, keygen, Point, utils, lengths });\n}\n/**\n * Creates ECDSA signing interface for given elliptic curve `Point` and `hash` function.\n *\n * @param Point created using {@link weierstrass} function\n * @param hash used for 1) message prehash-ing 2) k generation in `sign`, using hmac_drbg(hash)\n * @param ecdsaOpts rarely needed, see {@link ECDSAOpts}\n *\n * @example\n * ```js\n * const p256_Point = weierstrass(...);\n * const p256_sha256 = ecdsa(p256_Point, sha256);\n * const p256_sha224 = ecdsa(p256_Point, sha224);\n * const p256_sha224_r = ecdsa(p256_Point, sha224, { randomBytes: (length) => { ... } });\n * ```\n */\nexport function ecdsa(Point, hash, ecdsaOpts = {}) {\n ahash(hash);\n validateObject(ecdsaOpts, {}, {\n hmac: 'function',\n lowS: 'boolean',\n randomBytes: 'function',\n bits2int: 'function',\n bits2int_modN: 'function',\n });\n ecdsaOpts = Object.assign({}, ecdsaOpts);\n const randomBytes = ecdsaOpts.randomBytes || wcRandomBytes;\n const hmac = ecdsaOpts.hmac || ((key, msg) => nobleHmac(hash, key, msg));\n const { Fp, Fn } = Point;\n const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;\n const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);\n const defaultSigOpts = {\n prehash: true,\n lowS: typeof ecdsaOpts.lowS === 'boolean' ? ecdsaOpts.lowS : true,\n format: 'compact',\n extraEntropy: false,\n };\n const hasLargeCofactor = CURVE_ORDER * _2n < Fp.ORDER; // Won't CURVE().h > 2n be more effective?\n function isBiggerThanHalfOrder(number) {\n const HALF = CURVE_ORDER >> _1n;\n return number > HALF;\n }\n function validateRS(title, num) {\n if (!Fn.isValidNot0(num))\n throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);\n return num;\n }\n function assertSmallCofactor() {\n // ECDSA recovery is hard for cofactor > 1 curves.\n // In sign, `r = q.x mod n`, and here we recover q.x from r.\n // While recovering q.x >= n, we need to add r+n for cofactor=1 curves.\n // However, for cofactor>1, r+n may not get q.x:\n // r+n*i would need to be done instead where i is unknown.\n // To easily get i, we either need to:\n // a. increase amount of valid recid values (4, 5...); OR\n // b. prohibit non-prime-order signatures (recid > 1).\n if (hasLargeCofactor)\n throw new Error('\"recovered\" sig type is not supported for cofactor >2 curves');\n }\n function validateSigLength(bytes, format) {\n validateSigFormat(format);\n const size = lengths.signature;\n const sizer = format === 'compact' ? size : format === 'recovered' ? size + 1 : undefined;\n return abytes(bytes, sizer);\n }\n /**\n * ECDSA signature with its (r, s) properties. Supports compact, recovered & DER representations.\n */\n class Signature {\n r;\n s;\n recovery;\n constructor(r, s, recovery) {\n this.r = validateRS('r', r); // r in [1..N-1];\n this.s = validateRS('s', s); // s in [1..N-1];\n if (recovery != null) {\n assertSmallCofactor();\n if (![0, 1, 2, 3].includes(recovery))\n throw new Error('invalid recovery id');\n this.recovery = recovery;\n }\n Object.freeze(this);\n }\n static fromBytes(bytes, format = defaultSigOpts.format) {\n validateSigLength(bytes, format);\n let recid;\n if (format === 'der') {\n const { r, s } = DER.toSig(abytes(bytes));\n return new Signature(r, s);\n }\n if (format === 'recovered') {\n recid = bytes[0];\n format = 'compact';\n bytes = bytes.subarray(1);\n }\n const L = lengths.signature / 2;\n const r = bytes.subarray(0, L);\n const s = bytes.subarray(L, L * 2);\n return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid);\n }\n static fromHex(hex, format) {\n return this.fromBytes(hexToBytes(hex), format);\n }\n assertRecovery() {\n const { recovery } = this;\n if (recovery == null)\n throw new Error('invalid recovery id: must be present');\n return recovery;\n }\n addRecoveryBit(recovery) {\n return new Signature(this.r, this.s, recovery);\n }\n recoverPublicKey(messageHash) {\n const { r, s } = this;\n const recovery = this.assertRecovery();\n const radj = recovery === 2 || recovery === 3 ? r + CURVE_ORDER : r;\n if (!Fp.isValid(radj))\n throw new Error('invalid recovery id: sig.r+curve.n != R.x');\n const x = Fp.toBytes(radj);\n const R = Point.fromBytes(concatBytes(pprefix((recovery & 1) === 0), x));\n const ir = Fn.inv(radj); // r^-1\n const h = bits2int_modN(abytes(messageHash, undefined, 'msgHash')); // Truncate hash\n const u1 = Fn.create(-h * ir); // -hr^-1\n const u2 = Fn.create(s * ir); // sr^-1\n // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1). unsafe is fine: there is no private data.\n const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));\n if (Q.is0())\n throw new Error('invalid recovery: point at infinify');\n Q.assertValidity();\n return Q;\n }\n // Signatures should be low-s, to prevent malleability.\n hasHighS() {\n return isBiggerThanHalfOrder(this.s);\n }\n toBytes(format = defaultSigOpts.format) {\n validateSigFormat(format);\n if (format === 'der')\n return hexToBytes(DER.hexFromSig(this));\n const { r, s } = this;\n const rb = Fn.toBytes(r);\n const sb = Fn.toBytes(s);\n if (format === 'recovered') {\n assertSmallCofactor();\n return concatBytes(Uint8Array.of(this.assertRecovery()), rb, sb);\n }\n return concatBytes(rb, sb);\n }\n toHex(format) {\n return bytesToHex(this.toBytes(format));\n }\n }\n // RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.\n // FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.\n // bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.\n // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors\n const bits2int = ecdsaOpts.bits2int ||\n function bits2int_def(bytes) {\n // Our custom check \"just in case\", for protection against DoS\n if (bytes.length > 8192)\n throw new Error('input is too large');\n // For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)\n // for some cases, since bytes.length * 8 is not actual bitLength.\n const num = bytesToNumberBE(bytes); // check for == u8 done here\n const delta = bytes.length * 8 - fnBits; // truncate to nBitLength leftmost bits\n return delta > 0 ? num >> BigInt(delta) : num;\n };\n const bits2int_modN = ecdsaOpts.bits2int_modN ||\n function bits2int_modN_def(bytes) {\n return Fn.create(bits2int(bytes)); // can't use bytesToNumberBE here\n };\n // Pads output with zero as per spec\n const ORDER_MASK = bitMask(fnBits);\n /** Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`. */\n function int2octets(num) {\n // IMPORTANT: the check ensures working for case `Fn.BYTES != Fn.BITS * 8`\n aInRange('num < 2^' + fnBits, num, _0n, ORDER_MASK);\n return Fn.toBytes(num);\n }\n function validateMsgAndHash(message, prehash) {\n abytes(message, undefined, 'message');\n return prehash ? abytes(hash(message), undefined, 'prehashed message') : message;\n }\n /**\n * Steps A, D of RFC6979 3.2.\n * Creates RFC6979 seed; converts msg/privKey to numbers.\n * Used only in sign, not in verify.\n *\n * Warning: we cannot assume here that message has same amount of bytes as curve order,\n * this will be invalid at least for P521. Also it can be bigger for P224 + SHA256.\n */\n function prepSig(message, secretKey, opts) {\n const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts);\n message = validateMsgAndHash(message, prehash); // RFC6979 3.2 A: h1 = H(m)\n // We can't later call bits2octets, since nested bits2int is broken for curves\n // with fnBits % 8 !== 0. Because of that, we unwrap it here as int2octets call.\n // const bits2octets = (bits) => int2octets(bits2int_modN(bits))\n const h1int = bits2int_modN(message);\n const d = Fn.fromBytes(secretKey); // validate secret key, convert to bigint\n if (!Fn.isValidNot0(d))\n throw new Error('invalid private key');\n const seedArgs = [int2octets(d), int2octets(h1int)];\n // extraEntropy. RFC6979 3.6: additional k' (optional).\n if (extraEntropy != null && extraEntropy !== false) {\n // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')\n // gen random bytes OR pass as-is\n const e = extraEntropy === true ? randomBytes(lengths.secretKey) : extraEntropy;\n seedArgs.push(abytes(e, undefined, 'extraEntropy')); // check for being bytes\n }\n const seed = concatBytes(...seedArgs); // Step D of RFC6979 3.2\n const m = h1int; // no need to call bits2int second time here, it is inside truncateHash!\n // Converts signature params into point w r/s, checks result for validity.\n // To transform k => Signature:\n // q = k⋅G\n // r = q.x mod n\n // s = k^-1(m + rd) mod n\n // Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to\n // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:\n // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT\n function k2sig(kBytes) {\n // RFC 6979 Section 3.2, step 3: k = bits2int(T)\n // Important: all mod() calls here must be done over N\n const k = bits2int(kBytes); // Cannot use fields methods, since it is group element\n if (!Fn.isValidNot0(k))\n return; // Valid scalars (including k) must be in 1..N-1\n const ik = Fn.inv(k); // k^-1 mod n\n const q = Point.BASE.multiply(k).toAffine(); // q = k⋅G\n const r = Fn.create(q.x); // r = q.x mod n\n if (r === _0n)\n return;\n const s = Fn.create(ik * Fn.create(m + r * d)); // s = k^-1(m + rd) mod n\n if (s === _0n)\n return;\n let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3 when q.x>n)\n let normS = s;\n if (lowS && isBiggerThanHalfOrder(s)) {\n normS = Fn.neg(s); // if lowS was passed, ensure s is always in the bottom half of N\n recovery ^= 1;\n }\n return new Signature(r, normS, hasLargeCofactor ? undefined : recovery);\n }\n return { seed, k2sig };\n }\n /**\n * Signs message hash with a secret key.\n *\n * ```\n * sign(m, d) where\n * k = rfc6979_hmac_drbg(m, d)\n * (x, y) = G × k\n * r = x mod n\n * s = (m + dr) / k mod n\n * ```\n */\n function sign(message, secretKey, opts = {}) {\n const { seed, k2sig } = prepSig(message, secretKey, opts); // Steps A, D of RFC6979 3.2.\n const drbg = createHmacDrbg(hash.outputLen, Fn.BYTES, hmac);\n const sig = drbg(seed, k2sig); // Steps B, C, D, E, F, G\n return sig.toBytes(opts.format);\n }\n /**\n * Verifies a signature against message and public key.\n * Rejects lowS signatures by default: see {@link ECDSAVerifyOpts}.\n * Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:\n *\n * ```\n * verify(r, s, h, P) where\n * u1 = hs^-1 mod n\n * u2 = rs^-1 mod n\n * R = u1⋅G + u2⋅P\n * mod(R.x, n) == r\n * ```\n */\n function verify(signature, message, publicKey, opts = {}) {\n const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);\n publicKey = abytes(publicKey, undefined, 'publicKey');\n message = validateMsgAndHash(message, prehash);\n if (!isBytes(signature)) {\n const end = signature instanceof Signature ? ', use sig.toBytes()' : '';\n throw new Error('verify expects Uint8Array signature' + end);\n }\n validateSigLength(signature, format); // execute this twice because we want loud error\n try {\n const sig = Signature.fromBytes(signature, format);\n const P = Point.fromBytes(publicKey);\n if (lowS && sig.hasHighS())\n return false;\n const { r, s } = sig;\n const h = bits2int_modN(message); // mod n, not mod p\n const is = Fn.inv(s); // s^-1 mod n\n const u1 = Fn.create(h * is); // u1 = hs^-1 mod n\n const u2 = Fn.create(r * is); // u2 = rs^-1 mod n\n const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2)); // u1⋅G + u2⋅P\n if (R.is0())\n return false;\n const v = Fn.create(R.x); // v = r.x mod n\n return v === r;\n }\n catch (e) {\n return false;\n }\n }\n function recoverPublicKey(signature, message, opts = {}) {\n const { prehash } = validateSigOpts(opts, defaultSigOpts);\n message = validateMsgAndHash(message, prehash);\n return Signature.fromBytes(signature, 'recovered').recoverPublicKey(message).toBytes();\n }\n return Object.freeze({\n keygen,\n getPublicKey,\n getSharedSecret,\n utils,\n lengths,\n Point,\n sign,\n verify,\n recoverPublicKey,\n Signature,\n hash,\n });\n}\n//# sourceMappingURL=weierstrass.js.map","/**\n * SECG secp256k1. See [pdf](https://www.secg.org/sec2-v2.pdf).\n *\n * Belongs to Koblitz curves: it has efficiently-computable GLV endomorphism ψ,\n * check out {@link EndomorphismOpts}. Seems to be rigid (not backdoored).\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { randomBytes } from '@noble/hashes/utils.js';\nimport { createKeygen } from \"./abstract/curve.js\";\nimport { createHasher, isogenyMap } from \"./abstract/hash-to-curve.js\";\nimport { Field, mapHashToField, pow2 } from \"./abstract/modular.js\";\nimport { ecdsa, mapToCurveSimpleSWU, weierstrass, } from \"./abstract/weierstrass.js\";\nimport { abytes, asciiToBytes, bytesToNumberBE, concatBytes } from \"./utils.js\";\n// Seems like generator was produced from some seed:\n// `Pointk1.BASE.multiply(Pointk1.Fn.inv(2n, N)).toAffine().x`\n// // gives short x 0x3b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63n\nconst secp256k1_CURVE = {\n p: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),\n n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),\n h: BigInt(1),\n a: BigInt(0),\n b: BigInt(7),\n Gx: BigInt('0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),\n Gy: BigInt('0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'),\n};\nconst secp256k1_ENDO = {\n beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n basises: [\n [BigInt('0x3086d221a7d46bcde86c90e49284eb15'), -BigInt('0xe4437ed6010e88286f547fa90abfe4c3')],\n [BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8'), BigInt('0x3086d221a7d46bcde86c90e49284eb15')],\n ],\n};\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _2n = /* @__PURE__ */ BigInt(2);\n/**\n * √n = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.\n * (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]\n */\nfunction sqrtMod(y) {\n const P = secp256k1_CURVE.p;\n // prettier-ignore\n const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);\n // prettier-ignore\n const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);\n const b2 = (y * y * y) % P; // x^3, 11\n const b3 = (b2 * b2 * y) % P; // x^7\n const b6 = (pow2(b3, _3n, P) * b3) % P;\n const b9 = (pow2(b6, _3n, P) * b3) % P;\n const b11 = (pow2(b9, _2n, P) * b2) % P;\n const b22 = (pow2(b11, _11n, P) * b11) % P;\n const b44 = (pow2(b22, _22n, P) * b22) % P;\n const b88 = (pow2(b44, _44n, P) * b44) % P;\n const b176 = (pow2(b88, _88n, P) * b88) % P;\n const b220 = (pow2(b176, _44n, P) * b44) % P;\n const b223 = (pow2(b220, _3n, P) * b3) % P;\n const t1 = (pow2(b223, _23n, P) * b22) % P;\n const t2 = (pow2(t1, _6n, P) * b2) % P;\n const root = pow2(t2, _2n, P);\n if (!Fpk1.eql(Fpk1.sqr(root), y))\n throw new Error('Cannot find square root');\n return root;\n}\nconst Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });\nconst Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {\n Fp: Fpk1,\n endo: secp256k1_ENDO,\n});\n/**\n * secp256k1 curve: ECDSA and ECDH methods.\n *\n * Uses sha256 to hash messages. To use a different hash,\n * pass `{ prehash: false }` to sign / verify.\n *\n * @example\n * ```js\n * import { secp256k1 } from '@noble/curves/secp256k1.js';\n * const { secretKey, publicKey } = secp256k1.keygen();\n * // const publicKey = secp256k1.getPublicKey(secretKey);\n * const msg = new TextEncoder().encode('hello noble');\n * const sig = secp256k1.sign(msg, secretKey);\n * const isValid = secp256k1.verify(sig, msg, publicKey);\n * // const sigKeccak = secp256k1.sign(keccak256(msg), secretKey, { prehash: false });\n * ```\n */\nexport const secp256k1 = /* @__PURE__ */ ecdsa(Pointk1, sha256);\n// Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.\n// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */\nconst TAGGED_HASH_PREFIXES = {};\nfunction taggedHash(tag, ...messages) {\n let tagP = TAGGED_HASH_PREFIXES[tag];\n if (tagP === undefined) {\n const tagH = sha256(asciiToBytes(tag));\n tagP = concatBytes(tagH, tagH);\n TAGGED_HASH_PREFIXES[tag] = tagP;\n }\n return sha256(concatBytes(tagP, ...messages));\n}\n// ECDSA compact points are 33-byte. Schnorr is 32: we strip first byte 0x02 or 0x03\nconst pointToBytes = (point) => point.toBytes(true).slice(1);\nconst hasEven = (y) => y % _2n === _0n;\n// Calculate point, scalar and bytes\nfunction schnorrGetExtPubKey(priv) {\n const { Fn, BASE } = Pointk1;\n const d_ = Fn.fromBytes(priv);\n const p = BASE.multiply(d_); // P = d'⋅G; 0 < d' < n check is done inside\n const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);\n return { scalar, bytes: pointToBytes(p) };\n}\n/**\n * lift_x from BIP340. Convert 32-byte x coordinate to elliptic curve point.\n * @returns valid point checked for being on-curve\n */\nfunction lift_x(x) {\n const Fp = Fpk1;\n if (!Fp.isValidNot0(x))\n throw new Error('invalid x: Fail if x ≥ p');\n const xx = Fp.create(x * x);\n const c = Fp.create(xx * x + BigInt(7)); // Let c = x³ + 7 mod p.\n let y = Fp.sqrt(c); // Let y = c^(p+1)/4 mod p. Same as sqrt().\n // Return the unique point P such that x(P) = x and\n // y(P) = y if y mod 2 = 0 or y(P) = p-y otherwise.\n if (!hasEven(y))\n y = Fp.neg(y);\n const p = Pointk1.fromAffine({ x, y });\n p.assertValidity();\n return p;\n}\nconst num = bytesToNumberBE;\n/**\n * Create tagged hash, convert it to bigint, reduce modulo-n.\n */\nfunction challenge(...args) {\n return Pointk1.Fn.create(num(taggedHash('BIP0340/challenge', ...args)));\n}\n/**\n * Schnorr public key is just `x` coordinate of Point as per BIP340.\n */\nfunction schnorrGetPublicKey(secretKey) {\n return schnorrGetExtPubKey(secretKey).bytes; // d'=int(sk). Fail if d'=0 or d'≥n. Ret bytes(d'⋅G)\n}\n/**\n * Creates Schnorr signature as per BIP340. Verifies itself before returning anything.\n * auxRand is optional and is not the sole source of k generation: bad CSPRNG won't be dangerous.\n */\nfunction schnorrSign(message, secretKey, auxRand = randomBytes(32)) {\n const { Fn } = Pointk1;\n const m = abytes(message, undefined, 'message');\n const { bytes: px, scalar: d } = schnorrGetExtPubKey(secretKey); // checks for isWithinCurveOrder\n const a = abytes(auxRand, 32, 'auxRand'); // Auxiliary random data a: a 32-byte array\n const t = Fn.toBytes(d ^ num(taggedHash('BIP0340/aux', a))); // Let t be the byte-wise xor of bytes(d) and hash/aux(a)\n const rand = taggedHash('BIP0340/nonce', t, px, m); // Let rand = hash/nonce(t || bytes(P) || m)\n // Let k' = int(rand) mod n. Fail if k' = 0. Let R = k'⋅G\n const { bytes: rx, scalar: k } = schnorrGetExtPubKey(rand);\n const e = challenge(rx, px, m); // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.\n const sig = new Uint8Array(64); // Let sig = bytes(R) || bytes((k + ed) mod n).\n sig.set(rx, 0);\n sig.set(Fn.toBytes(Fn.create(k + e * d)), 32);\n // If Verify(bytes(P), m, sig) (see below) returns failure, abort\n if (!schnorrVerify(sig, m, px))\n throw new Error('sign: Invalid signature produced');\n return sig;\n}\n/**\n * Verifies Schnorr signature.\n * Will swallow errors & return false except for initial type validation of arguments.\n */\nfunction schnorrVerify(signature, message, publicKey) {\n const { Fp, Fn, BASE } = Pointk1;\n const sig = abytes(signature, 64, 'signature');\n const m = abytes(message, undefined, 'message');\n const pub = abytes(publicKey, 32, 'publicKey');\n try {\n const P = lift_x(num(pub)); // P = lift_x(int(pk)); fail if that fails\n const r = num(sig.subarray(0, 32)); // Let r = int(sig[0:32]); fail if r ≥ p.\n if (!Fp.isValidNot0(r))\n return false;\n const s = num(sig.subarray(32, 64)); // Let s = int(sig[32:64]); fail if s ≥ n.\n if (!Fn.isValidNot0(s))\n return false;\n const e = challenge(Fn.toBytes(r), pointToBytes(P), m); // int(challenge(bytes(r)||bytes(P)||m))%n\n // R = s⋅G - e⋅P, where -eP == (n-e)P\n const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));\n const { x, y } = R.toAffine();\n // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.\n if (R.is0() || !hasEven(y) || x !== r)\n return false;\n return true;\n }\n catch (error) {\n return false;\n }\n}\n/**\n * Schnorr signatures over secp256k1.\n * https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n * @example\n * ```js\n * import { schnorr } from '@noble/curves/secp256k1.js';\n * const { secretKey, publicKey } = schnorr.keygen();\n * // const publicKey = schnorr.getPublicKey(secretKey);\n * const msg = new TextEncoder().encode('hello');\n * const sig = schnorr.sign(msg, secretKey);\n * const isValid = schnorr.verify(sig, msg, publicKey);\n * ```\n */\nexport const schnorr = /* @__PURE__ */ (() => {\n const size = 32;\n const seedLength = 48;\n const randomSecretKey = (seed = randomBytes(seedLength)) => {\n return mapHashToField(seed, secp256k1_CURVE.n);\n };\n return {\n keygen: createKeygen(randomSecretKey, schnorrGetPublicKey),\n getPublicKey: schnorrGetPublicKey,\n sign: schnorrSign,\n verify: schnorrVerify,\n Point: Pointk1,\n utils: {\n randomSecretKey,\n taggedHash,\n lift_x,\n pointToBytes,\n },\n lengths: {\n secretKey: size,\n publicKey: size,\n publicKeyHasPrefix: false,\n signature: size * 2,\n seed: seedLength,\n },\n };\n})();\nconst isoMap = /* @__PURE__ */ (() => isogenyMap(Fpk1, [\n // xNum\n [\n '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7',\n '0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581',\n '0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262',\n '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c',\n ],\n // xDen\n [\n '0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b',\n '0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14',\n '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n ],\n // yNum\n [\n '0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c',\n '0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3',\n '0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931',\n '0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84',\n ],\n // yDen\n [\n '0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b',\n '0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573',\n '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',\n '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n ],\n].map((i) => i.map((j) => BigInt(j)))))();\nconst mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fpk1, {\n A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),\n B: BigInt('1771'),\n Z: Fpk1.create(BigInt('-11')),\n}))();\n/** Hashing / encoding to secp256k1 points / field. RFC 9380 methods. */\nexport const secp256k1_hasher = /* @__PURE__ */ (() => createHasher(Pointk1, (scalars) => {\n const { x, y } = mapSWU(Fpk1.create(scalars[0]));\n return isoMap(x, y);\n}, {\n DST: 'secp256k1_XMD:SHA-256_SSWU_RO_',\n encodeDST: 'secp256k1_XMD:SHA-256_SSWU_NU_',\n p: Fpk1.ORDER,\n m: 1,\n k: 128,\n expand: 'xmd',\n hash: sha256,\n}))();\n//# sourceMappingURL=secp256k1.js.map","/**\n\nSHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.\nDon't use them in a new protocol. What \"weak\" means:\n\n- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.\n- No practical pre-image attacks (only theoretical, 2^123.4)\n- HMAC seems kinda ok: https://www.rfc-editor.org/rfc/rfc6151\n * @module\n */\nimport { Chi, HashMD, Maj } from \"./_md.js\";\nimport { clean, createHasher, rotl } from \"./utils.js\";\n/** Initial SHA1 state */\nconst SHA1_IV = /* @__PURE__ */ Uint32Array.from([\n 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0,\n]);\n// Reusable temporary buffer\nconst SHA1_W = /* @__PURE__ */ new Uint32Array(80);\n/** Internal SHA1 legacy hash class. */\nexport class _SHA1 extends HashMD {\n A = SHA1_IV[0] | 0;\n B = SHA1_IV[1] | 0;\n C = SHA1_IV[2] | 0;\n D = SHA1_IV[3] | 0;\n E = SHA1_IV[4] | 0;\n constructor() {\n super(64, 20, 8, false);\n }\n get() {\n const { A, B, C, D, E } = this;\n return [A, B, C, D, E];\n }\n set(A, B, C, D, E) {\n this.A = A | 0;\n this.B = B | 0;\n this.C = C | 0;\n this.D = D | 0;\n this.E = E | 0;\n }\n process(view, offset) {\n for (let i = 0; i < 16; i++, offset += 4)\n SHA1_W[i] = view.getUint32(offset, false);\n for (let i = 16; i < 80; i++)\n SHA1_W[i] = rotl(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);\n // Compression function main loop, 80 rounds\n let { A, B, C, D, E } = this;\n for (let i = 0; i < 80; i++) {\n let F, K;\n if (i < 20) {\n F = Chi(B, C, D);\n K = 0x5a827999;\n }\n else if (i < 40) {\n F = B ^ C ^ D;\n K = 0x6ed9eba1;\n }\n else if (i < 60) {\n F = Maj(B, C, D);\n K = 0x8f1bbcdc;\n }\n else {\n F = B ^ C ^ D;\n K = 0xca62c1d6;\n }\n const T = (rotl(A, 5) + F + E + K + SHA1_W[i]) | 0;\n E = D;\n D = C;\n C = rotl(B, 30);\n B = A;\n A = T;\n }\n // Add the compressed chunk to the current hash value\n A = (A + this.A) | 0;\n B = (B + this.B) | 0;\n C = (C + this.C) | 0;\n D = (D + this.D) | 0;\n E = (E + this.E) | 0;\n this.set(A, B, C, D, E);\n }\n roundClean() {\n clean(SHA1_W);\n }\n destroy() {\n this.set(0, 0, 0, 0, 0);\n clean(this.buffer);\n }\n}\n/** SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */\nexport const sha1 = /* @__PURE__ */ createHasher(() => new _SHA1());\n/** Per-round constants */\nconst p32 = /* @__PURE__ */ Math.pow(2, 32);\nconst K = /* @__PURE__ */ Array.from({ length: 64 }, (_, i) => Math.floor(p32 * Math.abs(Math.sin(i + 1))));\n/** md5 initial state: same as sha1, but 4 u32 instead of 5. */\nconst MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);\n// Reusable temporary buffer\nconst MD5_W = /* @__PURE__ */ new Uint32Array(16);\n/** Internal MD5 legacy hash class. */\nexport class _MD5 extends HashMD {\n A = MD5_IV[0] | 0;\n B = MD5_IV[1] | 0;\n C = MD5_IV[2] | 0;\n D = MD5_IV[3] | 0;\n constructor() {\n super(64, 16, 8, true);\n }\n get() {\n const { A, B, C, D } = this;\n return [A, B, C, D];\n }\n set(A, B, C, D) {\n this.A = A | 0;\n this.B = B | 0;\n this.C = C | 0;\n this.D = D | 0;\n }\n process(view, offset) {\n for (let i = 0; i < 16; i++, offset += 4)\n MD5_W[i] = view.getUint32(offset, true);\n // Compression function main loop, 64 rounds\n let { A, B, C, D } = this;\n for (let i = 0; i < 64; i++) {\n let F, g, s;\n if (i < 16) {\n F = Chi(B, C, D);\n g = i;\n s = [7, 12, 17, 22];\n }\n else if (i < 32) {\n F = Chi(D, B, C);\n g = (5 * i + 1) % 16;\n s = [5, 9, 14, 20];\n }\n else if (i < 48) {\n F = B ^ C ^ D;\n g = (3 * i + 5) % 16;\n s = [4, 11, 16, 23];\n }\n else {\n F = C ^ (B | ~D);\n g = (7 * i) % 16;\n s = [6, 10, 15, 21];\n }\n F = F + A + K[i] + MD5_W[g];\n A = D;\n D = C;\n C = B;\n B = B + rotl(F, s[i % 4]);\n }\n // Add the compressed chunk to the current hash value\n A = (A + this.A) | 0;\n B = (B + this.B) | 0;\n C = (C + this.C) | 0;\n D = (D + this.D) | 0;\n this.set(A, B, C, D);\n }\n roundClean() {\n clean(MD5_W);\n }\n destroy() {\n this.set(0, 0, 0, 0);\n clean(this.buffer);\n }\n}\n/**\n * MD5 (RFC 1321) legacy hash function. It was cryptographically broken.\n * MD5 architecture is similar to SHA1, with some differences:\n * - Reduced output length: 16 bytes (128 bit) instead of 20\n * - 64 rounds, instead of 80\n * - Little-endian: could be faster, but will require more code\n * - Non-linear index selection: huge speed-up for unroll\n * - Per round constants: more memory accesses, additional speed-up for unroll\n */\nexport const md5 = /* @__PURE__ */ createHasher(() => new _MD5());\n// RIPEMD-160\nconst Rho160 = /* @__PURE__ */ Uint8Array.from([\n 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n]);\nconst Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();\nconst Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();\nconst idxLR = /* @__PURE__ */ (() => {\n const L = [Id160];\n const R = [Pi160];\n const res = [L, R];\n for (let i = 0; i < 4; i++)\n for (let j of res)\n j.push(j[i].map((k) => Rho160[k]));\n return res;\n})();\nconst idxL = /* @__PURE__ */ (() => idxLR[0])();\nconst idxR = /* @__PURE__ */ (() => idxLR[1])();\n// const [idxL, idxR] = idxLR;\nconst shifts160 = /* @__PURE__ */ [\n [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],\n [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],\n [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],\n [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],\n [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],\n].map((i) => Uint8Array.from(i));\nconst shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));\nconst shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));\nconst Kl160 = /* @__PURE__ */ Uint32Array.from([\n 0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,\n]);\nconst Kr160 = /* @__PURE__ */ Uint32Array.from([\n 0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,\n]);\n// It's called f() in spec.\nfunction ripemd_f(group, x, y, z) {\n if (group === 0)\n return x ^ y ^ z;\n if (group === 1)\n return (x & y) | (~x & z);\n if (group === 2)\n return (x | ~y) ^ z;\n if (group === 3)\n return (x & z) | (y & ~z);\n return x ^ (y | ~z);\n}\n// Reusable temporary buffer\nconst BUF_160 = /* @__PURE__ */ new Uint32Array(16);\nexport class _RIPEMD160 extends HashMD {\n h0 = 0x67452301 | 0;\n h1 = 0xefcdab89 | 0;\n h2 = 0x98badcfe | 0;\n h3 = 0x10325476 | 0;\n h4 = 0xc3d2e1f0 | 0;\n constructor() {\n super(64, 20, 8, true);\n }\n get() {\n const { h0, h1, h2, h3, h4 } = this;\n return [h0, h1, h2, h3, h4];\n }\n set(h0, h1, h2, h3, h4) {\n this.h0 = h0 | 0;\n this.h1 = h1 | 0;\n this.h2 = h2 | 0;\n this.h3 = h3 | 0;\n this.h4 = h4 | 0;\n }\n process(view, offset) {\n for (let i = 0; i < 16; i++, offset += 4)\n BUF_160[i] = view.getUint32(offset, true);\n // prettier-ignore\n let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;\n // Instead of iterating 0 to 80, we split it into 5 groups\n // And use the groups in constants, functions, etc. Much simpler\n for (let group = 0; group < 5; group++) {\n const rGroup = 4 - group;\n const hbl = Kl160[group], hbr = Kr160[group]; // prettier-ignore\n const rl = idxL[group], rr = idxR[group]; // prettier-ignore\n const sl = shiftsL160[group], sr = shiftsR160[group]; // prettier-ignore\n for (let i = 0; i < 16; i++) {\n const tl = (rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el) | 0;\n al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore\n }\n // 2 loops are 10% faster\n for (let i = 0; i < 16; i++) {\n const tr = (rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er) | 0;\n ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr; // prettier-ignore\n }\n }\n // Add the compressed chunk to the current hash value\n this.set((this.h1 + cl + dr) | 0, (this.h2 + dl + er) | 0, (this.h3 + el + ar) | 0, (this.h4 + al + br) | 0, (this.h0 + bl + cr) | 0);\n }\n roundClean() {\n clean(BUF_160);\n }\n destroy() {\n this.destroyed = true;\n clean(this.buffer);\n this.set(0, 0, 0, 0, 0);\n }\n}\n/**\n * RIPEMD-160 - a legacy hash function from 1990s.\n * * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html\n * * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf\n */\nexport const ripemd160 = /* @__PURE__ */ createHasher(() => new _RIPEMD160());\n//# sourceMappingURL=legacy.js.map","import { hex as baseHex, utf8 } from '@scure/base';\n/**\n * Define complex binary structures using composable primitives.\n * Main ideas:\n * - Encode / decode can be chained, same as in `scure-base`\n * - A complex structure can be created from an array and struct of primitive types\n * - Strings / bytes are arrays with specific optimizations: we can just read bytes directly\n * without creating plain array first and reading each byte separately.\n * - Types are inferred from definition\n * @module\n * @example\n * import * as P from 'micro-packed';\n * const s = P.struct({\n * field1: P.U32BE, // 32-bit unsigned big-endian integer\n * field2: P.string(P.U8), // String with U8 length prefix\n * field3: P.bytes(32), // 32 bytes\n * field4: P.array(P.U16BE, P.struct({ // Array of structs with U16BE length\n * subField1: P.U64BE, // 64-bit unsigned big-endian integer\n * subField2: P.string(10) // 10-byte string\n * }))\n * });\n */\n// TODO: remove dependency on scure-base & inline?\n/*\nExports can be groupped like this:\n\n- Primitive types: P.bytes, P.string, P.hex, P.constant, P.pointer\n- Complex types: P.array, P.struct, P.tuple, P.map, P.tag, P.mappedTag\n- Padding, prefix, magic: P.padLeft, P.padRight, P.prefix, P.magic, P.magicBytes\n- Flags: P.flag, P.flagged, P.optional\n- Wrappers: P.apply, P.wrap, P.lazy\n- Bit fiddling: P.bits, P.bitset\n- utils: P.validate, coders.decimal\n- Debugger\n*/\n/** Shortcut to zero-length (empty) byte array */\nexport const EMPTY = /* @__PURE__ */ Uint8Array.of();\n/** Shortcut to one-element (element is 0) byte array */\nexport const NULL = /* @__PURE__ */ Uint8Array.of(0);\n/** Checks if two Uint8Arrays are equal. Not constant-time. */\nfunction equalBytes(a, b) {\n if (a.length !== b.length)\n return false;\n for (let i = 0; i < a.length; i++)\n if (a[i] !== b[i])\n return false;\n return true;\n}\n/** Checks if the given value is a Uint8Array. */\nfunction isBytes(a) {\n return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/**\n * Concatenates multiple Uint8Arrays.\n * Engines limit functions to 65K+ arguments.\n * @param arrays Array of Uint8Array elements\n * @returns Concatenated Uint8Array\n */\nfunction concatBytes(...arrays) {\n let sum = 0;\n for (let i = 0; i < arrays.length; i++) {\n const a = arrays[i];\n if (!isBytes(a))\n throw new Error('Uint8Array expected');\n sum += a.length;\n }\n const res = new Uint8Array(sum);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const a = arrays[i];\n res.set(a, pad);\n pad += a.length;\n }\n return res;\n}\n/**\n * Creates DataView from Uint8Array\n * @param arr - bytes\n * @returns DataView\n */\nconst createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n/**\n * Checks if the provided value is a plain object, not created from any class or special constructor.\n * Array, Uint8Array and others are not plain objects.\n * @param obj - The value to be checked.\n */\nfunction isPlainObject(obj) {\n return Object.prototype.toString.call(obj) === '[object Object]';\n}\nfunction isNum(num) {\n return Number.isSafeInteger(num);\n}\nexport const utils = {\n equalBytes,\n isBytes,\n isCoder,\n checkBounds,\n concatBytes,\n createView,\n isPlainObject,\n};\n// NOTE: we can't have terminator separate function, since it won't know about boundaries\n// E.g. array of U16LE ([1,2,3]) would be [1, 0, 2, 0, 3, 0]\n// But terminator will find array at index '1', which happens to be inside of an element itself\n/**\n * Can be:\n * - Dynamic (CoderType)\n * - Fixed (number)\n * - Terminated (usually zero): Uint8Array with terminator\n * - Field path to field with length (string)\n * - Infinity (null) - decodes until end of buffer\n * Used in:\n * - bytes (string, prefix is implementation of bytes)\n * - array\n */\nconst lengthCoder = (len) => {\n if (len !== null && typeof len !== 'string' && !isCoder(len) && !isBytes(len) && !isNum(len)) {\n throw new Error(`lengthCoder: expected null | number | Uint8Array | CoderType, got ${len} (${typeof len})`);\n }\n return {\n encodeStream(w, value) {\n if (len === null)\n return;\n if (isCoder(len))\n return len.encodeStream(w, value);\n let byteLen;\n if (typeof len === 'number')\n byteLen = len;\n else if (typeof len === 'string')\n byteLen = Path.resolve(w.stack, len);\n if (typeof byteLen === 'bigint')\n byteLen = Number(byteLen);\n if (byteLen === undefined || byteLen !== value)\n throw w.err(`Wrong length: ${byteLen} len=${len} exp=${value} (${typeof value})`);\n },\n decodeStream(r) {\n let byteLen;\n if (isCoder(len))\n byteLen = Number(len.decodeStream(r));\n else if (typeof len === 'number')\n byteLen = len;\n else if (typeof len === 'string')\n byteLen = Path.resolve(r.stack, len);\n if (typeof byteLen === 'bigint')\n byteLen = Number(byteLen);\n if (typeof byteLen !== 'number')\n throw r.err(`Wrong length: ${byteLen}`);\n return byteLen;\n },\n };\n};\n/**\n * Small bitset structure to store position of ranges that have been read.\n * Can be more efficient when internal trees are utilized at the cost of complexity.\n * Needs `O(N/8)` memory for parsing.\n * Purpose: if there are pointers in parsed structure,\n * they can cause read of two distinct ranges:\n * [0-32, 64-128], which means 'pos' is not enough to handle them\n */\nconst Bitset = {\n BITS: 32,\n FULL_MASK: -1 >>> 0, // 1<<32 will overflow\n len: (len) => Math.ceil(len / 32),\n create: (len) => new Uint32Array(Bitset.len(len)),\n clean: (bs) => bs.fill(0),\n debug: (bs) => Array.from(bs).map((i) => (i >>> 0).toString(2).padStart(32, '0')),\n checkLen: (bs, len) => {\n if (Bitset.len(len) === bs.length)\n return;\n throw new Error(`wrong length=${bs.length}. Expected: ${Bitset.len(len)}`);\n },\n chunkLen: (bsLen, pos, len) => {\n if (pos < 0)\n throw new Error(`wrong pos=${pos}`);\n if (pos + len > bsLen)\n throw new Error(`wrong range=${pos}/${len} of ${bsLen}`);\n },\n set: (bs, chunk, value, allowRewrite = true) => {\n if (!allowRewrite && (bs[chunk] & value) !== 0)\n return false;\n bs[chunk] |= value;\n return true;\n },\n pos: (pos, i) => ({\n chunk: Math.floor((pos + i) / 32),\n mask: 1 << (32 - ((pos + i) % 32) - 1),\n }),\n indices: (bs, len, invert = false) => {\n Bitset.checkLen(bs, len);\n const { FULL_MASK, BITS } = Bitset;\n const left = BITS - (len % BITS);\n const lastMask = left ? (FULL_MASK >>> left) << left : FULL_MASK;\n const res = [];\n for (let i = 0; i < bs.length; i++) {\n let c = bs[i];\n if (invert)\n c = ~c; // allows to gen unset elements\n // apply mask to last element, so we won't iterate non-existent items\n if (i === bs.length - 1)\n c &= lastMask;\n if (c === 0)\n continue; // fast-path\n for (let j = 0; j < BITS; j++) {\n const m = 1 << (BITS - j - 1);\n if (c & m)\n res.push(i * BITS + j);\n }\n }\n return res;\n },\n range: (arr) => {\n const res = [];\n let cur;\n for (const i of arr) {\n if (cur === undefined || i !== cur.pos + cur.length)\n res.push((cur = { pos: i, length: 1 }));\n else\n cur.length += 1;\n }\n return res;\n },\n rangeDebug: (bs, len, invert = false) => `[${Bitset.range(Bitset.indices(bs, len, invert))\n .map((i) => `(${i.pos}/${i.length})`)\n .join(', ')}]`,\n setRange: (bs, bsLen, pos, len, allowRewrite = true) => {\n Bitset.chunkLen(bsLen, pos, len);\n const { FULL_MASK, BITS } = Bitset;\n // Try to set range with maximum efficiency:\n // - first chunk is always '0000[1111]' (only right ones)\n // - middle chunks are set to '[1111 1111]' (all ones)\n // - last chunk is always '[1111]0000' (only left ones)\n // - max operations: (N/32) + 2 (first and last)\n const first = pos % BITS ? Math.floor(pos / BITS) : undefined;\n const lastPos = pos + len;\n const last = lastPos % BITS ? Math.floor(lastPos / BITS) : undefined;\n // special case, whole range inside single chunk\n if (first !== undefined && first === last)\n return Bitset.set(bs, first, (FULL_MASK >>> (BITS - len)) << (BITS - len - pos), allowRewrite);\n if (first !== undefined) {\n if (!Bitset.set(bs, first, FULL_MASK >>> pos % BITS, allowRewrite))\n return false; // first chunk\n }\n // middle chunks\n const start = first !== undefined ? first + 1 : pos / BITS;\n const end = last !== undefined ? last : lastPos / BITS;\n for (let i = start; i < end; i++)\n if (!Bitset.set(bs, i, FULL_MASK, allowRewrite))\n return false;\n if (last !== undefined && first !== last)\n if (!Bitset.set(bs, last, FULL_MASK << (BITS - (lastPos % BITS)), allowRewrite))\n return false; // last chunk\n return true;\n },\n};\nconst Path = {\n /**\n * Internal method for handling stack of paths (debug, errors, dynamic fields via path)\n * This is looks ugly (callback), but allows us to force stack cleaning by construction (.pop always after function).\n * Also, this makes impossible:\n * - pushing field when stack is empty\n * - pushing field inside of field (real bug)\n * NOTE: we don't want to do '.pop' on error!\n */\n pushObj: (stack, obj, objFn) => {\n const last = { obj };\n stack.push(last);\n objFn((field, fieldFn) => {\n last.field = field;\n fieldFn();\n last.field = undefined;\n });\n stack.pop();\n },\n path: (stack) => {\n const res = [];\n for (const i of stack)\n if (i.field !== undefined)\n res.push(i.field);\n return res.join('/');\n },\n err: (name, stack, msg) => {\n const err = new Error(`${name}(${Path.path(stack)}): ${typeof msg === 'string' ? msg : msg.message}`);\n if (msg instanceof Error && msg.stack)\n err.stack = msg.stack;\n return err;\n },\n resolve: (stack, path) => {\n const parts = path.split('/');\n const objPath = stack.map((i) => i.obj);\n let i = 0;\n for (; i < parts.length; i++) {\n if (parts[i] === '..')\n objPath.pop();\n else\n break;\n }\n let cur = objPath.pop();\n for (; i < parts.length; i++) {\n if (!cur || cur[parts[i]] === undefined)\n return undefined;\n cur = cur[parts[i]];\n }\n return cur;\n },\n};\n/**\n * Internal structure. Reader class for reading from a byte array.\n * `stack` is internal: for debugger and logging\n * @class Reader\n */\nclass _Reader {\n pos = 0;\n data;\n opts;\n stack;\n parent;\n parentOffset;\n bitBuf = 0;\n bitPos = 0;\n bs; // bitset\n view;\n constructor(data, opts = {}, stack = [], parent = undefined, parentOffset = 0) {\n this.data = data;\n this.opts = opts;\n this.stack = stack;\n this.parent = parent;\n this.parentOffset = parentOffset;\n this.view = createView(data);\n }\n /** Internal method for pointers. */\n _enablePointers() {\n if (this.parent)\n return this.parent._enablePointers();\n if (this.bs)\n return;\n this.bs = Bitset.create(this.data.length);\n Bitset.setRange(this.bs, this.data.length, 0, this.pos, this.opts.allowMultipleReads);\n }\n markBytesBS(pos, len) {\n if (this.parent)\n return this.parent.markBytesBS(this.parentOffset + pos, len);\n if (!len)\n return true;\n if (!this.bs)\n return true;\n return Bitset.setRange(this.bs, this.data.length, pos, len, false);\n }\n markBytes(len) {\n const pos = this.pos;\n this.pos += len;\n const res = this.markBytesBS(pos, len);\n if (!this.opts.allowMultipleReads && !res)\n throw this.err(`multiple read pos=${this.pos} len=${len}`);\n return res;\n }\n pushObj(obj, objFn) {\n return Path.pushObj(this.stack, obj, objFn);\n }\n readView(n, fn) {\n if (!Number.isFinite(n))\n throw this.err(`readView: wrong length=${n}`);\n if (this.pos + n > this.data.length)\n throw this.err('readView: Unexpected end of buffer');\n const res = fn(this.view, this.pos);\n this.markBytes(n);\n return res;\n }\n // read bytes by absolute offset\n absBytes(n) {\n if (n > this.data.length)\n throw new Error('Unexpected end of buffer');\n return this.data.subarray(n);\n }\n finish() {\n if (this.opts.allowUnreadBytes)\n return;\n if (this.bitPos) {\n throw this.err(`${this.bitPos} bits left after unpack: ${baseHex.encode(this.data.slice(this.pos))}`);\n }\n if (this.bs && !this.parent) {\n const notRead = Bitset.indices(this.bs, this.data.length, true);\n if (notRead.length) {\n const formatted = Bitset.range(notRead)\n .map(({ pos, length }) => `(${pos}/${length})[${baseHex.encode(this.data.subarray(pos, pos + length))}]`)\n .join(', ');\n throw this.err(`unread byte ranges: ${formatted} (total=${this.data.length})`);\n }\n else\n return; // all bytes read, everything is ok\n }\n // Default: no pointers enabled\n if (!this.isEnd()) {\n throw this.err(`${this.leftBytes} bytes ${this.bitPos} bits left after unpack: ${baseHex.encode(this.data.slice(this.pos))}`);\n }\n }\n // User methods\n err(msg) {\n return Path.err('Reader', this.stack, msg);\n }\n offsetReader(n) {\n if (n > this.data.length)\n throw this.err('offsetReader: Unexpected end of buffer');\n return new _Reader(this.absBytes(n), this.opts, this.stack, this, n);\n }\n bytes(n, peek = false) {\n if (this.bitPos)\n throw this.err('readBytes: bitPos not empty');\n if (!Number.isFinite(n))\n throw this.err(`readBytes: wrong length=${n}`);\n if (this.pos + n > this.data.length)\n throw this.err('readBytes: Unexpected end of buffer');\n const slice = this.data.subarray(this.pos, this.pos + n);\n if (!peek)\n this.markBytes(n);\n return slice;\n }\n byte(peek = false) {\n if (this.bitPos)\n throw this.err('readByte: bitPos not empty');\n if (this.pos + 1 > this.data.length)\n throw this.err('readBytes: Unexpected end of buffer');\n const data = this.data[this.pos];\n if (!peek)\n this.markBytes(1);\n return data;\n }\n get leftBytes() {\n return this.data.length - this.pos;\n }\n get totalBytes() {\n return this.data.length;\n }\n isEnd() {\n return this.pos >= this.data.length && !this.bitPos;\n }\n // bits are read in BE mode (left to right): (0b1000_0000).readBits(1) == 1\n bits(bits) {\n if (bits > 32)\n throw this.err('BitReader: cannot read more than 32 bits in single call');\n let out = 0;\n while (bits) {\n if (!this.bitPos) {\n this.bitBuf = this.byte();\n this.bitPos = 8;\n }\n const take = Math.min(bits, this.bitPos);\n this.bitPos -= take;\n out = (out << take) | ((this.bitBuf >> this.bitPos) & (2 ** take - 1));\n this.bitBuf &= 2 ** this.bitPos - 1;\n bits -= take;\n }\n // Fix signed integers\n return out >>> 0;\n }\n find(needle, pos = this.pos) {\n if (!isBytes(needle))\n throw this.err(`find: needle is not bytes! ${needle}`);\n if (this.bitPos)\n throw this.err('findByte: bitPos not empty');\n if (!needle.length)\n throw this.err(`find: needle is empty`);\n // indexOf should be faster than full equalBytes check\n for (let idx = pos; (idx = this.data.indexOf(needle[0], idx)) !== -1; idx++) {\n if (idx === -1)\n return;\n const leftBytes = this.data.length - idx;\n if (leftBytes < needle.length)\n return;\n if (equalBytes(needle, this.data.subarray(idx, idx + needle.length)))\n return idx;\n }\n return;\n }\n}\n/**\n * Internal structure. Writer class for writing to a byte array.\n * The `stack` argument of constructor is internal, for debugging and logs.\n * @class Writer\n */\nclass _Writer {\n pos = 0;\n stack;\n // We could have a single buffer here and re-alloc it with\n // x1.5-2 size each time it full, but it will be slower:\n // basic/encode bench: 395ns -> 560ns\n buffers = [];\n ptrs = [];\n bitBuf = 0;\n bitPos = 0;\n viewBuf = new Uint8Array(8);\n view;\n finished = false;\n constructor(stack = []) {\n this.stack = stack;\n this.view = createView(this.viewBuf);\n }\n pushObj(obj, objFn) {\n return Path.pushObj(this.stack, obj, objFn);\n }\n writeView(len, fn) {\n if (this.finished)\n throw this.err('buffer: finished');\n if (!isNum(len) || len > 8)\n throw new Error(`wrong writeView length=${len}`);\n fn(this.view);\n this.bytes(this.viewBuf.slice(0, len));\n this.viewBuf.fill(0);\n }\n // User methods\n err(msg) {\n if (this.finished)\n throw this.err('buffer: finished');\n return Path.err('Reader', this.stack, msg);\n }\n bytes(b) {\n if (this.finished)\n throw this.err('buffer: finished');\n if (this.bitPos)\n throw this.err('writeBytes: ends with non-empty bit buffer');\n this.buffers.push(b);\n this.pos += b.length;\n }\n byte(b) {\n if (this.finished)\n throw this.err('buffer: finished');\n if (this.bitPos)\n throw this.err('writeByte: ends with non-empty bit buffer');\n this.buffers.push(new Uint8Array([b]));\n this.pos++;\n }\n finish(clean = true) {\n if (this.finished)\n throw this.err('buffer: finished');\n if (this.bitPos)\n throw this.err('buffer: ends with non-empty bit buffer');\n // Can't use concatBytes, because it limits amount of arguments (65K).\n const buffers = this.buffers.concat(this.ptrs.map((i) => i.buffer));\n const sum = buffers.map((b) => b.length).reduce((a, b) => a + b, 0);\n const buf = new Uint8Array(sum);\n for (let i = 0, pad = 0; i < buffers.length; i++) {\n const a = buffers[i];\n buf.set(a, pad);\n pad += a.length;\n }\n for (let pos = this.pos, i = 0; i < this.ptrs.length; i++) {\n const ptr = this.ptrs[i];\n buf.set(ptr.ptr.encode(pos), ptr.pos);\n pos += ptr.buffer.length;\n }\n // Cleanup\n if (clean) {\n // We cannot cleanup buffers here, since it can be static user provided buffer.\n // Only '.byte' and '.bits' create buffer which we can safely clean.\n // for (const b of this.buffers) b.fill(0);\n this.buffers = [];\n for (const p of this.ptrs)\n p.buffer.fill(0);\n this.ptrs = [];\n this.finished = true;\n this.bitBuf = 0;\n }\n return buf;\n }\n bits(value, bits) {\n if (bits > 32)\n throw this.err('writeBits: cannot write more than 32 bits in single call');\n if (value >= 2 ** bits)\n throw this.err(`writeBits: value (${value}) >= 2**bits (${bits})`);\n while (bits) {\n const take = Math.min(bits, 8 - this.bitPos);\n this.bitBuf = (this.bitBuf << take) | (value >> (bits - take));\n this.bitPos += take;\n bits -= take;\n value &= 2 ** bits - 1;\n if (this.bitPos === 8) {\n this.bitPos = 0;\n this.buffers.push(new Uint8Array([this.bitBuf]));\n this.pos++;\n }\n }\n }\n}\n// Immutable LE<->BE\nconst swapEndianness = (b) => Uint8Array.from(b).reverse();\n/** Internal function for checking bit bounds of bigint in signed/unsinged form */\nfunction checkBounds(value, bits, signed) {\n if (signed) {\n // [-(2**(32-1)), 2**(32-1)-1]\n const signBit = 2n ** (bits - 1n);\n if (value < -signBit || value >= signBit)\n throw new Error(`value out of signed bounds. Expected ${-signBit} <= ${value} < ${signBit}`);\n }\n else {\n // [0, 2**32-1]\n if (0n > value || value >= 2n ** bits)\n throw new Error(`value out of unsigned bounds. Expected 0 <= ${value} < ${2n ** bits}`);\n }\n}\nfunction _wrap(inner) {\n return {\n // NOTE: we cannot export validate here, since it is likely mistake.\n encodeStream: inner.encodeStream,\n decodeStream: inner.decodeStream,\n size: inner.size,\n encode: (value) => {\n const w = new _Writer();\n inner.encodeStream(w, value);\n return w.finish();\n },\n decode: (data, opts = {}) => {\n const r = new _Reader(data, opts);\n const res = inner.decodeStream(r);\n r.finish();\n return res;\n },\n };\n}\n/**\n * Validates a value before encoding and after decoding using a provided function.\n * @param inner - The inner CoderType.\n * @param fn - The validation function.\n * @returns CoderType which check value with validation function.\n * @example\n * const val = (n: number) => {\n * if (n > 10) throw new Error(`${n} > 10`);\n * return n;\n * };\n *\n * const RangedInt = P.validate(P.U32LE, val); // Will check if value is <= 10 during encoding and decoding\n */\nexport function validate(inner, fn) {\n if (!isCoder(inner))\n throw new Error(`validate: invalid inner value ${inner}`);\n if (typeof fn !== 'function')\n throw new Error('validate: fn should be function');\n return _wrap({\n size: inner.size,\n encodeStream: (w, value) => {\n let res;\n try {\n res = fn(value);\n }\n catch (e) {\n throw w.err(e);\n }\n inner.encodeStream(w, res);\n },\n decodeStream: (r) => {\n const res = inner.decodeStream(r);\n try {\n return fn(res);\n }\n catch (e) {\n throw r.err(e);\n }\n },\n });\n}\n/**\n * Wraps a stream encoder into a generic encoder and optionally validation function\n * @param {inner} inner BytesCoderStream & { validate?: Validate }.\n * @returns The wrapped CoderType.\n * @example\n * const U8 = P.wrap({\n * encodeStream: (w: Writer, value: number) => w.byte(value),\n * decodeStream: (r: Reader): number => r.byte()\n * });\n * const checkedU8 = P.wrap({\n * encodeStream: (w: Writer, value: number) => w.byte(value),\n * decodeStream: (r: Reader): number => r.byte()\n * validate: (n: number) => {\n * if (n > 10) throw new Error(`${n} > 10`);\n * return n;\n * }\n * });\n */\nexport const wrap = (inner) => {\n const res = _wrap(inner);\n return inner.validate ? validate(res, inner.validate) : res;\n};\nconst isBaseCoder = (elm) => isPlainObject(elm) && typeof elm.decode === 'function' && typeof elm.encode === 'function';\n/**\n * Checks if the given value is a CoderType.\n * @param elm - The value to check.\n * @returns True if the value is a CoderType, false otherwise.\n */\nexport function isCoder(elm) {\n return (isPlainObject(elm) &&\n isBaseCoder(elm) &&\n typeof elm.encodeStream === 'function' &&\n typeof elm.decodeStream === 'function' &&\n (elm.size === undefined || isNum(elm.size)));\n}\n// Coders (like in @scure/base) for common operations\n/**\n * Base coder for working with dictionaries (records, objects, key-value map)\n * Dictionary is dynamic type like: `[key: string, value: any][]`\n * @returns base coder that encodes/decodes between arrays of key-value tuples and dictionaries.\n * @example\n * const dict: P.CoderType> = P.apply(\n * P.array(P.U16BE, P.tuple([P.cstring, P.U32LE] as const)),\n * P.coders.dict()\n * );\n */\nfunction dict() {\n return {\n encode: (from) => {\n if (!Array.isArray(from))\n throw new Error('array expected');\n const to = {};\n for (const item of from) {\n if (!Array.isArray(item) || item.length !== 2)\n throw new Error(`array of two elements expected`);\n const name = item[0];\n const value = item[1];\n if (to[name] !== undefined)\n throw new Error(`key(${name}) appears twice in struct`);\n to[name] = value;\n }\n return to;\n },\n decode: (to) => {\n if (!isPlainObject(to))\n throw new Error(`expected plain object, got ${to}`);\n return Object.entries(to);\n },\n };\n}\n/**\n * Safely converts bigint to number.\n * Sometimes pointers / tags use u64 or other big numbers which cannot be represented by number,\n * but we still can use them since real value will be smaller than u32\n */\nconst numberBigint = {\n encode: (from) => {\n if (typeof from !== 'bigint')\n throw new Error(`expected bigint, got ${typeof from}`);\n if (from > BigInt(Number.MAX_SAFE_INTEGER))\n throw new Error(`element bigger than MAX_SAFE_INTEGER=${from}`);\n return Number(from);\n },\n decode: (to) => {\n if (!isNum(to))\n throw new Error('element is not a safe integer');\n return BigInt(to);\n },\n};\n/**\n * Base coder for working with TypeScript enums.\n * @param e - TypeScript enum.\n * @returns base coder that encodes/decodes between numbers and enum keys.\n * @example\n * enum Color { Red, Green, Blue }\n * const colorCoder = P.coders.tsEnum(Color);\n * colorCoder.encode(Color.Red); // 'Red'\n * colorCoder.decode('Green'); // 1\n */\nfunction tsEnum(e) {\n if (!isPlainObject(e))\n throw new Error('plain object expected');\n return {\n encode: (from) => {\n if (!isNum(from) || !(from in e))\n throw new Error(`wrong value ${from}`);\n return e[from];\n },\n decode: (to) => {\n if (typeof to !== 'string')\n throw new Error(`wrong value ${typeof to}`);\n return e[to];\n },\n };\n}\n/**\n * Base coder for working with decimal numbers.\n * @param precision - Number of decimal places.\n * @param round - Round fraction part if bigger than precision (throws error by default)\n * @returns base coder that encodes/decodes between bigints and decimal strings.\n * @example\n * const decimal8 = P.coders.decimal(8);\n * decimal8.encode(630880845n); // '6.30880845'\n * decimal8.decode('6.30880845'); // 630880845n\n */\nfunction decimal(precision, round = false) {\n if (!isNum(precision))\n throw new Error(`decimal/precision: wrong value ${precision}`);\n if (typeof round !== 'boolean')\n throw new Error(`decimal/round: expected boolean, got ${typeof round}`);\n const decimalMask = 10n ** BigInt(precision);\n return {\n encode: (from) => {\n if (typeof from !== 'bigint')\n throw new Error(`expected bigint, got ${typeof from}`);\n let s = (from < 0n ? -from : from).toString(10);\n let sep = s.length - precision;\n if (sep < 0) {\n s = s.padStart(s.length - sep, '0');\n sep = 0;\n }\n let i = s.length - 1;\n for (; i >= sep && s[i] === '0'; i--)\n ;\n let int = s.slice(0, sep);\n let frac = s.slice(sep, i + 1);\n if (!int)\n int = '0';\n if (from < 0n)\n int = '-' + int;\n if (!frac)\n return int;\n return `${int}.${frac}`;\n },\n decode: (to) => {\n if (typeof to !== 'string')\n throw new Error(`expected string, got ${typeof to}`);\n if (to === '-0')\n throw new Error(`negative zero is not allowed`);\n let neg = false;\n if (to.startsWith('-')) {\n neg = true;\n to = to.slice(1);\n }\n if (!/^(0|[1-9]\\d*)(\\.\\d+)?$/.test(to))\n throw new Error(`wrong string value=${to}`);\n let sep = to.indexOf('.');\n sep = sep === -1 ? to.length : sep;\n // split by separator and strip trailing zeros from fraction. always returns [string, string] (.split doesn't).\n const intS = to.slice(0, sep);\n const fracS = to.slice(sep + 1).replace(/0+$/, '');\n const int = BigInt(intS) * decimalMask;\n if (!round && fracS.length > precision) {\n throw new Error(`fractional part cannot be represented with this precision (num=${to}, prec=${precision})`);\n }\n const fracLen = Math.min(fracS.length, precision);\n const frac = BigInt(fracS.slice(0, fracLen)) * 10n ** BigInt(precision - fracLen);\n const value = int + frac;\n return neg ? -value : value;\n },\n };\n}\n/**\n * Combines multiple coders into a single coder, allowing conditional encoding/decoding based on input.\n * Acts as a parser combinator, splitting complex conditional coders into smaller parts.\n *\n * `encode = [Ae, Be]; decode = [Ad, Bd]`\n * ->\n * `match([{encode: Ae, decode: Ad}, {encode: Be; decode: Bd}])`\n *\n * @param lst - Array of coders to match.\n * @returns Combined coder for conditional encoding/decoding.\n */\nfunction match(lst) {\n if (!Array.isArray(lst))\n throw new Error(`expected array, got ${typeof lst}`);\n for (const i of lst)\n if (!isBaseCoder(i))\n throw new Error(`wrong base coder ${i}`);\n return {\n encode: (from) => {\n for (const c of lst) {\n const elm = c.encode(from);\n if (elm !== undefined)\n return elm;\n }\n throw new Error(`match/encode: cannot find match in ${from}`);\n },\n decode: (to) => {\n for (const c of lst) {\n const elm = c.decode(to);\n if (elm !== undefined)\n return elm;\n }\n throw new Error(`match/decode: cannot find match in ${to}`);\n },\n };\n}\n/** Reverses direction of coder */\nconst reverse = (coder) => {\n if (!isBaseCoder(coder))\n throw new Error('BaseCoder expected');\n return { encode: coder.decode, decode: coder.encode };\n};\nexport const coders = { dict, numberBigint, tsEnum, decimal, match, reverse };\n/**\n * CoderType for parsing individual bits.\n * NOTE: Structure should parse whole amount of bytes before it can start parsing byte-level elements.\n * @param len - Number of bits to parse.\n * @returns CoderType representing the parsed bits.\n * @example\n * const s = P.struct({ magic: P.bits(1), version: P.bits(1), tag: P.bits(4), len: P.bits(2) });\n */\nexport const bits = (len) => {\n if (!isNum(len))\n throw new Error(`bits: wrong length ${len} (${typeof len})`);\n return wrap({\n encodeStream: (w, value) => w.bits(value, len),\n decodeStream: (r) => r.bits(len),\n validate: (value) => {\n if (!isNum(value))\n throw new Error(`bits: wrong value ${value}`);\n return value;\n },\n });\n};\n/**\n * CoderType for working with bigint values.\n * Unsized bigint values should be wrapped in a container (e.g., bytes or string).\n *\n * `0n = Uint8Array.of()`\n *\n * `1n = new Uint8Array([1n])`\n *\n * Please open issue, if you need different behavior for zero.\n *\n * @param size - Size of the bigint in bytes.\n * @param le - Whether to use little-endian byte order.\n * @param signed - Whether the bigint is signed.\n * @param sized - Whether the bigint should have a fixed size.\n * @returns CoderType representing the bigint value.\n * @example\n * const U512BE = P.bigint(64, false, true, true); // Define a CoderType for a 512-bit unsigned big-endian integer\n */\nexport const bigint = (size, le = false, signed = false, sized = true) => {\n if (!isNum(size))\n throw new Error(`bigint/size: wrong value ${size}`);\n if (typeof le !== 'boolean')\n throw new Error(`bigint/le: expected boolean, got ${typeof le}`);\n if (typeof signed !== 'boolean')\n throw new Error(`bigint/signed: expected boolean, got ${typeof signed}`);\n if (typeof sized !== 'boolean')\n throw new Error(`bigint/sized: expected boolean, got ${typeof sized}`);\n const bLen = BigInt(size);\n const signBit = 2n ** (8n * bLen - 1n);\n return wrap({\n size: sized ? size : undefined,\n encodeStream: (w, value) => {\n if (signed && value < 0)\n value = value | signBit;\n const b = [];\n for (let i = 0; i < size; i++) {\n b.push(Number(value & 255n));\n value >>= 8n;\n }\n let res = new Uint8Array(b).reverse();\n if (!sized) {\n let pos = 0;\n for (pos = 0; pos < res.length; pos++)\n if (res[pos] !== 0)\n break;\n res = res.subarray(pos); // remove leading zeros\n }\n w.bytes(le ? res.reverse() : res);\n },\n decodeStream: (r) => {\n // TODO: for le we can read until first zero?\n const value = r.bytes(sized ? size : Math.min(size, r.leftBytes));\n const b = le ? value : swapEndianness(value);\n let res = 0n;\n for (let i = 0; i < b.length; i++)\n res |= BigInt(b[i]) << (8n * BigInt(i));\n if (signed && res & signBit)\n res = (res ^ signBit) - signBit;\n return res;\n },\n validate: (value) => {\n if (typeof value !== 'bigint')\n throw new Error(`bigint: invalid value: ${value}`);\n checkBounds(value, 8n * bLen, !!signed);\n return value;\n },\n });\n};\n/** Unsigned 256-bit little-endian integer CoderType. */\nexport const U256LE = /* @__PURE__ */ bigint(32, true);\n/** Unsigned 256-bit big-endian integer CoderType. */\nexport const U256BE = /* @__PURE__ */ bigint(32, false);\n/** Signed 256-bit little-endian integer CoderType. */\nexport const I256LE = /* @__PURE__ */ bigint(32, true, true);\n/** Signed 256-bit big-endian integer CoderType. */\nexport const I256BE = /* @__PURE__ */ bigint(32, false, true);\n/** Unsigned 128-bit little-endian integer CoderType. */\nexport const U128LE = /* @__PURE__ */ bigint(16, true);\n/** Unsigned 128-bit big-endian integer CoderType. */\nexport const U128BE = /* @__PURE__ */ bigint(16, false);\n/** Signed 128-bit little-endian integer CoderType. */\nexport const I128LE = /* @__PURE__ */ bigint(16, true, true);\n/** Signed 128-bit big-endian integer CoderType. */\nexport const I128BE = /* @__PURE__ */ bigint(16, false, true);\n/** Unsigned 64-bit little-endian integer CoderType. */\nexport const U64LE = /* @__PURE__ */ bigint(8, true);\n/** Unsigned 64-bit big-endian integer CoderType. */\nexport const U64BE = /* @__PURE__ */ bigint(8, false);\n/** Signed 64-bit little-endian integer CoderType. */\nexport const I64LE = /* @__PURE__ */ bigint(8, true, true);\n/** Signed 64-bit big-endian integer CoderType. */\nexport const I64BE = /* @__PURE__ */ bigint(8, false, true);\n/**\n * CoderType for working with numbber values (up to 6 bytes/48 bits).\n * Unsized int values should be wrapped in a container (e.g., bytes or string).\n *\n * `0 = Uint8Array.of()`\n *\n * `1 = new Uint8Array([1n])`\n *\n * Please open issue, if you need different behavior for zero.\n *\n * @param size - Size of the number in bytes.\n * @param le - Whether to use little-endian byte order.\n * @param signed - Whether the number is signed.\n * @param sized - Whether the number should have a fixed size.\n * @returns CoderType representing the number value.\n * @example\n * const uint64BE = P.bigint(8, false, true); // Define a CoderType for a 64-bit unsigned big-endian integer\n */\nexport const int = (size, le = false, signed = false, sized = true) => {\n if (!isNum(size))\n throw new Error(`int/size: wrong value ${size}`);\n if (typeof le !== 'boolean')\n throw new Error(`int/le: expected boolean, got ${typeof le}`);\n if (typeof signed !== 'boolean')\n throw new Error(`int/signed: expected boolean, got ${typeof signed}`);\n if (typeof sized !== 'boolean')\n throw new Error(`int/sized: expected boolean, got ${typeof sized}`);\n if (size > 6)\n throw new Error('int supports size up to 6 bytes (48 bits): use bigints instead');\n return apply(bigint(size, le, signed, sized), coders.numberBigint);\n};\nconst view = (len, opts) => wrap({\n size: len,\n encodeStream: (w, value) => w.writeView(len, (view) => opts.write(view, value)),\n decodeStream: (r) => r.readView(len, opts.read),\n validate: (value) => {\n if (typeof value !== 'number')\n throw new Error(`viewCoder: expected number, got ${typeof value}`);\n if (opts.validate)\n opts.validate(value);\n return value;\n },\n});\nconst intView = (len, signed, opts) => {\n const bits = len * 8;\n const signBit = 2 ** (bits - 1);\n // Inlined checkBounds for integer\n const validateSigned = (value) => {\n if (!isNum(value))\n throw new Error(`sintView: value is not safe integer: ${value}`);\n if (value < -signBit || value >= signBit) {\n throw new Error(`sintView: value out of bounds. Expected ${-signBit} <= ${value} < ${signBit}`);\n }\n };\n const maxVal = 2 ** bits;\n const validateUnsigned = (value) => {\n if (!isNum(value))\n throw new Error(`uintView: value is not safe integer: ${value}`);\n if (0 > value || value >= maxVal) {\n throw new Error(`uintView: value out of bounds. Expected 0 <= ${value} < ${maxVal}`);\n }\n };\n return view(len, {\n write: opts.write,\n read: opts.read,\n validate: signed ? validateSigned : validateUnsigned,\n });\n};\n/** Unsigned 32-bit little-endian integer CoderType. */\nexport const U32LE = /* @__PURE__ */ intView(4, false, {\n read: (view, pos) => view.getUint32(pos, true),\n write: (view, value) => view.setUint32(0, value, true),\n});\n/** Unsigned 32-bit big-endian integer CoderType. */\nexport const U32BE = /* @__PURE__ */ intView(4, false, {\n read: (view, pos) => view.getUint32(pos, false),\n write: (view, value) => view.setUint32(0, value, false),\n});\n/** Signed 32-bit little-endian integer CoderType. */\nexport const I32LE = /* @__PURE__ */ intView(4, true, {\n read: (view, pos) => view.getInt32(pos, true),\n write: (view, value) => view.setInt32(0, value, true),\n});\n/** Signed 32-bit big-endian integer CoderType. */\nexport const I32BE = /* @__PURE__ */ intView(4, true, {\n read: (view, pos) => view.getInt32(pos, false),\n write: (view, value) => view.setInt32(0, value, false),\n});\n/** Unsigned 16-bit little-endian integer CoderType. */\nexport const U16LE = /* @__PURE__ */ intView(2, false, {\n read: (view, pos) => view.getUint16(pos, true),\n write: (view, value) => view.setUint16(0, value, true),\n});\n/** Unsigned 16-bit big-endian integer CoderType. */\nexport const U16BE = /* @__PURE__ */ intView(2, false, {\n read: (view, pos) => view.getUint16(pos, false),\n write: (view, value) => view.setUint16(0, value, false),\n});\n/** Signed 16-bit little-endian integer CoderType. */\nexport const I16LE = /* @__PURE__ */ intView(2, true, {\n read: (view, pos) => view.getInt16(pos, true),\n write: (view, value) => view.setInt16(0, value, true),\n});\n/** Signed 16-bit big-endian integer CoderType. */\nexport const I16BE = /* @__PURE__ */ intView(2, true, {\n read: (view, pos) => view.getInt16(pos, false),\n write: (view, value) => view.setInt16(0, value, false),\n});\n/** Unsigned 8-bit integer CoderType. */\nexport const U8 = /* @__PURE__ */ intView(1, false, {\n read: (view, pos) => view.getUint8(pos),\n write: (view, value) => view.setUint8(0, value),\n});\n/** Signed 8-bit integer CoderType. */\nexport const I8 = /* @__PURE__ */ intView(1, true, {\n read: (view, pos) => view.getInt8(pos),\n write: (view, value) => view.setInt8(0, value),\n});\n// Floats\nconst f32 = (le) => view(4, {\n read: (view, pos) => view.getFloat32(pos, le),\n write: (view, value) => view.setFloat32(0, value, le),\n validate: (value) => {\n if (Math.fround(value) !== value && !Number.isNaN(value))\n throw new Error(`f32: wrong value=${value}`);\n },\n});\nconst f64 = (le) => view(8, {\n read: (view, pos) => view.getFloat64(pos, le),\n write: (view, value) => view.setFloat64(0, value, le),\n});\n/** 32-bit big-endian floating point CoderType (\"binary32\", IEEE 754-2008). */\nexport const F32BE = /* @__PURE__ */ f32(false);\n/** 32-bit little-endian floating point CoderType (\"binary32\", IEEE 754-2008). */\nexport const F32LE = /* @__PURE__ */ f32(true);\n/** A 64-bit big-endian floating point type (\"binary64\", IEEE 754-2008). Any JS number can be encoded. */\nexport const F64BE = /* @__PURE__ */ f64(false);\n/** A 64-bit little-endian floating point type (\"binary64\", IEEE 754-2008). Any JS number can be encoded. */\nexport const F64LE = /* @__PURE__ */ f64(true);\n/** Boolean CoderType. */\nexport const bool = /* @__PURE__ */ wrap({\n size: 1,\n encodeStream: (w, value) => w.byte(value ? 1 : 0),\n decodeStream: (r) => {\n const value = r.byte();\n if (value !== 0 && value !== 1)\n throw r.err(`bool: invalid value ${value}`);\n return value === 1;\n },\n validate: (value) => {\n if (typeof value !== 'boolean')\n throw new Error(`bool: invalid value ${value}`);\n return value;\n },\n});\n/**\n * Bytes CoderType with a specified length and endianness.\n * The bytes can have:\n * - Dynamic size (prefixed with a length CoderType like U16BE)\n * - Fixed size (specified by a number)\n * - Unknown size (null, will parse until end of buffer)\n * - Zero-terminated (terminator can be any Uint8Array)\n * @param len - CoderType, number, Uint8Array (terminator) or null\n * @param le - Whether to use little-endian byte order.\n * @returns CoderType representing the bytes.\n * @example\n * // Dynamic size bytes (prefixed with P.U16BE number of bytes length)\n * const dynamicBytes = P.bytes(P.U16BE, false);\n * const fixedBytes = P.bytes(32, false); // Fixed size bytes\n * const unknownBytes = P.bytes(null, false); // Unknown size bytes, will parse until end of buffer\n * const zeroTerminatedBytes = P.bytes(Uint8Array.of(0), false); // Zero-terminated bytes\n */\nconst createBytes = (len, le = false) => {\n if (typeof le !== 'boolean')\n throw new Error(`bytes/le: expected boolean, got ${typeof le}`);\n const _length = lengthCoder(len);\n const _isb = isBytes(len);\n return wrap({\n size: typeof len === 'number' ? len : undefined,\n encodeStream: (w, value) => {\n if (!_isb)\n _length.encodeStream(w, value.length);\n w.bytes(le ? swapEndianness(value) : value);\n if (_isb)\n w.bytes(len);\n },\n decodeStream: (r) => {\n let bytes;\n if (_isb) {\n const tPos = r.find(len);\n if (!tPos)\n throw r.err(`bytes: cannot find terminator`);\n bytes = r.bytes(tPos - r.pos);\n r.bytes(len.length);\n }\n else {\n bytes = r.bytes(len === null ? r.leftBytes : _length.decodeStream(r));\n }\n return le ? swapEndianness(bytes) : bytes;\n },\n validate: (value) => {\n if (!isBytes(value))\n throw new Error(`bytes: invalid value ${value}`);\n return value;\n },\n });\n};\nexport { createBytes as bytes, createHex as hex };\n/**\n * Prefix-encoded value using a length prefix and an inner CoderType.\n * The prefix can have:\n * - Dynamic size (prefixed with a length CoderType like U16BE)\n * - Fixed size (specified by a number)\n * - Unknown size (null, will parse until end of buffer)\n * - Zero-terminated (terminator can be any Uint8Array)\n * @param len - Length CoderType (dynamic size), number (fixed size), Uint8Array (for terminator), or null (will parse until end of buffer)\n * @param inner - CoderType for the actual value to be prefix-encoded.\n * @returns CoderType representing the prefix-encoded value.\n * @example\n * const dynamicPrefix = P.prefix(P.U16BE, P.bytes(null)); // Dynamic size prefix (prefixed with P.U16BE number of bytes length)\n * const fixedPrefix = P.prefix(10, P.bytes(null)); // Fixed size prefix (always 10 bytes)\n */\nexport function prefix(len, inner) {\n if (!isCoder(inner))\n throw new Error(`prefix: invalid inner value ${inner}`);\n return apply(createBytes(len), reverse(inner));\n}\n/**\n * String CoderType with a specified length and endianness.\n * The string can be:\n * - Dynamic size (prefixed with a length CoderType like U16BE)\n * - Fixed size (specified by a number)\n * - Unknown size (null, will parse until end of buffer)\n * - Zero-terminated (terminator can be any Uint8Array)\n * @param len - Length CoderType (dynamic size), number (fixed size), Uint8Array (for terminator), or null (will parse until end of buffer)\n * @param le - Whether to use little-endian byte order.\n * @returns CoderType representing the string.\n * @example\n * const dynamicString = P.string(P.U16BE, false); // Dynamic size string (prefixed with P.U16BE number of string length)\n * const fixedString = P.string(10, false); // Fixed size string\n * const unknownString = P.string(null, false); // Unknown size string, will parse until end of buffer\n * const nullTerminatedString = P.cstring; // NUL-terminated string\n * const _cstring = P.string(Uint8Array.of(0)); // Same thing\n */\nexport const string = (len, le = false) => validate(apply(createBytes(len, le), utf8), (value) => {\n // TextEncoder/TextDecoder will fail on non-string, but we create more readable errors earlier\n if (typeof value !== 'string')\n throw new Error(`expected string, got ${typeof value}`);\n return value;\n});\n/** NUL-terminated string CoderType. */\nexport const cstring = /* @__PURE__ */ string(NULL);\n/**\n * Hexadecimal string CoderType with a specified length, endianness, and optional 0x prefix.\n * @param len - Length CoderType (dynamic size), number (fixed size), Uint8Array (for terminator), or null (will parse until end of buffer)\n * @param le - Whether to use little-endian byte order.\n * @param withZero - Whether to include the 0x prefix.\n * @returns CoderType representing the hexadecimal string.\n * @example\n * const dynamicHex = P.hex(P.U16BE, {isLE: false, with0x: true}); // Hex string with 0x prefix and U16BE length\n * const fixedHex = P.hex(32, {isLE: false, with0x: false}); // Fixed-length 32-byte hex string without 0x prefix\n */\nconst createHex = (len, options = { isLE: false, with0x: false }) => {\n let inner = apply(createBytes(len, options.isLE), baseHex);\n const prefix = options.with0x;\n if (typeof prefix !== 'boolean')\n throw new Error(`hex/with0x: expected boolean, got ${typeof prefix}`);\n if (prefix) {\n inner = apply(inner, {\n encode: (value) => `0x${value}`,\n decode: (value) => {\n if (!value.startsWith('0x'))\n throw new Error('hex(with0x=true).encode input should start with 0x');\n return value.slice(2);\n },\n });\n }\n return inner;\n};\n/**\n * Applies a base coder to a CoderType.\n * @param inner - The inner CoderType.\n * @param b - The base coder to apply.\n * @returns CoderType representing the transformed value.\n * @example\n * import { hex } from '@scure/base';\n * const hex = P.apply(P.bytes(32), hex); // will decode bytes into a hex string\n */\nexport function apply(inner, base) {\n if (!isCoder(inner))\n throw new Error(`apply: invalid inner value ${inner}`);\n if (!isBaseCoder(base))\n throw new Error(`apply: invalid base value ${inner}`);\n return wrap({\n size: inner.size,\n encodeStream: (w, value) => {\n let innerValue;\n try {\n innerValue = base.decode(value);\n }\n catch (e) {\n throw w.err('' + e);\n }\n return inner.encodeStream(w, innerValue);\n },\n decodeStream: (r) => {\n const innerValue = inner.decodeStream(r);\n try {\n return base.encode(innerValue);\n }\n catch (e) {\n throw r.err('' + e);\n }\n },\n });\n}\n/**\n * Lazy CoderType that is evaluated at runtime.\n * @param fn - A function that returns the CoderType.\n * @returns CoderType representing the lazy value.\n * @example\n * type Tree = { name: string; children: Tree[] };\n * const tree = P.struct({\n * name: P.cstring,\n * children: P.array(\n * P.U16BE,\n * P.lazy((): P.CoderType => tree)\n * ),\n * });\n */\nexport function lazy(fn) {\n if (typeof fn !== 'function')\n throw new Error(`lazy: expected function, got ${typeof fn}`);\n return wrap({\n encodeStream: (w, value) => fn().encodeStream(w, value),\n decodeStream: (r) => fn().decodeStream(r),\n });\n}\n/**\n * Flag CoderType that encodes/decodes a boolean value based on the presence of a marker.\n * @param flagValue - Marker value.\n * @param xor - Whether to invert the flag behavior.\n * @returns CoderType representing the flag value.\n * @example\n * const flag = P.flag(new Uint8Array([0x01, 0x02])); // Encodes true as u8a([0x01, 0x02]), false as u8a([])\n * const flagXor = P.flag(new Uint8Array([0x01, 0x02]), true); // Encodes true as u8a([]), false as u8a([0x01, 0x02])\n * // Conditional encoding with flagged\n * const s = P.struct({ f: P.flag(new Uint8Array([0x0, 0x1])), f2: P.flagged('f', P.U32BE) });\n */\nexport const flag = (flagValue, xor = false) => {\n if (!isBytes(flagValue))\n throw new Error(`flag/flagValue: expected Uint8Array, got ${typeof flagValue}`);\n if (typeof xor !== 'boolean')\n throw new Error(`flag/xor: expected boolean, got ${typeof xor}`);\n return wrap({\n size: flagValue.length,\n encodeStream: (w, value) => {\n if (!!value !== xor)\n w.bytes(flagValue);\n },\n decodeStream: (r) => {\n let hasFlag = r.leftBytes >= flagValue.length;\n if (hasFlag) {\n hasFlag = equalBytes(r.bytes(flagValue.length, true), flagValue);\n // Found flag, advance cursor position\n if (hasFlag)\n r.bytes(flagValue.length);\n }\n return hasFlag !== xor; // hasFlag ^ xor\n },\n validate: (value) => {\n if (value !== undefined && typeof value !== 'boolean')\n throw new Error(`flag: expected boolean value or undefined, got ${typeof value}`);\n return value;\n },\n });\n};\n/**\n * Conditional CoderType that encodes/decodes a value only if a flag is present.\n * @param path - Path to the flag value or a CoderType for the flag.\n * @param inner - Inner CoderType for the value.\n * @param def - Optional default value to use if the flag is not present.\n * @returns CoderType representing the conditional value.\n * @example\n * const s = P.struct({\n * f: P.flag(new Uint8Array([0x0, 0x1])),\n * f2: P.flagged('f', P.U32BE)\n * });\n *\n * @example\n * const s2 = P.struct({\n * f: P.flag(new Uint8Array([0x0, 0x1])),\n * f2: P.flagged('f', P.U32BE, 123)\n * });\n */\nexport function flagged(path, inner, def) {\n if (!isCoder(inner))\n throw new Error(`flagged: invalid inner value ${inner}`);\n if (typeof path !== 'string' && !isCoder(inner))\n throw new Error(`flagged: wrong path=${path}`);\n return wrap({\n encodeStream: (w, value) => {\n if (typeof path === 'string') {\n if (Path.resolve(w.stack, path))\n inner.encodeStream(w, value);\n else if (def)\n inner.encodeStream(w, def);\n }\n else {\n path.encodeStream(w, !!value);\n if (!!value)\n inner.encodeStream(w, value);\n else if (def)\n inner.encodeStream(w, def);\n }\n },\n decodeStream: (r) => {\n let hasFlag = false;\n if (typeof path === 'string')\n hasFlag = !!Path.resolve(r.stack, path);\n else\n hasFlag = path.decodeStream(r);\n // If there is a flag -- decode and return value\n if (hasFlag)\n return inner.decodeStream(r);\n else if (def)\n inner.decodeStream(r);\n return;\n },\n });\n}\n/**\n * Optional CoderType that encodes/decodes a value based on a flag.\n * @param flag - CoderType for the flag value.\n * @param inner - Inner CoderType for the value.\n * @param def - Optional default value to use if the flag is not present.\n * @returns CoderType representing the optional value.\n * @example\n * // Will decode into P.U32BE only if flag present\n * const optional = P.optional(P.flag(new Uint8Array([0x0, 0x1])), P.U32BE);\n *\n * @example\n * // If no flag present, will decode into default value\n * const optionalWithDefault = P.optional(P.flag(new Uint8Array([0x0, 0x1])), P.U32BE, 123);\n */\nexport function optional(flag, inner, def) {\n if (!isCoder(flag) || !isCoder(inner))\n throw new Error(`optional: invalid flag or inner value flag=${flag} inner=${inner}`);\n return wrap({\n size: def !== undefined && flag.size && inner.size ? flag.size + inner.size : undefined,\n encodeStream: (w, value) => {\n flag.encodeStream(w, !!value);\n if (value)\n inner.encodeStream(w, value);\n else if (def !== undefined)\n inner.encodeStream(w, def);\n },\n decodeStream: (r) => {\n if (flag.decodeStream(r))\n return inner.decodeStream(r);\n else if (def !== undefined)\n inner.decodeStream(r);\n return;\n },\n });\n}\n/**\n * Magic value CoderType that encodes/decodes a constant value.\n * This can be used to check for a specific magic value or sequence of bytes at the beginning of a data structure.\n * @param inner - Inner CoderType for the value.\n * @param constant - Constant value.\n * @param check - Whether to check the decoded value against the constant.\n * @returns CoderType representing the magic value.\n * @example\n * // Always encodes constant as bytes using inner CoderType, throws if encoded value is not present\n * const magicU8 = P.magic(P.U8, 0x42);\n */\nexport function magic(inner, constant, check = true) {\n if (!isCoder(inner))\n throw new Error(`magic: invalid inner value ${inner}`);\n if (typeof check !== 'boolean')\n throw new Error(`magic: expected boolean, got ${typeof check}`);\n return wrap({\n size: inner.size,\n encodeStream: (w, _value) => inner.encodeStream(w, constant),\n decodeStream: (r) => {\n const value = inner.decodeStream(r);\n if ((check && typeof value !== 'object' && value !== constant) ||\n (isBytes(constant) && !equalBytes(constant, value))) {\n throw r.err(`magic: invalid value: ${value} !== ${constant}`);\n }\n return;\n },\n validate: (value) => {\n if (value !== undefined)\n throw new Error(`magic: wrong value=${typeof value}`);\n return value;\n },\n });\n}\n/**\n * Magic bytes CoderType that encodes/decodes a constant byte array or string.\n * @param constant - Constant byte array or string.\n * @returns CoderType representing the magic bytes.\n * @example\n * // Always encodes undefined into byte representation of string 'MAGIC'\n * const magicBytes = P.magicBytes('MAGIC');\n */\nexport const magicBytes = (constant) => {\n const c = typeof constant === 'string' ? utf8.decode(constant) : constant;\n return magic(createBytes(c.length), c);\n};\n/**\n * Creates a CoderType for a constant value. The function enforces this value during encoding,\n * ensuring it matches the provided constant. During decoding, it always returns the constant value.\n * The actual value is not written to or read from any byte stream; it's used only for validation.\n *\n * @param c - Constant value.\n * @returns CoderType representing the constant value.\n * @example\n * // Always return 123 on decode, throws on encoding anything other than 123\n * const constantU8 = P.constant(123);\n */\nexport function constant(c) {\n return wrap({\n encodeStream: (_w, value) => {\n if (value !== c)\n throw new Error(`constant: invalid value ${value} (exp: ${c})`);\n },\n decodeStream: (_r) => c,\n });\n}\nfunction sizeof(fields) {\n let size = 0;\n for (const f of fields) {\n if (f.size === undefined)\n return;\n if (!isNum(f.size))\n throw new Error(`sizeof: wrong element size=${size}`);\n size += f.size;\n }\n return size;\n}\n/**\n * Structure of composable primitives (C/Rust struct)\n * @param fields - Object mapping field names to CoderTypes.\n * @returns CoderType representing the structure.\n * @example\n * // Define a structure with a 32-bit big-endian unsigned integer, a string, and a nested structure\n * const myStruct = P.struct({\n * id: P.U32BE,\n * name: P.string(P.U8),\n * nested: P.struct({\n * flag: P.bool,\n * value: P.I16LE\n * })\n * });\n */\nexport function struct(fields) {\n if (!isPlainObject(fields))\n throw new Error(`struct: expected plain object, got ${fields}`);\n for (const name in fields) {\n if (!isCoder(fields[name]))\n throw new Error(`struct: field ${name} is not CoderType`);\n }\n return wrap({\n size: sizeof(Object.values(fields)),\n encodeStream: (w, value) => {\n w.pushObj(value, (fieldFn) => {\n for (const name in fields)\n fieldFn(name, () => fields[name].encodeStream(w, value[name]));\n });\n },\n decodeStream: (r) => {\n const res = {};\n r.pushObj(res, (fieldFn) => {\n for (const name in fields)\n fieldFn(name, () => (res[name] = fields[name].decodeStream(r)));\n });\n return res;\n },\n validate: (value) => {\n if (typeof value !== 'object' || value === null)\n throw new Error(`struct: invalid value ${value}`);\n return value;\n },\n });\n}\n/**\n * Tuple (unnamed structure) of CoderTypes. Same as struct but with unnamed fields.\n * @param fields - Array of CoderTypes.\n * @returns CoderType representing the tuple.\n * @example\n * const myTuple = P.tuple([P.U8, P.U16LE, P.string(P.U8)]);\n */\nexport function tuple(fields) {\n if (!Array.isArray(fields))\n throw new Error(`Packed.Tuple: got ${typeof fields} instead of array`);\n for (let i = 0; i < fields.length; i++) {\n if (!isCoder(fields[i]))\n throw new Error(`tuple: field ${i} is not CoderType`);\n }\n return wrap({\n size: sizeof(fields),\n encodeStream: (w, value) => {\n // TODO: fix types\n if (!Array.isArray(value))\n throw w.err(`tuple: invalid value ${value}`);\n w.pushObj(value, (fieldFn) => {\n for (let i = 0; i < fields.length; i++)\n fieldFn(`${i}`, () => fields[i].encodeStream(w, value[i]));\n });\n },\n decodeStream: (r) => {\n const res = [];\n r.pushObj(res, (fieldFn) => {\n for (let i = 0; i < fields.length; i++)\n fieldFn(`${i}`, () => res.push(fields[i].decodeStream(r)));\n });\n return res;\n },\n validate: (value) => {\n if (!Array.isArray(value))\n throw new Error(`tuple: invalid value ${value}`);\n if (value.length !== fields.length)\n throw new Error(`tuple: wrong length=${value.length}, expected ${fields.length}`);\n return value;\n },\n });\n}\n/**\n * Array of items (inner type) with a specified length.\n * @param len - Length CoderType (dynamic size), number (fixed size), Uint8Array (for terminator), or null (will parse until end of buffer)\n * @param inner - CoderType for encoding/decoding each array item.\n * @returns CoderType representing the array.\n * @example\n * const a1 = P.array(P.U16BE, child); // Dynamic size array (prefixed with P.U16BE number of array length)\n * const a2 = P.array(4, child); // Fixed size array\n * const a3 = P.array(null, child); // Unknown size array, will parse until end of buffer\n * const a4 = P.array(Uint8Array.of(0), child); // zero-terminated array (NOTE: terminator can be any buffer)\n */\nexport function array(len, inner) {\n if (!isCoder(inner))\n throw new Error(`array: invalid inner value ${inner}`);\n // By construction length is inside array (otherwise there will be various incorrect stack states)\n // But forcing users always write '..' seems like bad idea. Also, breaking change.\n const _length = lengthCoder(typeof len === 'string' ? `../${len}` : len);\n return wrap({\n size: typeof len === 'number' && inner.size ? len * inner.size : undefined,\n encodeStream: (w, value) => {\n const _w = w;\n _w.pushObj(value, (fieldFn) => {\n if (!isBytes(len))\n _length.encodeStream(w, value.length);\n for (let i = 0; i < value.length; i++) {\n fieldFn(`${i}`, () => {\n const elm = value[i];\n const startPos = w.pos;\n inner.encodeStream(w, elm);\n if (isBytes(len)) {\n // Terminator is bigger than elm size, so skip\n if (len.length > _w.pos - startPos)\n return;\n const data = _w.finish(false).subarray(startPos, _w.pos);\n // There is still possible case when multiple elements create terminator,\n // but it is hard to catch here, will be very slow\n if (equalBytes(data.subarray(0, len.length), len))\n throw _w.err(`array: inner element encoding same as separator. elm=${elm} data=${data}`);\n }\n });\n }\n });\n if (isBytes(len))\n w.bytes(len);\n },\n decodeStream: (r) => {\n const res = [];\n r.pushObj(res, (fieldFn) => {\n if (len === null) {\n for (let i = 0; !r.isEnd(); i++) {\n fieldFn(`${i}`, () => res.push(inner.decodeStream(r)));\n if (inner.size && r.leftBytes < inner.size)\n break;\n }\n }\n else if (isBytes(len)) {\n for (let i = 0;; i++) {\n if (equalBytes(r.bytes(len.length, true), len)) {\n // Advance cursor position if terminator found\n r.bytes(len.length);\n break;\n }\n fieldFn(`${i}`, () => res.push(inner.decodeStream(r)));\n }\n }\n else {\n let length;\n fieldFn('arrayLen', () => (length = _length.decodeStream(r)));\n for (let i = 0; i < length; i++)\n fieldFn(`${i}`, () => res.push(inner.decodeStream(r)));\n }\n });\n return res;\n },\n validate: (value) => {\n if (!Array.isArray(value))\n throw new Error(`array: invalid value ${value}`);\n return value;\n },\n });\n}\n/**\n * Mapping between encoded values and string representations.\n * @param inner - CoderType for encoded values.\n * @param variants - Object mapping string representations to encoded values.\n * @returns CoderType representing the mapping.\n * @example\n * // Map between numbers and strings\n * const numberMap = P.map(P.U8, {\n * 'one': 1,\n * 'two': 2,\n * 'three': 3\n * });\n *\n * // Map between byte arrays and strings\n * const byteMap = P.map(P.bytes(2, false), {\n * 'ab': Uint8Array.from([0x61, 0x62]),\n * 'cd': Uint8Array.from([0x63, 0x64])\n * });\n */\nexport function map(inner, variants) {\n if (!isCoder(inner))\n throw new Error(`map: invalid inner value ${inner}`);\n if (!isPlainObject(variants))\n throw new Error(`map: variants should be plain object`);\n const variantNames = new Map();\n for (const k in variants)\n variantNames.set(variants[k], k);\n return wrap({\n size: inner.size,\n encodeStream: (w, value) => inner.encodeStream(w, variants[value]),\n decodeStream: (r) => {\n const variant = inner.decodeStream(r);\n const name = variantNames.get(variant);\n if (name === undefined)\n throw r.err(`Enum: unknown value: ${variant} ${Array.from(variantNames.keys())}`);\n return name;\n },\n validate: (value) => {\n if (typeof value !== 'string')\n throw new Error(`map: invalid value ${value}`);\n if (!(value in variants))\n throw new Error(`Map: unknown variant: ${value}`);\n return value;\n },\n });\n}\n/**\n * Tagged union of CoderTypes, where the tag value determines which CoderType to use.\n * The decoded value will have the structure `{ TAG: number, data: ... }`.\n * @param tag - CoderType for the tag value.\n * @param variants - Object mapping tag values to CoderTypes.\n * @returns CoderType representing the tagged union.\n * @example\n * // Tagged union of array, string, and number\n * // Depending on the value of the first byte, it will be decoded as an array, string, or number.\n * const taggedUnion = P.tag(P.U8, {\n * 0x01: P.array(P.U16LE, P.U8),\n * 0x02: P.string(P.U8),\n * 0x03: P.U32BE\n * });\n *\n * const encoded = taggedUnion.encode({ TAG: 0x01, data: 'hello' }); // Encodes the string 'hello' with tag 0x01\n * const decoded = taggedUnion.decode(encoded); // Decodes the encoded value back to { TAG: 0x01, data: 'hello' }\n */\nexport function tag(tag, variants) {\n if (!isCoder(tag))\n throw new Error(`tag: invalid tag value ${tag}`);\n if (!isPlainObject(variants))\n throw new Error(`tag: variants should be plain object`);\n for (const name in variants) {\n if (!isCoder(variants[name]))\n throw new Error(`tag: variant ${name} is not CoderType`);\n }\n return wrap({\n size: tag.size,\n encodeStream: (w, value) => {\n const { TAG, data } = value;\n const dataType = variants[TAG];\n tag.encodeStream(w, TAG);\n dataType.encodeStream(w, data);\n },\n decodeStream: (r) => {\n const TAG = tag.decodeStream(r);\n const dataType = variants[TAG];\n if (!dataType)\n throw r.err(`Tag: invalid tag ${TAG}`);\n return { TAG, data: dataType.decodeStream(r) };\n },\n validate: (value) => {\n const { TAG } = value;\n const dataType = variants[TAG];\n if (!dataType)\n throw new Error(`Tag: invalid tag ${TAG.toString()}`);\n return value;\n },\n });\n}\n/**\n * Mapping between encoded values, string representations, and CoderTypes using a tag CoderType.\n * @param tagCoder - CoderType for the tag value.\n * @param variants - Object mapping string representations to [tag value, CoderType] pairs.\n * * @returns CoderType representing the mapping.\n * @example\n * const cborValue: P.CoderType = P.mappedTag(P.bits(3), {\n * uint: [0, cborUint], // An unsigned integer in the range 0..264-1 inclusive.\n * negint: [1, cborNegint], // A negative integer in the range -264..-1 inclusive\n * bytes: [2, P.lazy(() => cborLength(P.bytes, cborValue))], // A byte string.\n * string: [3, P.lazy(() => cborLength(P.string, cborValue))], // A text string (utf8)\n * array: [4, cborArrLength(P.lazy(() => cborValue))], // An array of data items\n * map: [5, P.lazy(() => cborArrLength(P.tuple([cborValue, cborValue])))], // A map of pairs of data items\n * tag: [6, P.tuple([cborUint, P.lazy(() => cborValue)] as const)], // A tagged data item (\"tag\") whose tag number\n * simple: [7, cborSimple], // Floating-point numbers and simple values, as well as the \"break\" stop code\n * });\n */\nexport function mappedTag(tagCoder, variants) {\n if (!isCoder(tagCoder))\n throw new Error(`mappedTag: invalid tag value ${tag}`);\n if (!isPlainObject(variants))\n throw new Error(`mappedTag: variants should be plain object`);\n const mapValue = {};\n const tagValue = {};\n for (const key in variants) {\n const v = variants[key];\n mapValue[key] = v[0];\n tagValue[key] = v[1];\n }\n return tag(map(tagCoder, mapValue), tagValue);\n}\n/**\n * Bitset of boolean values with optional padding.\n * @param names - An array of string names for the bitset values.\n * @param pad - Whether to pad the bitset to a multiple of 8 bits.\n * @returns CoderType representing the bitset.\n * @template Names\n * @example\n * const myBitset = P.bitset(['flag1', 'flag2', 'flag3', 'flag4'], true);\n */\nexport function bitset(names, pad = false) {\n if (typeof pad !== 'boolean')\n throw new Error(`bitset/pad: expected boolean, got ${typeof pad}`);\n if (!Array.isArray(names))\n throw new Error('bitset/names: expected array');\n for (const name of names) {\n if (typeof name !== 'string')\n throw new Error('bitset/names: expected array of strings');\n }\n return wrap({\n encodeStream: (w, value) => {\n for (let i = 0; i < names.length; i++)\n w.bits(+value[names[i]], 1);\n if (pad && names.length % 8)\n w.bits(0, 8 - (names.length % 8));\n },\n decodeStream: (r) => {\n const out = {};\n for (let i = 0; i < names.length; i++)\n out[names[i]] = !!r.bits(1);\n if (pad && names.length % 8)\n r.bits(8 - (names.length % 8));\n return out;\n },\n validate: (value) => {\n if (!isPlainObject(value))\n throw new Error(`bitset: invalid value ${value}`);\n for (const v of Object.values(value)) {\n if (typeof v !== 'boolean')\n throw new Error('expected boolean');\n }\n return value;\n },\n });\n}\n/** Padding function which always returns zero */\nexport const ZeroPad = (_) => 0;\nfunction padLength(blockSize, len) {\n if (len % blockSize === 0)\n return 0;\n return blockSize - (len % blockSize);\n}\n/**\n * Pads a CoderType with a specified block size and padding function on the left side.\n * @param blockSize - Block size for padding (positive safe integer).\n * @param inner - Inner CoderType to pad.\n * @param padFn - Padding function to use. If not provided, zero padding is used.\n * @returns CoderType representing the padded value.\n * @example\n * // Pad a U32BE with a block size of 4 and zero padding\n * const paddedU32BE = P.padLeft(4, P.U32BE);\n *\n * // Pad a string with a block size of 16 and custom padding\n * const paddedString = P.padLeft(16, P.string(P.U8), (i) => i + 1);\n */\nexport function padLeft(blockSize, inner, padFn) {\n if (!isNum(blockSize) || blockSize <= 0)\n throw new Error(`padLeft: wrong blockSize=${blockSize}`);\n if (!isCoder(inner))\n throw new Error(`padLeft: invalid inner value ${inner}`);\n if (padFn !== undefined && typeof padFn !== 'function')\n throw new Error(`padLeft: wrong padFn=${typeof padFn}`);\n const _padFn = padFn || ZeroPad;\n if (!inner.size)\n throw new Error('padLeft cannot have dynamic size');\n return wrap({\n size: inner.size + padLength(blockSize, inner.size),\n encodeStream: (w, value) => {\n const padBytes = padLength(blockSize, inner.size);\n for (let i = 0; i < padBytes; i++)\n w.byte(_padFn(i));\n inner.encodeStream(w, value);\n },\n decodeStream: (r) => {\n r.bytes(padLength(blockSize, inner.size));\n return inner.decodeStream(r);\n },\n });\n}\n/**\n * Pads a CoderType with a specified block size and padding function on the right side.\n * @param blockSize - Block size for padding (positive safe integer).\n * @param inner - Inner CoderType to pad.\n * @param padFn - Padding function to use. If not provided, zero padding is used.\n * @returns CoderType representing the padded value.\n * @example\n * // Pad a U16BE with a block size of 2 and zero padding\n * const paddedU16BE = P.padRight(2, P.U16BE);\n *\n * // Pad a bytes with a block size of 8 and custom padding\n * const paddedBytes = P.padRight(8, P.bytes(null), (i) => i + 1);\n */\nexport function padRight(blockSize, inner, padFn) {\n if (!isCoder(inner))\n throw new Error(`padRight: invalid inner value ${inner}`);\n if (!isNum(blockSize) || blockSize <= 0)\n throw new Error(`padLeft: wrong blockSize=${blockSize}`);\n if (padFn !== undefined && typeof padFn !== 'function')\n throw new Error(`padRight: wrong padFn=${typeof padFn}`);\n const _padFn = padFn || ZeroPad;\n return wrap({\n size: inner.size ? inner.size + padLength(blockSize, inner.size) : undefined,\n encodeStream: (w, value) => {\n const _w = w;\n const pos = _w.pos;\n inner.encodeStream(w, value);\n const padBytes = padLength(blockSize, _w.pos - pos);\n for (let i = 0; i < padBytes; i++)\n w.byte(_padFn(i));\n },\n decodeStream: (r) => {\n const start = r.pos;\n const res = inner.decodeStream(r);\n r.bytes(padLength(blockSize, r.pos - start));\n return res;\n },\n });\n}\n1;\n/**\n * Pointer to a value using a pointer CoderType and an inner CoderType.\n * Pointers are scoped, and the next pointer in the dereference chain is offset by the previous one.\n * By default (if no 'allowMultipleReads' in ReaderOpts is set) is safe, since\n * same region of memory cannot be read multiple times.\n * @param ptr - CoderType for the pointer value.\n * @param inner - CoderType for encoding/decoding the pointed value.\n * @param sized - Whether the pointer should have a fixed size.\n * @returns CoderType representing the pointer to the value.\n * @example\n * const pointerToU8 = P.pointer(P.U16BE, P.U8); // Pointer to a single U8 value\n */\nexport function pointer(ptr, inner, sized = false) {\n if (!isCoder(ptr))\n throw new Error(`pointer: invalid ptr value ${ptr}`);\n if (!isCoder(inner))\n throw new Error(`pointer: invalid inner value ${inner}`);\n if (typeof sized !== 'boolean')\n throw new Error(`pointer/sized: expected boolean, got ${typeof sized}`);\n if (!ptr.size)\n throw new Error('unsized pointer');\n return wrap({\n size: sized ? ptr.size : undefined,\n encodeStream: (w, value) => {\n const _w = w;\n const start = _w.pos;\n ptr.encodeStream(w, 0);\n _w.ptrs.push({ pos: start, ptr, buffer: inner.encode(value) });\n },\n decodeStream: (r) => {\n const ptrVal = ptr.decodeStream(r);\n r._enablePointers();\n return inner.decodeStream(r.offsetReader(ptrVal));\n },\n });\n}\n// Internal methods for test purposes only\nexport const _TEST = { _bitset: Bitset, _Reader, _Writer, Path };\n//# sourceMappingURL=index.js.map","import { schnorr, secp256k1 as secp } from '@noble/curves/secp256k1.js';\nimport { bytesToNumberBE, numberToBytesBE } from '@noble/curves/utils.js';\nimport { ripemd160 } from '@noble/hashes/legacy.js';\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { utils as packedUtils, U32LE } from 'micro-packed';\nconst Point = secp.Point;\nconst Fn = Point.Fn;\nconst CURVE_ORDER = Point.Fn.ORDER;\nexport const hasEven = (y) => y % 2n === 0n;\nconst isBytes = packedUtils.isBytes;\nconst concatBytes = packedUtils.concatBytes;\nconst equalBytes = packedUtils.equalBytes;\nexport { concatBytes, equalBytes, isBytes, sha256 };\nexport const hash160 = (msg) => ripemd160(sha256(msg));\nexport const sha256x2 = (...msgs) => sha256(sha256(concatBytes(...msgs)));\nexport const randomPrivateKeyBytes = schnorr.utils.randomSecretKey;\nexport const pubSchnorr = schnorr.getPublicKey;\nexport const pubECDSA = secp.getPublicKey;\n// low-r signature grinding. Used to reduce tx size by 1 byte.\n// noble/secp256k1 does not support the feature: it is not used outside of BTC.\n// We implement it manually, because in BTC it's common.\n// Not best way, but closest to bitcoin implementation (easier to check)\nconst hasLowR = (sig) => sig.r < CURVE_ORDER / 2n;\nexport function signECDSA(hash, privateKey, lowR = false) {\n let sig = secp.Signature.fromBytes(secp.sign(hash, privateKey, { prehash: false }));\n if (lowR && !hasLowR(sig)) {\n const extraEntropy = new Uint8Array(32);\n let counter = 0;\n while (!hasLowR(sig)) {\n extraEntropy.set(U32LE.encode(counter++));\n sig = secp.Signature.fromBytes(secp.sign(hash, privateKey, { prehash: false, extraEntropy }));\n if (counter > 4294967295)\n throw new Error('lowR counter overflow: report the error');\n }\n }\n return sig.toBytes('der');\n}\nexport const signSchnorr = schnorr.sign;\nexport const tagSchnorr = schnorr.utils.taggedHash;\nexport const PubT = {\n ecdsa: 0,\n schnorr: 1,\n};\nexport function validatePubkey(pub, type) {\n const len = pub.length;\n if (type === PubT.ecdsa) {\n if (len === 32)\n throw new Error('Expected non-Schnorr key');\n Point.fromBytes(pub); // does assertValidity\n return pub;\n }\n else if (type === PubT.schnorr) {\n if (len !== 32)\n throw new Error('Expected 32-byte Schnorr key');\n schnorr.utils.lift_x(bytesToNumberBE(pub));\n return pub;\n }\n else {\n throw new Error('Unknown key type');\n }\n}\nexport function tapTweak(a, b) {\n const u = schnorr.utils;\n const t = u.taggedHash('TapTweak', a, b);\n const tn = bytesToNumberBE(t);\n if (tn >= CURVE_ORDER)\n throw new Error('tweak higher than curve order');\n return tn;\n}\nexport function taprootTweakPrivKey(privKey, merkleRoot = Uint8Array.of()) {\n const u = schnorr.utils;\n const seckey0 = bytesToNumberBE(privKey); // seckey0 = int_from_bytes(seckey0)\n const P = Point.BASE.multiply(seckey0); // P = point_mul(G, seckey0)\n // seckey = seckey0 if has_even_y(P) else SECP256K1_ORDER - seckey0\n const seckey = hasEven(P.y) ? seckey0 : Fn.neg(seckey0);\n const xP = u.pointToBytes(P);\n // t = int_from_bytes(tagged_hash(\"TapTweak\", bytes_from_int(x(P)) + h)); >= SECP256K1_ORDER check\n const t = tapTweak(xP, merkleRoot);\n // bytes_from_int((seckey + t) % SECP256K1_ORDER)\n return numberToBytesBE(Fn.add(seckey, t), 32);\n}\nexport function taprootTweakPubkey(pubKey, h) {\n const u = schnorr.utils;\n const t = tapTweak(pubKey, h); // t = int_from_bytes(tagged_hash(\"TapTweak\", pubkey + h))\n const P = u.lift_x(bytesToNumberBE(pubKey)); // P = lift_x(int_from_bytes(pubkey))\n const Q = P.add(Point.BASE.multiply(t)); // Q = point_add(P, point_mul(G, t))\n const parity = hasEven(Q.y) ? 0 : 1; // 0 if has_even_y(Q) else 1\n return [u.pointToBytes(Q), parity]; // bytes_from_int(x(Q))\n}\n// Another stupid decision, where lack of standard affects security.\n// Multisig needs to be generated with some key.\n// We are using approach from BIP 341/bitcoinjs-lib: SHA256(uncompressedDER(SECP256K1_GENERATOR_POINT))\n// It is possible to switch SECP256K1_GENERATOR_POINT with some random point;\n// but it's too complex to prove.\n// Also used by bitcoin-core and bitcoinjs-lib\nexport const TAPROOT_UNSPENDABLE_KEY = sha256(Point.BASE.toBytes(false));\nexport const NETWORK = {\n bech32: 'bc',\n pubKeyHash: 0x00,\n scriptHash: 0x05,\n wif: 0x80,\n};\nexport const TEST_NETWORK = {\n bech32: 'tb',\n pubKeyHash: 0x6f,\n scriptHash: 0xc4,\n wif: 0xef,\n};\n// Exported for tests, internal method\nexport function compareBytes(a, b) {\n if (!isBytes(a) || !isBytes(b))\n throw new Error(`cmp: wrong type a=${typeof a} b=${typeof b}`);\n // -1 -> a a==b, 1 -> a>b\n const len = Math.min(a.length, b.length);\n for (let i = 0; i < len; i++)\n if (a[i] != b[i])\n return Math.sign(a[i] - b[i]);\n return Math.sign(a.length - b.length);\n}\n// Reverses key<->values\nexport function reverseObject(obj) {\n const res = {};\n for (const k in obj) {\n if (res[obj[k]] !== undefined)\n throw new Error('duplicate key');\n res[obj[k]] = k;\n }\n return res;\n}\n//# sourceMappingURL=utils.js.map","import * as P from 'micro-packed';\nimport { isBytes, reverseObject } from \"./utils.js\";\nexport const MAX_SCRIPT_BYTE_LENGTH = 520;\n// prettier-ignore\nexport const OP = {\n OP_0: 0, PUSHDATA1: 76, PUSHDATA2: 77, PUSHDATA4: 78, '1NEGATE': 79,\n RESERVED: 80,\n OP_1: 81, OP_2: 82, OP_3: 83, OP_4: 84, OP_5: 85, OP_6: 86, OP_7: 87, OP_8: 88, OP_9: 89,\n OP_10: 90, OP_11: 91, OP_12: 92, OP_13: 93, OP_14: 94, OP_15: 95, OP_16: 96,\n // Control\n NOP: 97, VER: 98, IF: 99, NOTIF: 100, VERIF: 101, VERNOTIF: 102, ELSE: 103, ENDIF: 104, VERIFY: 105, RETURN: 106,\n // Stack\n TOALTSTACK: 107, FROMALTSTACK: 108, '2DROP': 109, '2DUP': 110, '3DUP': 111, '2OVER': 112, '2ROT': 113, '2SWAP': 114,\n IFDUP: 115, DEPTH: 116, DROP: 117, DUP: 118, NIP: 119, OVER: 120, PICK: 121, ROLL: 122, ROT: 123, SWAP: 124, TUCK: 125,\n // Splice\n CAT: 126, SUBSTR: 127, LEFT: 128, RIGHT: 129, SIZE: 130,\n // Boolean logic\n INVERT: 131, AND: 132, OR: 133, XOR: 134, EQUAL: 135, EQUALVERIFY: 136, RESERVED1: 137, RESERVED2: 138,\n // Numbers\n '1ADD': 139, '1SUB': 140, '2MUL': 141, '2DIV': 142,\n NEGATE: 143, ABS: 144, NOT: 145, '0NOTEQUAL': 146,\n ADD: 147, SUB: 148, MUL: 149, DIV: 150, MOD: 151, LSHIFT: 152, RSHIFT: 153, BOOLAND: 154, BOOLOR: 155,\n NUMEQUAL: 156, NUMEQUALVERIFY: 157, NUMNOTEQUAL: 158, LESSTHAN: 159, GREATERTHAN: 160,\n LESSTHANOREQUAL: 161, GREATERTHANOREQUAL: 162, MIN: 163, MAX: 164, WITHIN: 165,\n // Crypto\n RIPEMD160: 166, SHA1: 167, SHA256: 168, HASH160: 169, HASH256: 170, CODESEPARATOR: 171,\n CHECKSIG: 172, CHECKSIGVERIFY: 173, CHECKMULTISIG: 174, CHECKMULTISIGVERIFY: 175,\n // Expansion\n NOP1: 176, CHECKLOCKTIMEVERIFY: 177, CHECKSEQUENCEVERIFY: 178, NOP4: 179, NOP5: 180, NOP6: 181, NOP7: 182, NOP8: 183, NOP9: 184, NOP10: 185,\n // BIP 342\n CHECKSIGADD: 186,\n // Invalid\n INVALID: 255,\n};\nexport const OPNames = reverseObject(OP);\n// We can encode almost any number as ScriptNum, however, parsing will be a problem\n// since we can't know if buffer is a number or something else.\nexport function ScriptNum(bytesLimit = 6, forceMinimal = false) {\n return P.wrap({\n encodeStream: (w, value) => {\n if (value === 0n)\n return;\n const neg = value < 0;\n const val = BigInt(value);\n const nums = [];\n for (let abs = neg ? -val : val; abs; abs >>= 8n)\n nums.push(Number(abs & 0xffn));\n if (nums[nums.length - 1] >= 0x80)\n nums.push(neg ? 0x80 : 0);\n else if (neg)\n nums[nums.length - 1] |= 0x80;\n w.bytes(new Uint8Array(nums));\n },\n decodeStream: (r) => {\n const len = r.leftBytes;\n if (len > bytesLimit)\n throw new Error(`ScriptNum: number (${len}) bigger than limit=${bytesLimit}`);\n if (len === 0)\n return 0n;\n if (forceMinimal) {\n const data = r.bytes(len, true);\n // MSB is zero (without sign bit) -> not minimally encoded\n if ((data[data.length - 1] & 0x7f) === 0) {\n // exception\n if (len <= 1 || (data[data.length - 2] & 0x80) === 0)\n throw new Error('Non-minimally encoded ScriptNum');\n }\n }\n let last = 0;\n let res = 0n;\n for (let i = 0; i < len; ++i) {\n last = r.byte();\n res |= BigInt(last) << (8n * BigInt(i));\n }\n if (last >= 0x80) {\n res &= (2n ** BigInt(len * 8) - 1n) >> 1n;\n res = -res;\n }\n return res;\n },\n });\n}\nexport function OpToNum(op, bytesLimit = 4, forceMinimal = true) {\n if (typeof op === 'number')\n return op;\n if (isBytes(op)) {\n try {\n const val = ScriptNum(bytesLimit, forceMinimal).decode(op);\n if (val > Number.MAX_SAFE_INTEGER)\n return;\n return Number(val);\n }\n catch (e) {\n return;\n }\n }\n return;\n}\n// Converts script bytes to parsed script\n// 5221030000000000000000000000000000000000000000000000000000000000000001210300000000000000000000000000000000000000000000000000000000000000022103000000000000000000000000000000000000000000000000000000000000000353ae\n// =>\n// OP_2\n// 030000000000000000000000000000000000000000000000000000000000000001\n// 030000000000000000000000000000000000000000000000000000000000000002\n// 030000000000000000000000000000000000000000000000000000000000000003\n// OP_3\n// CHECKMULTISIG\nexport const Script = P.wrap({\n encodeStream: (w, value) => {\n for (let o of value) {\n if (typeof o === 'string') {\n if (OP[o] === undefined)\n throw new Error(`Unknown opcode=${o}`);\n w.byte(OP[o]);\n continue;\n }\n else if (typeof o === 'number') {\n if (o === 0x00) {\n w.byte(0x00);\n continue;\n }\n else if (1 <= o && o <= 16) {\n w.byte(OP.OP_1 - 1 + o);\n continue;\n }\n }\n // Encode big numbers\n if (typeof o === 'number')\n o = ScriptNum().encode(BigInt(o));\n if (!isBytes(o))\n throw new Error(`Wrong Script OP=${o} (${typeof o})`);\n // Bytes\n const len = o.length;\n if (len < OP.PUSHDATA1)\n w.byte(len);\n else if (len <= 0xff) {\n w.byte(OP.PUSHDATA1);\n w.byte(len);\n }\n else if (len <= 0xffff) {\n w.byte(OP.PUSHDATA2);\n w.bytes(P.U16LE.encode(len));\n }\n else {\n w.byte(OP.PUSHDATA4);\n w.bytes(P.U32LE.encode(len));\n }\n w.bytes(o);\n }\n },\n decodeStream: (r) => {\n const out = [];\n while (!r.isEnd()) {\n const cur = r.byte();\n // if 0 < cur < 78\n if (OP.OP_0 < cur && cur <= OP.PUSHDATA4) {\n let len;\n if (cur < OP.PUSHDATA1)\n len = cur;\n else if (cur === OP.PUSHDATA1)\n len = P.U8.decodeStream(r);\n else if (cur === OP.PUSHDATA2)\n len = P.U16LE.decodeStream(r);\n else if (cur === OP.PUSHDATA4)\n len = P.U32LE.decodeStream(r);\n else\n throw new Error('Should be not possible');\n out.push(r.bytes(len));\n }\n else if (cur === 0x00) {\n out.push(0);\n }\n else if (OP.OP_1 <= cur && cur <= OP.OP_16) {\n out.push(cur - (OP.OP_1 - 1));\n }\n else {\n const op = OPNames[cur];\n if (op === undefined)\n throw new Error(`Unknown opcode=${cur.toString(16)}`);\n out.push(op);\n }\n }\n return out;\n },\n});\n// BTC specific variable length integer encoding\n// https://en.bitcoin.it/wiki/Protocol_documentation#Variable_length_integer\nconst CSLimits = {\n 0xfd: [0xfd, 2, 253n, 65535n],\n 0xfe: [0xfe, 4, 65536n, 4294967295n],\n 0xff: [0xff, 8, 4294967296n, 18446744073709551615n],\n};\nexport const CompactSize = P.wrap({\n encodeStream: (w, value) => {\n if (typeof value === 'number')\n value = BigInt(value);\n if (0n <= value && value <= 252n)\n return w.byte(Number(value));\n for (const [flag, bytes, start, stop] of Object.values(CSLimits)) {\n if (start > value || value > stop)\n continue;\n w.byte(flag);\n for (let i = 0; i < bytes; i++)\n w.byte(Number((value >> (8n * BigInt(i))) & 0xffn));\n return;\n }\n throw w.err(`VarInt too big: ${value}`);\n },\n decodeStream: (r) => {\n const b0 = r.byte();\n if (b0 <= 0xfc)\n return BigInt(b0);\n const [_, bytes, start] = CSLimits[b0];\n let num = 0n;\n for (let i = 0; i < bytes; i++)\n num |= BigInt(r.byte()) << (8n * BigInt(i));\n if (num < start)\n throw r.err(`Wrong CompactSize(${8 * bytes})`);\n return num;\n },\n});\n// Same thing, but in number instead of bigint. Checks for safe integer inside\nexport const CompactSizeLen = P.apply(CompactSize, P.coders.numberBigint);\n// ui8a of size \nexport const VarBytes = P.bytes(CompactSize);\n// SegWit v0 stack of witness buffers\nexport const RawWitness = P.array(CompactSizeLen, VarBytes);\n// Array of size \nexport const BTCArray = (t) => P.array(CompactSize, t);\nexport const RawInput = P.struct({\n txid: P.bytes(32, true), // hash(prev_tx),\n index: P.U32LE, // output number of previous tx\n finalScriptSig: VarBytes, // btc merges input and output script, executes it. If ok = tx passes\n sequence: P.U32LE, // ?\n});\nexport const RawOutput = P.struct({ amount: P.U64LE, script: VarBytes });\n// https://en.bitcoin.it/wiki/Protocol_documentation#tx\nconst _RawTx = P.struct({\n version: P.I32LE,\n segwitFlag: P.flag(new Uint8Array([0x00, 0x01])),\n inputs: BTCArray(RawInput),\n outputs: BTCArray(RawOutput),\n witnesses: P.flagged('segwitFlag', P.array('inputs/length', RawWitness)),\n // < 500000000\tBlock number at which this transaction is unlocked\n // >= 500000000\tUNIX timestamp at which this transaction is unlocked\n // Handled as part of PSBTv2\n lockTime: P.U32LE,\n});\nfunction validateRawTx(tx) {\n if (tx.segwitFlag && tx.witnesses && !tx.witnesses.length)\n throw new Error('Segwit flag with empty witnesses array');\n return tx;\n}\nexport const RawTx = P.validate(_RawTx, validateRawTx);\n// Pre-SegWit serialization format (for PSBTv0)\nexport const RawOldTx = P.struct({\n version: P.I32LE,\n inputs: BTCArray(RawInput),\n outputs: BTCArray(RawOutput),\n lockTime: P.U32LE,\n});\n//# sourceMappingURL=script.js.map","import { bech32, bech32m, createBase58check, hex } from '@scure/base';\nimport * as P from 'micro-packed';\nimport { TaprootControlBlock } from \"./psbt.js\";\nimport { OpToNum, Script, VarBytes } from \"./script.js\";\nimport * as u from \"./utils.js\";\nimport { NETWORK } from \"./utils.js\";\nconst OutP2A = {\n encode(from) {\n if (from.length !== 2 || from[0] !== 1 || !u.isBytes(from[1]) || hex.encode(from[1]) !== '4e73')\n return;\n return { type: 'p2a', script: Script.encode(from) };\n },\n decode: (to) => {\n if (to.type !== 'p2a')\n return;\n return [1, hex.decode('4e73')];\n },\n};\nfunction isValidPubkey(pub, type) {\n try {\n u.validatePubkey(pub, type);\n return true;\n }\n catch (e) {\n return false;\n }\n}\nconst OutPK = {\n encode(from) {\n if (from.length !== 2 ||\n !u.isBytes(from[0]) ||\n !isValidPubkey(from[0], u.PubT.ecdsa) ||\n from[1] !== 'CHECKSIG')\n return;\n return { type: 'pk', pubkey: from[0] };\n },\n decode: (to) => (to.type === 'pk' ? [to.pubkey, 'CHECKSIG'] : undefined),\n};\nconst OutPKH = {\n encode(from) {\n if (from.length !== 5 || from[0] !== 'DUP' || from[1] !== 'HASH160' || !u.isBytes(from[2]))\n return;\n if (from[3] !== 'EQUALVERIFY' || from[4] !== 'CHECKSIG')\n return;\n return { type: 'pkh', hash: from[2] };\n },\n decode: (to) => to.type === 'pkh' ? ['DUP', 'HASH160', to.hash, 'EQUALVERIFY', 'CHECKSIG'] : undefined,\n};\nconst OutSH = {\n encode(from) {\n if (from.length !== 3 || from[0] !== 'HASH160' || !u.isBytes(from[1]) || from[2] !== 'EQUAL')\n return;\n return { type: 'sh', hash: from[1] };\n },\n decode: (to) => to.type === 'sh' ? ['HASH160', to.hash, 'EQUAL'] : undefined,\n};\nconst OutWSH = {\n encode(from) {\n if (from.length !== 2 || from[0] !== 0 || !u.isBytes(from[1]))\n return;\n if (from[1].length !== 32)\n return;\n return { type: 'wsh', hash: from[1] };\n },\n decode: (to) => (to.type === 'wsh' ? [0, to.hash] : undefined),\n};\nconst OutWPKH = {\n encode(from) {\n if (from.length !== 2 || from[0] !== 0 || !u.isBytes(from[1]))\n return;\n if (from[1].length !== 20)\n return;\n return { type: 'wpkh', hash: from[1] };\n },\n decode: (to) => (to.type === 'wpkh' ? [0, to.hash] : undefined),\n};\nconst OutMS = {\n encode(from) {\n const last = from.length - 1;\n if (from[last] !== 'CHECKMULTISIG')\n return;\n const m = from[0];\n const n = from[last - 1];\n if (typeof m !== 'number' || typeof n !== 'number')\n return;\n const pubkeys = from.slice(1, -2);\n if (n !== pubkeys.length)\n return;\n for (const pub of pubkeys)\n if (!u.isBytes(pub))\n return;\n return { type: 'ms', m, pubkeys: pubkeys }; // we don't need n, since it is the same as pubkeys\n },\n // checkmultisig(n, ..pubkeys, m)\n decode: (to) => to.type === 'ms' ? [to.m, ...to.pubkeys, to.pubkeys.length, 'CHECKMULTISIG'] : undefined,\n};\nconst OutTR = {\n encode(from) {\n if (from.length !== 2 || from[0] !== 1 || !u.isBytes(from[1]))\n return;\n return { type: 'tr', pubkey: from[1] };\n },\n decode: (to) => (to.type === 'tr' ? [1, to.pubkey] : undefined),\n};\nconst OutTRNS = {\n encode(from) {\n const last = from.length - 1;\n if (from[last] !== 'CHECKSIG')\n return;\n const pubkeys = [];\n // On error return, since it can be different script\n for (let i = 0; i < last; i++) {\n const elm = from[i];\n if (i & 1) {\n if (elm !== 'CHECKSIGVERIFY' || i === last - 1)\n return;\n continue;\n }\n if (!u.isBytes(elm))\n return;\n pubkeys.push(elm);\n }\n return { type: 'tr_ns', pubkeys };\n },\n decode: (to) => {\n if (to.type !== 'tr_ns')\n return;\n const out = [];\n for (let i = 0; i < to.pubkeys.length - 1; i++)\n out.push(to.pubkeys[i], 'CHECKSIGVERIFY');\n out.push(to.pubkeys[to.pubkeys.length - 1], 'CHECKSIG');\n return out;\n },\n};\nconst OutTRMS = {\n encode(from) {\n const last = from.length - 1;\n if (from[last] !== 'NUMEQUAL' || from[1] !== 'CHECKSIG')\n return;\n const pubkeys = [];\n const m = OpToNum(from[last - 1]);\n if (typeof m !== 'number')\n return;\n for (let i = 0; i < last - 1; i++) {\n const elm = from[i];\n if (i & 1) {\n if (elm !== (i === 1 ? 'CHECKSIG' : 'CHECKSIGADD'))\n throw new Error('OutScript.encode/tr_ms: wrong element');\n continue;\n }\n if (!u.isBytes(elm))\n throw new Error('OutScript.encode/tr_ms: wrong key element');\n pubkeys.push(elm);\n }\n return { type: 'tr_ms', pubkeys, m };\n },\n decode: (to) => {\n if (to.type !== 'tr_ms')\n return;\n const out = [to.pubkeys[0], 'CHECKSIG'];\n for (let i = 1; i < to.pubkeys.length; i++)\n out.push(to.pubkeys[i], 'CHECKSIGADD');\n out.push(to.m, 'NUMEQUAL');\n return out;\n },\n};\nconst OutUnknown = {\n encode(from) {\n return { type: 'unknown', script: Script.encode(from) };\n },\n decode: (to) => to.type === 'unknown' ? Script.decode(to.script) : undefined,\n};\n// /Payments\nconst OutScripts = [\n OutP2A,\n OutPK,\n OutPKH,\n OutSH,\n OutWSH,\n OutWPKH,\n OutMS,\n OutTR,\n OutTRNS,\n OutTRMS,\n OutUnknown,\n];\n// TODO: we can support user supplied output scripts now\n// - addOutScript\n// - removeOutScript\n// - We can do that as log we modify array in-place\n// - Actually is very hard, since there is sign/finalize logic\nconst _OutScript = P.apply(Script, P.coders.match(OutScripts));\n// We can validate this once, because of packed & coders\nexport const OutScript = P.validate(_OutScript, (i) => {\n if (i.type === 'pk' && !isValidPubkey(i.pubkey, u.PubT.ecdsa))\n throw new Error('OutScript/pk: wrong key');\n if ((i.type === 'pkh' || i.type === 'sh' || i.type === 'wpkh') &&\n (!u.isBytes(i.hash) || i.hash.length !== 20))\n throw new Error(`OutScript/${i.type}: wrong hash`);\n if (i.type === 'wsh' && (!u.isBytes(i.hash) || i.hash.length !== 32))\n throw new Error(`OutScript/wsh: wrong hash`);\n if (i.type === 'tr' && (!u.isBytes(i.pubkey) || !isValidPubkey(i.pubkey, u.PubT.schnorr)))\n throw new Error('OutScript/tr: wrong taproot public key');\n if (i.type === 'ms' || i.type === 'tr_ns' || i.type === 'tr_ms')\n if (!Array.isArray(i.pubkeys))\n throw new Error('OutScript/multisig: wrong pubkeys array');\n if (i.type === 'ms') {\n const n = i.pubkeys.length;\n for (const p of i.pubkeys)\n if (!isValidPubkey(p, u.PubT.ecdsa))\n throw new Error('OutScript/multisig: wrong pubkey');\n if (i.m <= 0 || n > 16 || i.m > n)\n throw new Error('OutScript/multisig: invalid params');\n }\n if (i.type === 'tr_ns' || i.type === 'tr_ms') {\n for (const p of i.pubkeys)\n if (!isValidPubkey(p, u.PubT.schnorr))\n throw new Error(`OutScript/${i.type}: wrong pubkey`);\n }\n if (i.type === 'tr_ms') {\n const n = i.pubkeys.length;\n if (i.m <= 0 || n > 999 || i.m > n)\n throw new Error('OutScript/tr_ms: invalid params');\n }\n return i;\n});\n// Basic sanity check for scripts\nfunction checkWSH(s, witnessScript) {\n if (!u.equalBytes(s.hash, u.sha256(witnessScript)))\n throw new Error('checkScript: wsh wrong witnessScript hash');\n const w = OutScript.decode(witnessScript);\n if (w.type === 'tr' || w.type === 'tr_ns' || w.type === 'tr_ms')\n throw new Error(`checkScript: P2${w.type} cannot be wrapped in P2SH`);\n if (w.type === 'wpkh' || w.type === 'sh')\n throw new Error(`checkScript: P2${w.type} cannot be wrapped in P2WSH`);\n}\nexport function checkScript(script, redeemScript, witnessScript) {\n if (script) {\n const s = OutScript.decode(script);\n // ms||pk maybe work, but there will be no address, hard to spend\n if (s.type === 'tr_ns' || s.type === 'tr_ms' || s.type === 'ms' || s.type == 'pk')\n throw new Error(`checkScript: non-wrapped ${s.type}`);\n if (s.type === 'sh' && redeemScript) {\n if (!u.equalBytes(s.hash, u.hash160(redeemScript)))\n throw new Error('checkScript: sh wrong redeemScript hash');\n const r = OutScript.decode(redeemScript);\n if (r.type === 'tr' || r.type === 'tr_ns' || r.type === 'tr_ms')\n throw new Error(`checkScript: P2${r.type} cannot be wrapped in P2SH`);\n // Not sure if this unspendable, but we cannot represent this via PSBT\n if (r.type === 'sh')\n throw new Error('checkScript: P2SH cannot be wrapped in P2SH');\n }\n if (s.type === 'wsh' && witnessScript)\n checkWSH(s, witnessScript);\n }\n if (redeemScript) {\n const r = OutScript.decode(redeemScript);\n if (r.type === 'wsh' && witnessScript)\n checkWSH(r, witnessScript);\n }\n}\nfunction uniqPubkey(pubkeys) {\n const map = {};\n for (const pub of pubkeys) {\n const key = hex.encode(pub);\n if (map[key])\n throw new Error(`Multisig: non-uniq pubkey: ${pubkeys.map(hex.encode)}`);\n map[key] = true;\n }\n}\nexport const p2pk = (pubkey, _network = NETWORK) => {\n // network is unused\n if (!isValidPubkey(pubkey, u.PubT.ecdsa))\n throw new Error('P2PK: invalid publicKey');\n return { type: 'pk', script: OutScript.encode({ type: 'pk', pubkey }) };\n};\nexport const p2pkh = (publicKey, network = NETWORK) => {\n if (!isValidPubkey(publicKey, u.PubT.ecdsa))\n throw new Error('P2PKH: invalid publicKey');\n const hash = u.hash160(publicKey);\n return {\n type: 'pkh',\n script: OutScript.encode({ type: 'pkh', hash }),\n address: Address(network).encode({ type: 'pkh', hash }),\n hash,\n };\n};\nexport const p2sh = (child, network = NETWORK) => {\n // It is already tested inside noble-hashes and checkScript\n const cs = child.script;\n if (!u.isBytes(cs))\n throw new Error(`Wrong script: ${typeof child.script}, expected Uint8Array`);\n const hash = u.hash160(cs);\n const script = OutScript.encode({ type: 'sh', hash });\n checkScript(script, cs, child.witnessScript);\n if (child.witnessScript) {\n return {\n type: 'sh',\n redeemScript: cs,\n script: OutScript.encode({ type: 'sh', hash }),\n address: Address(network).encode({ type: 'sh', hash }),\n hash,\n witnessScript: child.witnessScript,\n };\n }\n else {\n return {\n type: 'sh',\n redeemScript: cs,\n script: OutScript.encode({ type: 'sh', hash }),\n address: Address(network).encode({ type: 'sh', hash }),\n hash,\n };\n }\n};\nexport const p2wsh = (child, network = NETWORK) => {\n const cs = child.script;\n if (!u.isBytes(cs))\n throw new Error(`Wrong script: ${typeof cs}, expected Uint8Array`);\n const hash = u.sha256(cs);\n const script = OutScript.encode({ type: 'wsh', hash });\n checkScript(script, undefined, cs);\n return {\n type: 'wsh',\n witnessScript: cs,\n script: OutScript.encode({ type: 'wsh', hash }),\n address: Address(network).encode({ type: 'wsh', hash }),\n hash,\n };\n};\nexport const p2wpkh = (publicKey, network = NETWORK) => {\n if (!isValidPubkey(publicKey, u.PubT.ecdsa))\n throw new Error('P2WPKH: invalid publicKey');\n if (publicKey.length === 65)\n throw new Error('P2WPKH: uncompressed public key');\n const hash = u.hash160(publicKey);\n return {\n type: 'wpkh',\n script: OutScript.encode({ type: 'wpkh', hash }),\n address: Address(network).encode({ type: 'wpkh', hash }),\n hash,\n };\n};\nexport const p2ms = (m, pubkeys, allowSamePubkeys = false) => {\n if (!allowSamePubkeys)\n uniqPubkey(pubkeys);\n return {\n type: 'ms',\n script: OutScript.encode({ type: 'ms', pubkeys, m }),\n };\n};\nfunction checkTaprootScript(script, internalPubKey, allowUnknownOutputs = false, customScripts) {\n const out = OutScript.decode(script);\n if (out.type === 'unknown') {\n // NOTE: this check should be before allowUnknownOutputs, otherwise it will\n // disable custom. All custom scripts for taproot should have prefix 'tr_'\n if (customScripts) {\n const cs = P.apply(Script, P.coders.match(customScripts));\n const c = cs.decode(script);\n if (c !== undefined) {\n if (typeof c.type !== 'string' || !c.type.startsWith('tr_'))\n throw new Error(`P2TR: invalid custom type=${c.type}`);\n return;\n }\n }\n if (allowUnknownOutputs)\n return;\n }\n if (!['tr_ns', 'tr_ms'].includes(out.type))\n throw new Error(`P2TR: invalid leaf script=${out.type}`);\n const outms = out;\n if (!allowUnknownOutputs && outms.pubkeys) {\n for (const p of outms.pubkeys) {\n if (u.equalBytes(p, u.TAPROOT_UNSPENDABLE_KEY))\n throw new Error('Unspendable taproot key in leaf script');\n // It's likely a mistake at this point:\n // 1. p2tr(A, p2tr_ns(2, [A, B])) == p2tr(A, p2tr_pk(B)) (A or B key)\n // but will take more space and fees.\n // 2. For multi-sig p2tr(A, p2tr_ns(2, [A, B, C])) it's probably a security issue:\n // User creates 2 of 3 multisig of keys [A, B, C],\n // but key A always can spend whole output without signatures from other keys.\n // p2tr(A, p2tr_ns(2, [B, C, D])) is ok: A or (B and C) or (B and D) or (C and D)\n if (u.equalBytes(p, internalPubKey)) {\n throw new Error('Using P2TR with leaf script with same key as internal key is not supported');\n }\n }\n }\n}\n// Helper for generating binary tree from list, with weights\nexport function taprootListToTree(taprootList) {\n // Clone input in order to not corrupt it\n const lst = Array.from(taprootList);\n // We have at least 2 elements => can create branch\n while (lst.length >= 2) {\n // Sort: elements with smallest weight are in the end of queue\n lst.sort((a, b) => (b.weight || 1) - (a.weight || 1));\n const b = lst.pop();\n const a = lst.pop();\n const weight = (a?.weight || 1) + (b?.weight || 1);\n lst.push({\n weight,\n // Unwrap children array\n // TODO: Very hard to remove any here\n childs: [a?.childs || a, b?.childs || b],\n });\n }\n // At this point there is always 1 element in lst\n const last = lst[0];\n return (last?.childs || last);\n}\nfunction taprootAddPath(tree, path = []) {\n if (!tree)\n throw new Error(`taprootAddPath: empty tree`);\n if (tree.type === 'leaf')\n return { ...tree, path };\n if (tree.type !== 'branch')\n throw new Error(`taprootAddPath: wrong type=${tree}`);\n return {\n ...tree,\n path,\n // Left element has right hash in path and otherwise\n left: taprootAddPath(tree.left, [tree.right.hash, ...path]),\n right: taprootAddPath(tree.right, [tree.left.hash, ...path]),\n };\n}\nfunction taprootWalkTree(tree) {\n if (!tree)\n throw new Error(`taprootAddPath: empty tree`);\n if (tree.type === 'leaf')\n return [tree];\n if (tree.type !== 'branch')\n throw new Error(`taprootWalkTree: wrong type=${tree}`);\n return [...taprootWalkTree(tree.left), ...taprootWalkTree(tree.right)];\n}\nfunction taprootHashTree(tree, internalPubKey, allowUnknownOutputs = false, customScripts) {\n if (!tree)\n throw new Error('taprootHashTree: empty tree');\n if (Array.isArray(tree) && tree.length === 1)\n tree = tree[0];\n // Terminal node (leaf)\n if (!Array.isArray(tree)) {\n const { leafVersion: version, script: leafScript } = tree;\n // Earliest tree walk where we can validate tapScripts\n if (tree.tapLeafScript || (tree.tapMerkleRoot && !u.equalBytes(tree.tapMerkleRoot, P.EMPTY)))\n throw new Error('P2TR: tapRoot leafScript cannot have tree');\n const script = typeof leafScript === 'string' ? hex.decode(leafScript) : leafScript;\n if (!u.isBytes(script))\n throw new Error(`checkScript: wrong script type=${script}`);\n checkTaprootScript(script, internalPubKey, allowUnknownOutputs, customScripts);\n return {\n type: 'leaf',\n version,\n script,\n hash: tapLeafHash(script, version),\n };\n }\n // If tree / branch is not binary tree, convert it\n if (tree.length !== 2)\n tree = taprootListToTree(tree);\n if (tree.length !== 2)\n throw new Error('hashTree: non binary tree!');\n // branch\n // Both nodes should exist\n const left = taprootHashTree(tree[0], internalPubKey, allowUnknownOutputs, customScripts);\n const right = taprootHashTree(tree[1], internalPubKey, allowUnknownOutputs, customScripts);\n // We cannot swap left/right here, since it will change structure of tree\n let [lH, rH] = [left.hash, right.hash];\n if (u.compareBytes(rH, lH) === -1)\n [lH, rH] = [rH, lH];\n return { type: 'branch', left, right, hash: u.tagSchnorr('TapBranch', lH, rH) };\n}\nexport const TAP_LEAF_VERSION = 0xc0;\nexport const tapLeafHash = (script, version = TAP_LEAF_VERSION) => u.tagSchnorr('TapLeaf', new Uint8Array([version]), VarBytes.encode(script));\nexport function p2tr(internalPubKey, tree, network = NETWORK, allowUnknownOutputs = false, customScripts) {\n // Unspendable\n if (!internalPubKey && !tree)\n throw new Error('p2tr: should have pubKey or scriptTree (or both)');\n const pubKey = typeof internalPubKey === 'string'\n ? hex.decode(internalPubKey)\n : internalPubKey || u.TAPROOT_UNSPENDABLE_KEY;\n if (!isValidPubkey(pubKey, u.PubT.schnorr))\n throw new Error('p2tr: non-schnorr pubkey');\n if (tree) {\n let hashedTree = taprootAddPath(taprootHashTree(tree, pubKey, allowUnknownOutputs, customScripts));\n const tapMerkleRoot = hashedTree.hash;\n const [tweakedPubkey, parity] = u.taprootTweakPubkey(pubKey, tapMerkleRoot);\n const leaves = taprootWalkTree(hashedTree).map((l) => ({\n ...l,\n controlBlock: TaprootControlBlock.encode({\n version: (l.version || TAP_LEAF_VERSION) + parity,\n internalKey: pubKey,\n merklePath: l.path,\n }),\n }));\n return {\n type: 'tr',\n script: OutScript.encode({ type: 'tr', pubkey: tweakedPubkey }),\n address: Address(network).encode({ type: 'tr', pubkey: tweakedPubkey }),\n // For tests\n tweakedPubkey,\n // PSBT stuff\n tapInternalKey: pubKey,\n leaves,\n tapLeafScript: leaves.map((l) => [\n TaprootControlBlock.decode(l.controlBlock),\n u.concatBytes(l.script, new Uint8Array([l.version || TAP_LEAF_VERSION])),\n ]),\n tapMerkleRoot,\n };\n }\n else {\n const tweakedPubkey = u.taprootTweakPubkey(pubKey, P.EMPTY)[0];\n return {\n type: 'tr',\n script: OutScript.encode({ type: 'tr', pubkey: tweakedPubkey }),\n address: Address(network).encode({ type: 'tr', pubkey: tweakedPubkey }),\n // For tests\n tweakedPubkey,\n // PSBT stuff\n tapInternalKey: pubKey,\n };\n }\n}\n// Returns all combinations of size M from lst\nexport function combinations(m, list) {\n const res = [];\n if (!Array.isArray(list))\n throw new Error('combinations: lst arg should be array');\n const n = list.length;\n if (m > n)\n throw new Error('combinations: m > lst.length, no combinations possible');\n /*\n Basically works as M nested loops like:\n for (;idx[0] i);\n const last = idx.length - 1;\n main: for (;;) {\n res.push(idx.map((i) => list[i]));\n idx[last] += 1;\n let i = last;\n // Propagate increment\n // idx[i] cannot be bigger than n-m+i, otherwise last elements in right part will overflow\n for (; i >= 0 && idx[i] > n - m + i; i--) {\n idx[i] = 0;\n // Overflow in idx[0], break\n if (i === 0)\n break main;\n idx[i - 1] += 1;\n }\n // Propagate: idx[i+1] = idx[idx]+1\n for (i += 1; i < idx.length; i++)\n idx[i] = idx[i - 1] + 1;\n }\n return res;\n}\nexport const p2tr_ns = (m, pubkeys, allowSamePubkeys = false) => {\n if (!allowSamePubkeys)\n uniqPubkey(pubkeys);\n return combinations(m, pubkeys).map((i) => ({\n type: 'tr_ns',\n script: OutScript.encode({ type: 'tr_ns', pubkeys: i }),\n }));\n};\nexport const p2tr_pk = (pubkey) => p2tr_ns(1, [pubkey], undefined)[0];\nexport function p2tr_ms(m, pubkeys, allowSamePubkeys = false) {\n if (!allowSamePubkeys)\n uniqPubkey(pubkeys);\n return {\n type: 'tr_ms',\n script: OutScript.encode({ type: 'tr_ms', pubkeys, m }),\n };\n}\n// Simple pubkey address, without complex scripts\nexport function getAddress(type, privKey, network = NETWORK) {\n if (type === 'tr') {\n return p2tr(u.pubSchnorr(privKey), undefined, network).address;\n }\n const pubKey = u.pubECDSA(privKey);\n if (type === 'pkh')\n return p2pkh(pubKey, network).address;\n if (type === 'wpkh')\n return p2wpkh(pubKey, network).address;\n throw new Error(`getAddress: unknown type=${type}`);\n}\nexport const _sortPubkeys = (pubkeys) => Array.from(pubkeys).sort(u.compareBytes);\nexport function multisig(m, pubkeys, sorted = false, witness = false, network = NETWORK) {\n const ms = p2ms(m, sorted ? _sortPubkeys(pubkeys) : pubkeys);\n return witness ? p2wsh(ms, network) : p2sh(ms, network);\n}\nexport function sortedMultisig(m, pubkeys, witness = false, network = NETWORK) {\n return multisig(m, pubkeys, true, witness, network);\n}\nconst base58check = createBase58check(u.sha256);\nfunction validateWitness(version, data) {\n if (data.length < 2 || data.length > 40)\n throw new Error('Witness: invalid length');\n if (version > 16)\n throw new Error('Witness: invalid version');\n if (version === 0 && !(data.length === 20 || data.length === 32))\n throw new Error('Witness: invalid length for version');\n}\nfunction programToWitness(version, data, network = NETWORK) {\n validateWitness(version, data);\n const coder = version === 0 ? bech32 : bech32m;\n return coder.encode(network.bech32, [version].concat(coder.toWords(data)));\n}\nfunction formatKey(hashed, prefix) {\n return base58check.encode(u.concatBytes(Uint8Array.from(prefix), hashed));\n}\nexport function WIF(network = NETWORK) {\n return {\n encode(privKey) {\n const compressed = u.concatBytes(privKey, new Uint8Array([0x01]));\n return formatKey(compressed.subarray(0, 33), [network.wif]);\n },\n decode(wif) {\n let parsed = base58check.decode(wif);\n if (parsed[0] !== network.wif)\n throw new Error('Wrong WIF prefix');\n parsed = parsed.subarray(1);\n // Check what it is. Compressed flag?\n if (parsed.length !== 33)\n throw new Error('Wrong WIF length');\n if (parsed[32] !== 0x01)\n throw new Error('Wrong WIF postfix');\n return parsed.subarray(0, -1);\n },\n };\n}\n// Returns OutType, which can be used to create outscript\nexport function Address(network = NETWORK) {\n return {\n encode(from) {\n const { type } = from;\n if (type === 'wpkh')\n return programToWitness(0, from.hash, network);\n else if (type === 'wsh')\n return programToWitness(0, from.hash, network);\n else if (type === 'tr')\n return programToWitness(1, from.pubkey, network);\n else if (type === 'pkh')\n return formatKey(from.hash, [network.pubKeyHash]);\n else if (type === 'sh')\n return formatKey(from.hash, [network.scriptHash]);\n throw new Error(`Unknown address type=${type}`);\n },\n decode(address) {\n if (address.length < 14 || address.length > 74)\n throw new Error('Invalid address length');\n // Bech32\n if (network.bech32 && address.toLowerCase().startsWith(`${network.bech32}1`)) {\n let res;\n try {\n res = bech32.decode(address);\n if (res.words[0] !== 0)\n throw new Error(`bech32: wrong version=${res.words[0]}`);\n }\n catch (_) {\n // Starting from version 1 it is decoded as bech32m\n res = bech32m.decode(address);\n if (res.words[0] === 0)\n throw new Error(`bech32m: wrong version=${res.words[0]}`);\n }\n if (res.prefix !== network.bech32)\n throw new Error(`wrong bech32 prefix=${res.prefix}`);\n const [version, ...program] = res.words;\n const data = bech32.fromWords(program);\n validateWitness(version, data);\n if (version === 0 && data.length === 32)\n return { type: 'wsh', hash: data };\n else if (version === 0 && data.length === 20)\n return { type: 'wpkh', hash: data };\n else if (version === 1 && data.length === 32)\n return { type: 'tr', pubkey: data };\n else\n throw new Error('Unknown witness program');\n }\n const data = base58check.decode(address);\n if (data.length !== 21)\n throw new Error('Invalid base58 address');\n // Pay To Public Key Hash\n if (data[0] === network.pubKeyHash) {\n return { type: 'pkh', hash: data.slice(1) };\n }\n else if (data[0] === network.scriptHash) {\n return {\n type: 'sh',\n hash: data.slice(1),\n };\n }\n throw new Error(`Invalid address prefix=${data[0]}`);\n },\n };\n}\n//# sourceMappingURL=payment.js.map","import * as btc from \"@scure/btc-signer\"\nimport { checkNever } from \"./misc\"\n\nexport type BitcoinNetwork = typeof btc.NETWORK\n\nexport function getBitcoinNetwork(\n network: \"mainnet\" | \"testnet\",\n): BitcoinNetwork {\n if (network === \"mainnet\") return btc.NETWORK\n if (network === \"testnet\") return btc.TEST_NETWORK\n checkNever(network as never)\n return btc.NETWORK\n}\n\nexport function isMainnet(network: BitcoinNetwork): boolean {\n return network.bech32 === \"bc\"\n}\n","import { hex } from \"@scure/base\"\nimport * as btc from \"@scure/btc-signer\"\nimport { Address, OutScript } from \"@scure/btc-signer\"\nimport { BitcoinNetwork, isMainnet } from \"./bitcoinNetworkHelpers\"\n\nexport type AddressTypeKnown = \"p2pkh\" | \"p2sh\" | \"p2wpkh\" | \"p2wsh\" | \"p2tr\"\nexport type AddressType = AddressTypeKnown | \"unknown\"\n\nexport function getAddressType(\n network: BitcoinNetwork,\n address: string,\n): AddressType {\n if (isP2PKHAddress(network, address)) {\n return \"p2pkh\"\n } else if (isP2SHAddress(network, address)) {\n return \"p2sh\"\n } else if (isP2WPKHAddress(network, address)) {\n return \"p2wpkh\"\n } else if (isP2WSHAddress(network, address)) {\n return \"p2wsh\"\n } else if (isP2TRAddress(network, address)) {\n return \"p2tr\"\n } else {\n return \"unknown\"\n }\n}\n\nexport function isP2PKHAddress(\n network: BitcoinNetwork,\n address: string,\n): boolean {\n if (isMainnet(network)) {\n return address.startsWith(\"1\")\n } else {\n return address.startsWith(\"m\") || address.startsWith(\"n\")\n }\n}\n\nexport function isP2SHAddress(\n network: BitcoinNetwork,\n address: string,\n): boolean {\n if (isMainnet(network)) {\n return address.startsWith(\"3\")\n } else {\n return address.startsWith(\"2\")\n }\n}\n\nexport function isP2WPKHAddress(\n network: BitcoinNetwork,\n address: string,\n): boolean {\n if (isMainnet(network)) {\n return address.startsWith(\"bc1q\")\n } else {\n return address.startsWith(\"tb1q\")\n }\n}\n\nexport function isP2TRAddress(\n network: BitcoinNetwork,\n address: string,\n): boolean {\n if (isMainnet(network)) {\n return address.startsWith(\"bc1p\")\n } else {\n return address.startsWith(\"tb1p\")\n }\n}\n\nexport function isP2WSHAddress(\n network: BitcoinNetwork,\n address: string,\n): boolean {\n if (isP2TRAddress(network, address)) {\n return false\n }\n if (isP2WPKHAddress(network, address)) {\n return false\n }\n\n if (isMainnet(network)) {\n return address.startsWith(\"bc1\")\n } else {\n return address.startsWith(\"tb1\")\n }\n}\n\nexport function getP2TRInternalPublicKey(\n network: BitcoinNetwork,\n publicKey: Uint8Array,\n): Uint8Array {\n const ecdsaPublicKeyLength = 33\n if (publicKey.byteLength !== ecdsaPublicKeyLength) {\n throw new Error(\"Invalid public key length\")\n }\n return publicKey.slice(1)\n}\n\nexport function getTapInternalKeyOf_P2TR_publicKey(\n network: BitcoinNetwork,\n publicKey: Uint8Array,\n): Uint8Array {\n return btc.p2tr(\n getP2TRInternalPublicKey(network, publicKey),\n undefined,\n network,\n ).tapInternalKey\n}\n\nexport function getRedeemScriptOf_P2SH_P2WPKH_publicKey(\n network: BitcoinNetwork,\n publicKey: Uint8Array,\n): Uint8Array {\n return btc.p2sh(btc.p2wpkh(publicKey, network), network).redeemScript!\n}\n\nexport function addressToScriptPubKey(\n network: BitcoinNetwork,\n address: string,\n): Uint8Array {\n const addr = Address(network).decode(address)\n return OutScript.encode(addr)\n}\n\nexport function addressToScriptPubKeyHex(\n network: BitcoinNetwork,\n address: string,\n): string {\n return hex.encode(addressToScriptPubKey(network, address))\n}\n","export class BitcoinWalletAdapterError extends Error {\n constructor(message?: string, options?: ErrorOptions) {\n super(message ?? \"Unknown error\", options)\n this.name = \"BitcoinWalletAdapterError\"\n }\n}\n\nexport class UserRejectError extends BitcoinWalletAdapterError {\n constructor(message?: string, options?: ErrorOptions) {\n super(message ?? \"User rejected the operation\", options)\n this.name = \"UserRejectError\"\n }\n}\n","import { hex } from \"@scure/base\"\nimport { Script } from \"@scure/btc-signer\"\nimport {\n addressToScriptPubKeyHex,\n getAddressType,\n} from \"../utils/bitcoinAddressHelpers\"\nimport {\n BitcoinNetwork,\n getBitcoinNetwork,\n isMainnet,\n} from \"../utils/bitcoinNetworkHelpers\"\nimport { BitcoinWalletAdapterError } from \"../utils/error\"\nimport { checkNever } from \"../utils/misc\"\nimport {\n SignMessageResult,\n WalletAdapter,\n WalletAdapter_onAddressesChanged_callback,\n WalletAdapterAddress,\n WalletAdapterAddressPurpose,\n WalletAdapterAddressType,\n WalletAdapterBitcoinNetwork,\n WalletAdapterFactory,\n WalletAdapter_sendBitcoinFeeRateCapability,\n} from \"../WalletAdapters.types\"\n\nconst randomTapInternalKey =\n \"0000000000000000000000000000000000000000000000000000000000000000\"\n\nconst randomPublicKey =\n \"0000000000000000000000000000000000000000000000000000000000000000\"\n\nconst randomRedeemScript = hex.encode(\n Script.encode([\"OP_1\", hex.decode(randomPublicKey), \"OP_1\", \"CHECKMULTISIG\"]),\n)\n\nexport const MockAddressWalletAdapterFactory = (\n network: WalletAdapterBitcoinNetwork,\n mockedAdapter: WalletAdapterFactory,\n mockedAddresses: Partial<{\n bitcoin: Partial & { address: string }\n ordinals: Partial & { address: string }\n }>,\n): WalletAdapterFactory => {\n return {\n adapterId: `mocked.${mockedAdapter.adapterId}`,\n metadata: {\n ...mockedAdapter.metadata,\n name: `Mocked ${mockedAdapter.metadata.name}`,\n },\n getAdapter() {\n const availability = mockedAdapter.getAdapter()\n\n return {\n subscribe(listener) {\n return availability.subscribe(adapter => {\n listener(\n new MockAddressWalletAdapter(network, adapter, mockedAddresses),\n )\n })\n },\n }\n },\n }\n}\n\nclass MockAddressWalletAdapter implements WalletAdapter {\n private network: BitcoinNetwork\n\n constructor(\n network: WalletAdapterBitcoinNetwork,\n private inner: WalletAdapter,\n private addresses: Partial<{\n bitcoin: Partial & { address: string }\n ordinals: Partial & { address: string }\n }>,\n ) {\n this.network =\n network === WalletAdapterBitcoinNetwork.TESTNET\n ? getBitcoinNetwork(\"testnet\")\n : getBitcoinNetwork(\"mainnet\")\n }\n\n async connect(): Promise {\n await this.inner.connect()\n }\n\n async disconnect(): Promise {\n await this.inner.disconnect()\n }\n\n async getAddresses(): Promise {\n const addresses = await this.inner.getAddresses()\n\n const getWalletAdapterAddress = (\n addressName: string,\n info: {\n address: string\n purposes: WalletAdapterAddressPurpose[]\n },\n ): WalletAdapterAddress => {\n const addrType = getAddressType(this.network, info.address)\n\n // prettier-ignore\n const addressType =\n addrType === \"p2tr\" ? WalletAdapterAddressType.P2TR :\n addrType === \"p2sh\" ? WalletAdapterAddressType.P2SH_P2WPKH :\n addrType === \"p2wpkh\" ? WalletAdapterAddressType.P2WPKH :\n addrType === 'p2pkh' ? WalletAdapterAddressType.P2PKH :\n addrType === 'p2wsh' ? undefined /* unsupported */ :\n addrType === 'unknown' ? undefined :\n (checkNever(addrType), undefined)\n\n if (addressType == null) {\n throw new BitcoinWalletAdapterError(\n `[MockAddressWalletAdapter] Please provide a supported ${addressName} address`,\n )\n }\n\n return {\n network: isMainnet(this.network)\n ? WalletAdapterBitcoinNetwork.MAINNET\n : WalletAdapterBitcoinNetwork.TESTNET,\n purposes: info.purposes,\n addressType,\n address: info.address,\n scriptPubKey: addressToScriptPubKeyHex(this.network, info.address),\n publicKey: randomPublicKey,\n redeemScript: randomRedeemScript,\n tapInternalKey: randomTapInternalKey,\n }\n }\n\n let bitcoinAddress: undefined | WalletAdapterAddress\n let ordinalsAddress: undefined | WalletAdapterAddress\n\n if (this.addresses.bitcoin != null) {\n bitcoinAddress = getWalletAdapterAddress(\"bitcoin\", {\n ...this.addresses.bitcoin,\n purposes: [WalletAdapterAddressPurpose.Bitcoin],\n })\n }\n\n if (this.addresses.ordinals != null) {\n ordinalsAddress = getWalletAdapterAddress(\"ordinals\", {\n ...this.addresses.ordinals,\n purposes: [\n WalletAdapterAddressPurpose.Ordinals,\n WalletAdapterAddressPurpose.BRC20,\n WalletAdapterAddressPurpose.Runes,\n ],\n })\n }\n\n return addresses.flatMap(a => {\n const result: WalletAdapterAddress[] = []\n let restPurposes = a.purposes\n\n if (\n bitcoinAddress != null &&\n restPurposes.includes(WalletAdapterAddressPurpose.Bitcoin)\n ) {\n result.push(bitcoinAddress)\n restPurposes = restPurposes.filter(\n p => p !== WalletAdapterAddressPurpose.Bitcoin,\n )\n }\n\n if (\n ordinalsAddress != null &&\n restPurposes.includes(WalletAdapterAddressPurpose.Ordinals)\n ) {\n result.push(ordinalsAddress)\n restPurposes = restPurposes.filter(\n p => p !== WalletAdapterAddressPurpose.Ordinals,\n )\n }\n\n if (restPurposes.length > 0) {\n result.push({ ...a, purposes: restPurposes })\n }\n\n return result\n })\n }\n\n async signMessage(\n address: string,\n message: string,\n ): Promise {\n throw new BitcoinWalletAdapterError(\n `[MockAddressWalletAdapter] it's a mock adapter, can't send inscription`,\n )\n }\n\n signAndFinalizePsbt(psbtHex: string): Promise<{ signedPsbtHex: string }> {\n throw new BitcoinWalletAdapterError(\n `[MockAddressWalletAdapter] it's a mock adapter, can't sign transaction`,\n )\n }\n\n onAddressesChanged(_callback: WalletAdapter_onAddressesChanged_callback): {\n unsubscribe: () => void\n } {\n // Mock adapter doesn't support address change events\n return {\n unsubscribe: () => {\n // No-op\n },\n }\n }\n\n get sendBitcoinFeeRateCapability(): WalletAdapter_sendBitcoinFeeRateCapability {\n return this.inner.sendBitcoinFeeRateCapability\n }\n\n sendBitcoin(\n fromAddress: string,\n receiverAddress: string,\n satoshiAmount: bigint,\n ): Promise<{ txid: string }> {\n throw new BitcoinWalletAdapterError(\n `[MockAddressWalletAdapter] it's a mock adapter, can't send bitcoin`,\n )\n }\n}\n","import type {\n WalletAdapter,\n WalletAdapterFactory,\n WalletAdapterMetadata,\n} from \"../WalletAdapters.types\"\nimport type { UnisatCompatibleProviderAPI } from \"../utils/UnisatCompatibleWalletAdapterImpl\"\nimport { createAvailability } from \"../utils/createAdapterAvailability\"\n\nconst adapterId = \"okxwallet.bitcoin\"\n\nexport const metadata: WalletAdapterMetadata = {\n name: \"OKX Wallet\",\n iconUrl: () => import(\"../_/okx.png\").then(m => m.default),\n websiteUrl: \"https://web3.okx.com/\",\n downloadUrl: \"https://web3.okx.com/download\",\n}\n\nconst availability = createAvailability<\n UnisatCompatibleProviderAPI,\n WalletAdapter\n>({\n getPrecondition: () => {\n const provider = (window as any).okxwallet?.bitcoin as\n | UnisatCompatibleProviderAPI\n | undefined\n return provider == null ? null : { value: provider }\n },\n initializer: async provider => {\n const { OkxWalletAdapterImpl } = await import(\"./OkxWalletAdapter.impl\")\n return new OkxWalletAdapterImpl(provider as any)\n },\n})\n\nexport function OkxWalletAdapterFactory(): WalletAdapterFactory {\n return {\n adapterId,\n metadata,\n getAdapter: () => availability,\n }\n}\n","import { createAvailability } from \"../utils/createAdapterAvailability\"\nimport type { UnisatCompatibleProviderAPI } from \"../utils/UnisatCompatibleWalletAdapterImpl\"\nimport type {\n WalletAdapter,\n WalletAdapterMetadata,\n WalletAdapterFactory,\n} from \"../WalletAdapters.types\"\n\n/**\n * Derivation path (Native SegWit) (BIP-84): m/84'/0'/0'/0/address_index\n * Derivation path (Nested SegWit) (BIP-49): m/49'/0'/0'/0/address_index\n * Derivation path (Taproot) (BIP-86): m/86'/0'/0'/0/address_index\n * Derivation path (Taproot) (BIP-44): m/44'/0'/0'/0/address_index\n * Derivation path (Legacy) (BIP-44): m/44'/0'/0'/0/address_index\n */\n\nconst adapterId = \"unisat\"\n\nexport const metadata: WalletAdapterMetadata = {\n name: \"UniSat\",\n /**\n * https://next-cdn.unisat.io/_/2025-v965/UniSat%20Logo.zip\n */\n iconUrl: () => import(\"../_/unisat.svg\").then(m => m.default),\n websiteUrl: \"https://unisat.io/\",\n downloadUrl: \"https://unisat.io/download\",\n}\n\nconst availability = createAvailability<\n UnisatCompatibleProviderAPI,\n WalletAdapter\n>({\n getPrecondition: () => {\n const provider = (window as any).unisat as\n | UnisatCompatibleProviderAPI\n | undefined\n return provider == null ? null : { value: provider }\n },\n initializer: async provider => {\n const { UnisatWalletAdapterImpl } =\n await import(\"./UnisatWalletAdapter.impl\")\n return new UnisatWalletAdapterImpl(provider)\n },\n})\n\nexport function UnisatWalletAdapterFactory(): WalletAdapterFactory {\n return {\n adapterId,\n metadata,\n getAdapter: () => availability,\n }\n}\n","import type {\n WalletAdapter,\n WalletAdapterFactory,\n WalletAdapterMetadata,\n} from \"../WalletAdapters.types\"\nimport { createAvailability } from \"../utils/createAdapterAvailability\"\n\nexport const XVERSE_PROVIDER_ID = \"XverseProviders.BitcoinProvider\"\n\nexport const metadata: WalletAdapterMetadata = {\n name: \"Xverse\",\n iconUrl: () => import(\"../_/xverse.png\").then(m => m.default),\n websiteUrl: \"https://xverse.app/\",\n downloadUrl: \"https://www.xverse.app/download\",\n}\n\nconst availability = createAvailability<\n import(\"sats-connect\").Provider,\n WalletAdapter\n>({\n getPrecondition: () => {\n const provider = (window.btc_providers ?? []).find(\n p => p.id === XVERSE_PROVIDER_ID,\n )\n return provider == null ? null : { value: provider }\n },\n initializer: async () => {\n const { XverseWalletAdapterImpl } =\n await import(\"./XverseWalletAdapter.impl\")\n return new XverseWalletAdapterImpl()\n },\n})\n\nexport function XverseWalletAdapterFactory(): WalletAdapterFactory {\n return {\n adapterId: XVERSE_PROVIDER_ID,\n metadata,\n getAdapter: () => availability,\n }\n}\n"],"names":["createAvailability","getPrecondition","initializer","pollIntervalMs","cachedAdapter","polling","creating","listeners","stopPolling","emit","adapter","listener","attemptCreate","precondition","error","ensurePolling","adapterId","metadata","m","availability","provider","BitgetWalletAdapterImpl","BitgetWalletAdapterFactory","request","LeatherWalletAdapterImpl","LeatherWalletAdapterFactory","MAGICEDEN_PROVIDER_ID","buildAvailability","network","MagicEdenWalletAdapterImpl","MagicEdenWalletAdapterFactory","options","isBytes","a","abytes","b","isArrayOf","isString","arr","item","afn","input","astr","label","anumber","n","aArr","astrArr","anumArr","chain","args","id","wrap","encode","x","decode","alphabet","letters","lettersA","len","indexes","l","i","digits","letter","join","separator","from","to","padding","bits","chr","data","end","normalize","fn","convertRadix","pos","res","d","dlen","carry","done","digit","fromCarry","digitBase","div","rounded","gcd","radix2carry","powers","convertRadix2","max","mask","pow","radix","num","_256","bytes","radix2","revPadding","unsafeWrapper","checksum","sum","payload","oldChecksum","newChecksum","hasBase64Builtin","decodeBase64Builtin","s","isUrl","re","base64","genBase58","abc","base58","createBase58check","sha256","BECH_ALPHABET","POLYMOD_GENERATORS","bech32Polymod","pre","chk","bechChecksum","prefix","words","encodingConst","c","v","genBech32","encoding","ENCODING_CONST","_words","fromWords","toWords","fromWordsUnsafe","limit","plen","actualLength","lowered","str","slen","sepIndex","decodeUnsafe","decodeToBytes","encodeFromBytes","bech32","bech32m","utf8","hasHexBuiltin","hexBuiltin","hex","title","value","length","needsLen","ofLen","got","ahash","h","aexists","instance","checkFinished","aoutput","out","min","clean","arrays","createView","rotr","word","shift","rotl","hexes","_","bytesToHex","asciis","asciiToBase16","ch","hexToBytes","hl","al","array","ai","hi","n1","n2","char","concatBytes","pad","createHasher","hashCons","info","hashC","msg","opts","tmp","randomBytes","bytesLength","cr","oidNist","suffix","Chi","Maj","HashMD","blockLen","outputLen","padOffset","isLE","view","buffer","take","dataView","oview","outLen","state","finished","destroyed","SHA256_IV","SHA256_K","SHA256_W","SHA2_32B","A","B","C","D","E","F","G","H","offset","W15","W2","s0","s1","sigma1","T1","T2","_SHA256","_0n","_1n","abool","abignumber","isPosBig","numberToHexUnpadded","hexToNumber","bytesToNumberBE","bytesToHex_","bytesToNumberLE","copyBytes","abytes_","numberToBytesBE","hexToBytes_","numberToBytesLE","asciiToBytes","ascii","charCode","inRange","aInRange","bitLen","bitMask","createHmacDrbg","hashLen","qByteLen","hmacFn","u8n","NULL","byte0","byte1","_maxDrbgIters","k","reset","msgs","concatBytes_","reseed","seed","gen","sl","pred","validateObject","object","fields","optFields","checkField","fieldName","expectedType","isOpt","val","current","iter","f","memoized","map","arg","computed","_2n","_3n","_4n","_5n","_7n","_8n","_9n","_16n","mod","result","pow2","power","modulo","invert","number","u","q","r","assertIsSquare","Fp","root","sqrt3mod4","p1div4","sqrt5mod8","p5div8","nv","sqrt9mod16","P","Fp_","Field","tn","tonelliShanks","c1","c2","c3","c4","tv1","tv2","tv3","tv4","e1","e2","e3","Q","S","Z","_Fp","FpLegendre","cc","Q1div2","M","t","R","t_tmp","exponent","FpSqrt","FIELD_FIELDS","validateField","field","initial","FpPow","p","FpInvertBatch","nums","passZero","inverted","multipliedAcc","acc","invertedAcc","p1mod2","powered","yes","zero","no","nLength","nBitLength","_nBitLength","nByteLength","_Field","ORDER","_nbitLength","lhs","rhs","skipValidation","allowedLengths","BYTES","modFromBytes","padded","scalar","lst","condition","getFieldBytesLength","fieldOrder","bitLength","getMinHashLength","mapHashToField","key","fieldLen","minLen","reduced","negateCt","neg","normalizeZ","points","invertedZs","validateW","W","calcWOpts","scalarBits","windows","windowSize","maxNumber","shiftBy","calcOffsets","window","wOpts","wbits","nextN","offsetStart","isZero","isNeg","isNegF","pointPrecomputes","pointWindowSizes","getW","assert0","wNAF","Point","elm","point","base","precomputes","wo","offsetF","transform","comp","prev","mulEndoUnsafe","k1","k2","p1","p2","createField","order","createCurveFields","type","CURVE","curveOpts","FpFnLE","Fn","params","createKeygen","randomSecretKey","getPublicKey","secretKey","_HMAC","hash","buf","oHash","iHash","hmac","message","divNearest","den","_splitEndoScalar","basis","a1","b1","a2","b2","k1neg","k2neg","MAX_NUM","validateSigFormat","format","validateSigOpts","def","optsn","optName","DERErr","DER","tag","dataLen","lenLen","first","isLong","lengthBytes","int","tlv","seqBytes","seqLeftBytes","rBytes","rLeftBytes","sBytes","sLeftBytes","sig","rs","ss","seq","weierstrass","extraOpts","validated","cofactor","CURVE_ORDER","endo","lengths","getWLengths","assertCompressionIsSupported","pointToBytes","_c","isCompressed","y","bx","hasEvenY","pprefix","pointFromBytes","uncomp","head","tail","y2","weierstrassEquation","sqrtError","err","evenY","L","isValidXY","encodePoint","decodePoint","x2","x3","left","right","_4a3","_27b2","acoord","banZero","aprjpoint","other","splitEndoScalarN","toAffineMemo","iz","X","Y","is0","zz","assertValidMemo","finishEndo","endoBeta","k1p","k2p","isLazy","wnaf","X1","Y1","Z1","X2","Y2","Z2","U1","U2","b3","X3","Y3","Z3","t0","t1","t2","t3","t4","t5","fake","mul","k1f","k2f","sc","invertedZ","isTorsionFree","clearCofactor","ecdh","ecdhOpts","randomBytes_","wcRandomBytes","isValidSecretKey","isValidPublicKey","publicKey","publicKeyUncompressed","isProbPub","getSharedSecret","secretKeyA","publicKeyB","utils","keygen","ecdsa","ecdsaOpts","nobleHmac","fnBits","defaultSigOpts","hasLargeCofactor","isBiggerThanHalfOrder","HALF","validateRS","assertSmallCofactor","validateSigLength","size","sizer","Signature","recovery","recid","messageHash","radj","ir","bits2int_modN","u1","u2","rb","sb","bits2int","delta","ORDER_MASK","int2octets","validateMsgAndHash","prehash","prepSig","lowS","extraEntropy","h1int","seedArgs","e","k2sig","kBytes","ik","normS","sign","verify","signature","is","recoverPublicKey","secp256k1_CURVE","secp256k1_ENDO","sqrtMod","_6n","_11n","_22n","_23n","_44n","_88n","b6","b9","b11","b22","b44","b88","b176","b220","b223","Fpk1","Pointk1","secp256k1","TAGGED_HASH_PREFIXES","taggedHash","messages","tagP","tagH","hasEven","schnorrGetExtPubKey","priv","BASE","d_","lift_x","xx","challenge","schnorrGetPublicKey","schnorrSign","auxRand","px","rand","rx","schnorrVerify","pub","schnorr","Rho160","Id160","Pi160","idxLR","j","idxL","idxR","shifts160","shiftsL160","idx","shiftsR160","Kl160","Kr160","ripemd_f","group","z","BUF_160","_RIPEMD160","h0","h1","h2","h3","h4","ar","bl","br","cl","dl","dr","el","er","rGroup","hbl","hbr","rl","rr","sr","tl","tr","ripemd160","EMPTY","equalBytes","isPlainObject","obj","isNum","lengthCoder","isCoder","w","byteLen","Path","Bitset","bs","bsLen","chunk","allowRewrite","FULL_MASK","BITS","lastMask","cur","lastPos","last","start","stack","objFn","fieldFn","name","path","parts","objPath","_Reader","parent","parentOffset","baseHex","notRead","formatted","peek","slice","needle","_Writer","buffers","ptr","swapEndianness","checkBounds","signed","signBit","_wrap","inner","validate","isBaseCoder","dict","numberBigint","tsEnum","decimal","precision","round","decimalMask","sep","frac","intS","fracS","fracLen","match","reverse","coder","coders","bigint","le","sized","bLen","U256BE","U64LE","I64LE","intView","validateSigned","maxVal","validateUnsigned","U32LE","U32BE","I32LE","U16LE","U8","createBytes","_length","_isb","tPos","apply","string","createHex","innerValue","flag","flagValue","xor","hasFlag","flagged","magic","constant","check","_value","sizeof","struct","tuple","_w","startPos","secp","packedUtils","hash160","sha256x2","pubSchnorr","pubECDSA","hasLowR","signECDSA","privateKey","lowR","counter","signSchnorr","tagSchnorr","PubT","validatePubkey","tapTweak","taprootTweakPrivKey","privKey","merkleRoot","seckey0","seckey","xP","taprootTweakPubkey","pubKey","parity","TAPROOT_UNSPENDABLE_KEY","NETWORK","TEST_NETWORK","compareBytes","reverseObject","OP","OPNames","ScriptNum","bytesLimit","forceMinimal","P.wrap","abs","OpToNum","op","Script","o","P.U16LE","P.U32LE","P.U8","CSLimits","CompactSize","stop","b0","CompactSizeLen","P.apply","P.coders","VarBytes","P.bytes","RawWitness","P.array","BTCArray","RawInput","P.struct","RawOutput","P.U64LE","_RawTx","P.I32LE","P.flag","P.flagged","validateRawTx","tx","RawTx","P.validate","RawOldTx","OutP2A","u.isBytes","isValidPubkey","u.validatePubkey","OutPK","u.PubT","OutPKH","OutSH","OutWSH","OutWPKH","OutMS","pubkeys","OutTR","OutTRNS","OutTRMS","OutUnknown","OutScripts","_OutScript","OutScript","checkWSH","witnessScript","u.equalBytes","u.sha256","checkScript","script","redeemScript","u.hash160","p2sh","child","cs","Address","p2wpkh","TAP_LEAF_VERSION","tapLeafHash","version","u.tagSchnorr","p2tr","internalPubKey","tree","allowUnknownOutputs","customScripts","u.TAPROOT_UNSPENDABLE_KEY","tweakedPubkey","u.taprootTweakPubkey","P.EMPTY","base58check","validateWitness","programToWitness","formatKey","hashed","u.concatBytes","address","program","getBitcoinNetwork","btc.NETWORK","btc.TEST_NETWORK","isMainnet","getAddressType","isP2PKHAddress","isP2SHAddress","isP2WPKHAddress","isP2WSHAddress","isP2TRAddress","getP2TRInternalPublicKey","getTapInternalKeyOf_P2TR_publicKey","btc.p2tr","getRedeemScriptOf_P2SH_P2WPKH_publicKey","btc.p2sh","btc.p2wpkh","addressToScriptPubKey","addr","addressToScriptPubKeyHex","BitcoinWalletAdapterError","UserRejectError","randomTapInternalKey","randomPublicKey","randomRedeemScript","MockAddressWalletAdapterFactory","mockedAdapter","mockedAddresses","MockAddressWalletAdapter","addresses","WalletAdapterBitcoinNetwork","getWalletAdapterAddress","addressName","addrType","addressType","WalletAdapterAddressType","bitcoinAddress","ordinalsAddress","WalletAdapterAddressPurpose","restPurposes","psbtHex","_callback","fromAddress","receiverAddress","satoshiAmount","OkxWalletAdapterImpl","OkxWalletAdapterFactory","UnisatWalletAdapterImpl","UnisatWalletAdapterFactory","XVERSE_PROVIDER_ID","XverseWalletAdapterImpl","XverseWalletAdapterFactory"],"mappings":"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","x_google_ignoreList":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]}