{"version":3,"file":"accounts-CgUUF-_i.mjs","names":["normalize","secp","hexToBytes","generateMnemonic","baseUtils","generateMnemonic_"],"sources":["../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/legacy.js","../../../node_modules/.pnpm/@scure+base@1.2.6/node_modules/@scure/base/lib/esm/index.js","../../../node_modules/.pnpm/@scure+bip32@1.7.0/node_modules/@scure/bip32/lib/esm/index.js","../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/pbkdf2.js","../../../node_modules/.pnpm/@scure+bip39@1.6.0/node_modules/@scure/bip39/esm/index.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/generateMnemonic.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/generatePrivateKey.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/toAccount.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/utils/sign.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/utils/signAuthorization.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/utils/signMessage.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/utils/signTransaction.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/utils/signTypedData.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/privateKeyToAccount.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/hdKeyToAccount.js","../../../node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_esm/accounts/mnemonicToAccount.js"],"sourcesContent":["/**\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://datatracker.ietf.org/doc/html/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/** SHA1 legacy hash class. */\nexport class SHA1 extends HashMD {\n    constructor() {\n        super(64, 20, 8, false);\n        this.A = SHA1_IV[0] | 0;\n        this.B = SHA1_IV[1] | 0;\n        this.C = SHA1_IV[2] | 0;\n        this.D = SHA1_IV[3] | 0;\n        this.E = SHA1_IV[4] | 0;\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/** MD5 legacy hash class. */\nexport class MD5 extends HashMD {\n    constructor() {\n        super(64, 16, 8, true);\n        this.A = MD5_IV[0] | 0;\n        this.B = MD5_IV[1] | 0;\n        this.C = MD5_IV[2] | 0;\n        this.D = MD5_IV[3] | 0;\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    constructor() {\n        super(64, 20, 8, true);\n        this.h0 = 0x67452301 | 0;\n        this.h1 = 0xefcdab89 | 0;\n        this.h2 = 0x98badcfe | 0;\n        this.h3 = 0x10325476 | 0;\n        this.h4 = 0xc3d2e1f0 | 0;\n    }\n    get() {\n        const { h0, h1, h2, h3, h4 } = this;\n        return [h0, h1, h2, h3, h4];\n    }\n    set(h0, h1, h2, h3, h4) {\n        this.h0 = h0 | 0;\n        this.h1 = h1 | 0;\n        this.h2 = h2 | 0;\n        this.h3 = h3 | 0;\n        this.h4 = h4 | 0;\n    }\n    process(view, offset) {\n        for (let i = 0; i < 16; i++, offset += 4)\n            BUF_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","/*! 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, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Uint8Array expected');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\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}\n// no abytes: seems to have 10% slowdown. Why?!\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 * @module BIP32 hierarchical deterministic (HD) wallets over secp256k1.\n * @example\n * ```js\n * import { HDKey } from \"@scure/bip32\";\n * const hdkey1 = HDKey.fromMasterSeed(seed);\n * const hdkey2 = HDKey.fromExtendedKey(base58key);\n * const hdkey3 = HDKey.fromJSON({ xpriv: string });\n *\n * // props\n * [hdkey1.depth, hdkey1.index, hdkey1.chainCode];\n * console.log(hdkey2.privateKey, hdkey2.publicKey);\n * console.log(hdkey3.derive(\"m/0/2147483647'/1\"));\n * const sig = hdkey3.sign(hash);\n * hdkey3.verify(hash, sig);\n * ```\n */\n/*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport { mod } from '@noble/curves/abstract/modular';\nimport { secp256k1 as secp } from '@noble/curves/secp256k1';\nimport { hmac } from '@noble/hashes/hmac';\nimport { ripemd160 } from '@noble/hashes/legacy';\nimport { sha256, sha512 } from '@noble/hashes/sha2';\nimport { abytes, bytesToHex, concatBytes, createView, hexToBytes, utf8ToBytes, } from '@noble/hashes/utils';\nimport { createBase58check } from '@scure/base';\nconst Point = secp.ProjectivePoint;\nconst base58check = createBase58check(sha256);\nfunction bytesToNumber(bytes) {\n    abytes(bytes);\n    const h = bytes.length === 0 ? '0' : bytesToHex(bytes);\n    return BigInt('0x' + h);\n}\nfunction numberToBytes(num) {\n    if (typeof num !== 'bigint')\n        throw new Error('bigint expected');\n    return hexToBytes(num.toString(16).padStart(64, '0'));\n}\nconst MASTER_SECRET = utf8ToBytes('Bitcoin seed');\n// Bitcoin hardcoded by default\nconst BITCOIN_VERSIONS = { private: 0x0488ade4, public: 0x0488b21e };\nexport const HARDENED_OFFSET = 0x80000000;\nconst hash160 = (data) => ripemd160(sha256(data));\nconst fromU32 = (data) => createView(data).getUint32(0, false);\nconst toU32 = (n) => {\n    if (!Number.isSafeInteger(n) || n < 0 || n > 2 ** 32 - 1) {\n        throw new Error('invalid number, should be from 0 to 2**32-1, got ' + n);\n    }\n    const buf = new Uint8Array(4);\n    createView(buf).setUint32(0, n, false);\n    return buf;\n};\nexport class HDKey {\n    get fingerprint() {\n        if (!this.pubHash) {\n            throw new Error('No publicKey set!');\n        }\n        return fromU32(this.pubHash);\n    }\n    get identifier() {\n        return this.pubHash;\n    }\n    get pubKeyHash() {\n        return this.pubHash;\n    }\n    get privateKey() {\n        return this.privKeyBytes || null;\n    }\n    get publicKey() {\n        return this.pubKey || null;\n    }\n    get privateExtendedKey() {\n        const priv = this.privateKey;\n        if (!priv) {\n            throw new Error('No private key');\n        }\n        return base58check.encode(this.serialize(this.versions.private, concatBytes(new Uint8Array([0]), priv)));\n    }\n    get publicExtendedKey() {\n        if (!this.pubKey) {\n            throw new Error('No public key');\n        }\n        return base58check.encode(this.serialize(this.versions.public, this.pubKey));\n    }\n    static fromMasterSeed(seed, versions = BITCOIN_VERSIONS) {\n        abytes(seed);\n        if (8 * seed.length < 128 || 8 * seed.length > 512) {\n            throw new Error('HDKey: seed length must be between 128 and 512 bits; 256 bits is advised, got ' +\n                seed.length);\n        }\n        const I = hmac(sha512, MASTER_SECRET, seed);\n        return new HDKey({\n            versions,\n            chainCode: I.slice(32),\n            privateKey: I.slice(0, 32),\n        });\n    }\n    static fromExtendedKey(base58key, versions = BITCOIN_VERSIONS) {\n        // => version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)\n        const keyBuffer = base58check.decode(base58key);\n        const keyView = createView(keyBuffer);\n        const version = keyView.getUint32(0, false);\n        const opt = {\n            versions,\n            depth: keyBuffer[4],\n            parentFingerprint: keyView.getUint32(5, false),\n            index: keyView.getUint32(9, false),\n            chainCode: keyBuffer.slice(13, 45),\n        };\n        const key = keyBuffer.slice(45);\n        const isPriv = key[0] === 0;\n        if (version !== versions[isPriv ? 'private' : 'public']) {\n            throw new Error('Version mismatch');\n        }\n        if (isPriv) {\n            return new HDKey({ ...opt, privateKey: key.slice(1) });\n        }\n        else {\n            return new HDKey({ ...opt, publicKey: key });\n        }\n    }\n    static fromJSON(json) {\n        return HDKey.fromExtendedKey(json.xpriv);\n    }\n    constructor(opt) {\n        this.depth = 0;\n        this.index = 0;\n        this.chainCode = null;\n        this.parentFingerprint = 0;\n        if (!opt || typeof opt !== 'object') {\n            throw new Error('HDKey.constructor must not be called directly');\n        }\n        this.versions = opt.versions || BITCOIN_VERSIONS;\n        this.depth = opt.depth || 0;\n        this.chainCode = opt.chainCode || null;\n        this.index = opt.index || 0;\n        this.parentFingerprint = opt.parentFingerprint || 0;\n        if (!this.depth) {\n            if (this.parentFingerprint || this.index) {\n                throw new Error('HDKey: zero depth with non-zero index/parent fingerprint');\n            }\n        }\n        if (opt.publicKey && opt.privateKey) {\n            throw new Error('HDKey: publicKey and privateKey at same time.');\n        }\n        if (opt.privateKey) {\n            if (!secp.utils.isValidPrivateKey(opt.privateKey)) {\n                throw new Error('Invalid private key');\n            }\n            this.privKey =\n                typeof opt.privateKey === 'bigint' ? opt.privateKey : bytesToNumber(opt.privateKey);\n            this.privKeyBytes = numberToBytes(this.privKey);\n            this.pubKey = secp.getPublicKey(opt.privateKey, true);\n        }\n        else if (opt.publicKey) {\n            this.pubKey = Point.fromHex(opt.publicKey).toRawBytes(true); // force compressed point\n        }\n        else {\n            throw new Error('HDKey: no public or private key provided');\n        }\n        this.pubHash = hash160(this.pubKey);\n    }\n    derive(path) {\n        if (!/^[mM]'?/.test(path)) {\n            throw new Error('Path must start with \"m\" or \"M\"');\n        }\n        if (/^[mM]'?$/.test(path)) {\n            return this;\n        }\n        const parts = path.replace(/^[mM]'?\\//, '').split('/');\n        // tslint:disable-next-line\n        let child = this;\n        for (const c of parts) {\n            const m = /^(\\d+)('?)$/.exec(c);\n            const m1 = m && m[1];\n            if (!m || m.length !== 3 || typeof m1 !== 'string')\n                throw new Error('invalid child index: ' + c);\n            let idx = +m1;\n            if (!Number.isSafeInteger(idx) || idx >= HARDENED_OFFSET) {\n                throw new Error('Invalid index');\n            }\n            // hardened key\n            if (m[2] === \"'\") {\n                idx += HARDENED_OFFSET;\n            }\n            child = child.deriveChild(idx);\n        }\n        return child;\n    }\n    deriveChild(index) {\n        if (!this.pubKey || !this.chainCode) {\n            throw new Error('No publicKey or chainCode set');\n        }\n        let data = toU32(index);\n        if (index >= HARDENED_OFFSET) {\n            // Hardened\n            const priv = this.privateKey;\n            if (!priv) {\n                throw new Error('Could not derive hardened child key');\n            }\n            // Hardened child: 0x00 || ser256(kpar) || ser32(index)\n            data = concatBytes(new Uint8Array([0]), priv, data);\n        }\n        else {\n            // Normal child: serP(point(kpar)) || ser32(index)\n            data = concatBytes(this.pubKey, data);\n        }\n        const I = hmac(sha512, this.chainCode, data);\n        const childTweak = bytesToNumber(I.slice(0, 32));\n        const chainCode = I.slice(32);\n        if (!secp.utils.isValidPrivateKey(childTweak)) {\n            throw new Error('Tweak bigger than curve order');\n        }\n        const opt = {\n            versions: this.versions,\n            chainCode,\n            depth: this.depth + 1,\n            parentFingerprint: this.fingerprint,\n            index,\n        };\n        try {\n            // Private parent key -> private child key\n            if (this.privateKey) {\n                const added = mod(this.privKey + childTweak, secp.CURVE.n);\n                if (!secp.utils.isValidPrivateKey(added)) {\n                    throw new Error('The tweak was out of range or the resulted private key is invalid');\n                }\n                opt.privateKey = added;\n            }\n            else {\n                const added = Point.fromHex(this.pubKey).add(Point.fromPrivateKey(childTweak));\n                // Cryptographically impossible: hmac-sha512 preimage would need to be found\n                if (added.equals(Point.ZERO)) {\n                    throw new Error('The tweak was equal to negative P, which made the result key invalid');\n                }\n                opt.publicKey = added.toRawBytes(true);\n            }\n            return new HDKey(opt);\n        }\n        catch (err) {\n            return this.deriveChild(index + 1);\n        }\n    }\n    sign(hash) {\n        if (!this.privateKey) {\n            throw new Error('No privateKey set!');\n        }\n        abytes(hash, 32);\n        return secp.sign(hash, this.privKey).toCompactRawBytes();\n    }\n    verify(hash, signature) {\n        abytes(hash, 32);\n        abytes(signature, 64);\n        if (!this.publicKey) {\n            throw new Error('No publicKey set!');\n        }\n        let sig;\n        try {\n            sig = secp.Signature.fromCompact(signature);\n        }\n        catch (error) {\n            return false;\n        }\n        return secp.verify(sig, hash, this.publicKey);\n    }\n    wipePrivateData() {\n        this.privKey = undefined;\n        if (this.privKeyBytes) {\n            this.privKeyBytes.fill(0);\n            this.privKeyBytes = undefined;\n        }\n        return this;\n    }\n    toJSON() {\n        return {\n            xpriv: this.privateExtendedKey,\n            xpub: this.publicExtendedKey,\n        };\n    }\n    serialize(version, key) {\n        if (!this.chainCode) {\n            throw new Error('No chainCode set');\n        }\n        abytes(key, 33);\n        // version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)\n        return concatBytes(toU32(version), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key);\n    }\n}\n//# sourceMappingURL=index.js.map","/**\n * PBKDF (RFC 2898). Can be used to create a key from password and salt.\n * @module\n */\nimport { hmac } from \"./hmac.js\";\n// prettier-ignore\nimport { ahash, anumber, asyncLoop, checkOpts, clean, createView, Hash, kdfInputToBytes } from \"./utils.js\";\n// Common prologue and epilogue for sync/async functions\nfunction pbkdf2Init(hash, _password, _salt, _opts) {\n    ahash(hash);\n    const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);\n    const { c, dkLen, asyncTick } = opts;\n    anumber(c);\n    anumber(dkLen);\n    anumber(asyncTick);\n    if (c < 1)\n        throw new Error('iterations (c) should be >= 1');\n    const password = kdfInputToBytes(_password);\n    const salt = kdfInputToBytes(_salt);\n    // DK = PBKDF2(PRF, Password, Salt, c, dkLen);\n    const DK = new Uint8Array(dkLen);\n    // U1 = PRF(Password, Salt + INT_32_BE(i))\n    const PRF = hmac.create(hash, password);\n    const PRFSalt = PRF._cloneInto().update(salt);\n    return { c, dkLen, asyncTick, DK, PRF, PRFSalt };\n}\nfunction pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {\n    PRF.destroy();\n    PRFSalt.destroy();\n    if (prfW)\n        prfW.destroy();\n    clean(u);\n    return DK;\n}\n/**\n * PBKDF2-HMAC: RFC 2898 key derivation function\n * @param hash - hash function that would be used e.g. sha256\n * @param password - password from which a derived key is generated\n * @param salt - cryptographic salt\n * @param opts - {c, dkLen} where c is work factor and dkLen is output message size\n * @example\n * const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });\n */\nexport function pbkdf2(hash, password, salt, opts) {\n    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);\n    let prfW; // Working copy\n    const arr = new Uint8Array(4);\n    const view = createView(arr);\n    const u = new Uint8Array(PRF.outputLen);\n    // DK = T1 + T2 + ⋯ + Tdklen/hlen\n    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {\n        // Ti = F(Password, Salt, c, i)\n        const Ti = DK.subarray(pos, pos + PRF.outputLen);\n        view.setInt32(0, ti, false);\n        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc\n        // U1 = PRF(Password, Salt + INT_32_BE(i))\n        (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);\n        Ti.set(u.subarray(0, Ti.length));\n        for (let ui = 1; ui < c; ui++) {\n            // Uc = PRF(Password, Uc−1)\n            PRF._cloneInto(prfW).update(u).digestInto(u);\n            for (let i = 0; i < Ti.length; i++)\n                Ti[i] ^= u[i];\n        }\n    }\n    return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);\n}\n/**\n * PBKDF2-HMAC: RFC 2898 key derivation function. Async version.\n * @example\n * await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });\n */\nexport async function pbkdf2Async(hash, password, salt, opts) {\n    const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);\n    let prfW; // Working copy\n    const arr = new Uint8Array(4);\n    const view = createView(arr);\n    const u = new Uint8Array(PRF.outputLen);\n    // DK = T1 + T2 + ⋯ + Tdklen/hlen\n    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {\n        // Ti = F(Password, Salt, c, i)\n        const Ti = DK.subarray(pos, pos + PRF.outputLen);\n        view.setInt32(0, ti, false);\n        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc\n        // U1 = PRF(Password, Salt + INT_32_BE(i))\n        (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);\n        Ti.set(u.subarray(0, Ti.length));\n        await asyncLoop(c - 1, asyncTick, () => {\n            // Uc = PRF(Password, Uc−1)\n            PRF._cloneInto(prfW).update(u).digestInto(u);\n            for (let i = 0; i < Ti.length; i++)\n                Ti[i] ^= u[i];\n        });\n    }\n    return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);\n}\n//# sourceMappingURL=pbkdf2.js.map","/**\n * Audited & minimal JS implementation of\n * [BIP39 mnemonic phrases](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).\n * @module\n * @example\n```js\nimport * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english';\nconst mn = bip39.generateMnemonic(wordlist);\nconsole.log(mn);\nconst ent = bip39.mnemonicToEntropy(mn, wordlist)\nbip39.entropyToMnemonic(ent, wordlist);\nbip39.validateMnemonic(mn, wordlist);\nawait bip39.mnemonicToSeed(mn, 'password');\nbip39.mnemonicToSeedSync(mn, 'password');\n\n// Wordlists\nimport { wordlist as czech } from '@scure/bip39/wordlists/czech';\nimport { wordlist as english } from '@scure/bip39/wordlists/english';\nimport { wordlist as french } from '@scure/bip39/wordlists/french';\nimport { wordlist as italian } from '@scure/bip39/wordlists/italian';\nimport { wordlist as japanese } from '@scure/bip39/wordlists/japanese';\nimport { wordlist as korean } from '@scure/bip39/wordlists/korean';\nimport { wordlist as portuguese } from '@scure/bip39/wordlists/portuguese';\nimport { wordlist as simplifiedChinese } from '@scure/bip39/wordlists/simplified-chinese';\nimport { wordlist as spanish } from '@scure/bip39/wordlists/spanish';\nimport { wordlist as traditionalChinese } from '@scure/bip39/wordlists/traditional-chinese';\n```\n */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2';\nimport { sha256, sha512 } from '@noble/hashes/sha2';\nimport { abytes, anumber, randomBytes } from '@noble/hashes/utils';\nimport { utils as baseUtils } from '@scure/base';\n// Japanese wordlist\nconst isJapanese = (wordlist) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304f\\u3057\\u3093';\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\n// https://tonsky.me/blog/unicode/#why-is-a----\nfunction nfkd(str) {\n    if (typeof str !== 'string')\n        throw new TypeError('invalid mnemonic type: ' + typeof str);\n    return str.normalize('NFKD');\n}\nfunction normalize(str) {\n    const norm = nfkd(str);\n    const words = norm.split(' ');\n    if (![12, 15, 18, 21, 24].includes(words.length))\n        throw new Error('Invalid mnemonic');\n    return { nfkd: norm, words };\n}\nfunction aentropy(ent) {\n    abytes(ent, 16, 20, 24, 28, 32);\n}\n/**\n * Generate x random words. Uses Cryptographically-Secure Random Number Generator.\n * @param wordlist imported wordlist for specific language\n * @param strength mnemonic strength 128-256 bits\n * @example\n * generateMnemonic(wordlist, 128)\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\nexport function generateMnemonic(wordlist, strength = 128) {\n    anumber(strength);\n    if (strength % 32 !== 0 || strength > 256)\n        throw new TypeError('Invalid entropy');\n    return entropyToMnemonic(randomBytes(strength / 8), wordlist);\n}\nconst calcChecksum = (entropy) => {\n    // Checksum is ent.length/4 bits long\n    const bitsLeft = 8 - entropy.length / 4;\n    // Zero rightmost \"bitsLeft\" bits in byte\n    // For example: bitsLeft=4 val=10111101 -> 10110000\n    return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft]);\n};\nfunction getCoder(wordlist) {\n    if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n        throw new Error('Wordlist: expected array of 2048 strings');\n    wordlist.forEach((i) => {\n        if (typeof i !== 'string')\n            throw new Error('wordlist: non-string element: ' + i);\n    });\n    return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist));\n}\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\nexport function mnemonicToEntropy(mnemonic, wordlist) {\n    const { words } = normalize(mnemonic);\n    const entropy = getCoder(wordlist).decode(words);\n    aentropy(entropy);\n    return entropy;\n}\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\nexport function entropyToMnemonic(entropy, wordlist) {\n    aentropy(entropy);\n    const words = getCoder(wordlist).encode(entropy);\n    return words.join(isJapanese(wordlist) ? '\\u3000' : ' ');\n}\n/**\n * Validates mnemonic for being 12-24 words contained in `wordlist`.\n */\nexport function validateMnemonic(mnemonic, wordlist) {\n    try {\n        mnemonicToEntropy(mnemonic, wordlist);\n    }\n    catch (e) {\n        return false;\n    }\n    return true;\n}\nconst psalt = (passphrase) => nfkd('mnemonic' + passphrase);\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\nexport function mnemonicToSeed(mnemonic, passphrase = '') {\n    return pbkdf2Async(sha512, normalize(mnemonic).nfkd, psalt(passphrase), { c: 2048, dkLen: 64 });\n}\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\nexport function mnemonicToSeedSync(mnemonic, passphrase = '') {\n    return pbkdf2(sha512, normalize(mnemonic).nfkd, psalt(passphrase), { c: 2048, dkLen: 64 });\n}\n","import { generateMnemonic as generateMnemonic_ } from '@scure/bip39';\n/**\n * @description Generates a random mnemonic phrase with a given wordlist.\n *\n * @param wordlist The wordlist to use for generating the mnemonic phrase.\n * @param strength mnemonic strength 128-256 bits\n *\n * @returns A randomly generated mnemonic phrase.\n */\nexport function generateMnemonic(wordlist, strength) {\n    return generateMnemonic_(wordlist, strength);\n}\n//# sourceMappingURL=generateMnemonic.js.map","import { secp256k1 } from '@noble/curves/secp256k1';\nimport { toHex } from '../utils/encoding/toHex.js';\n/**\n * @description Generates a random private key.\n *\n * @returns A randomly generated private key.\n */\nexport function generatePrivateKey() {\n    return toHex(secp256k1.utils.randomPrivateKey());\n}\n//# sourceMappingURL=generatePrivateKey.js.map","// TODO(v3): Rename to `toLocalAccount` + add `source` property to define source (privateKey, mnemonic, hdKey, etc).\nimport { InvalidAddressError, } from '../errors/address.js';\nimport { isAddress, } from '../utils/address/isAddress.js';\n/**\n * @description Creates an Account from a custom signing implementation.\n *\n * @returns A Local Account.\n */\nexport function toAccount(source) {\n    if (typeof source === 'string') {\n        if (!isAddress(source, { strict: false }))\n            throw new InvalidAddressError({ address: source });\n        return {\n            address: source,\n            type: 'json-rpc',\n        };\n    }\n    if (!isAddress(source.address, { strict: false }))\n        throw new InvalidAddressError({ address: source.address });\n    return {\n        address: source.address,\n        nonceManager: source.nonceManager,\n        sign: source.sign,\n        signAuthorization: source.signAuthorization,\n        signMessage: source.signMessage,\n        signTransaction: source.signTransaction,\n        signTypedData: source.signTypedData,\n        source: 'custom',\n        type: 'local',\n    };\n}\n//# sourceMappingURL=toAccount.js.map","// TODO(v3): Convert to sync.\nimport { secp256k1 } from '@noble/curves/secp256k1';\nimport { isHex } from '../../utils/data/isHex.js';\nimport { hexToBytes, } from '../../utils/encoding/toBytes.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { serializeSignature } from '../../utils/signature/serializeSignature.js';\nlet extraEntropy = false;\n/**\n * Sets extra entropy for signing functions.\n */\nexport function setSignEntropy(entropy) {\n    if (!entropy)\n        throw new Error('must be a `true` or a hex value.');\n    extraEntropy = entropy;\n}\n/**\n * @description Signs a hash with a given private key.\n *\n * @param hash The hash to sign.\n * @param privateKey The private key to sign with.\n *\n * @returns The signature.\n */\nexport async function sign({ hash, privateKey, to = 'object', }) {\n    const { r, s, recovery } = secp256k1.sign(hash.slice(2), privateKey.slice(2), {\n        lowS: true,\n        extraEntropy: isHex(extraEntropy, { strict: false })\n            ? hexToBytes(extraEntropy)\n            : extraEntropy,\n    });\n    const signature = {\n        r: numberToHex(r, { size: 32 }),\n        s: numberToHex(s, { size: 32 }),\n        v: recovery ? 28n : 27n,\n        yParity: recovery,\n    };\n    return (() => {\n        if (to === 'bytes' || to === 'hex')\n            return serializeSignature({ ...signature, to });\n        return signature;\n    })();\n}\n//# sourceMappingURL=sign.js.map","import { hashAuthorization, } from '../../utils/authorization/hashAuthorization.js';\nimport { sign, } from './sign.js';\n/**\n * Signs an Authorization hash in [EIP-7702 format](https://eips.ethereum.org/EIPS/eip-7702): `keccak256('0x05' || rlp([chain_id, address, nonce]))`.\n */\nexport async function signAuthorization(parameters) {\n    const { chainId, nonce, privateKey, to = 'object' } = parameters;\n    const address = parameters.contractAddress ?? parameters.address;\n    const signature = await sign({\n        hash: hashAuthorization({ address, chainId, nonce }),\n        privateKey,\n        to,\n    });\n    if (to === 'object')\n        return {\n            address,\n            chainId,\n            nonce,\n            ...signature,\n        };\n    return signature;\n}\n//# sourceMappingURL=signAuthorization.js.map","import { hashMessage, } from '../../utils/signature/hashMessage.js';\nimport { sign } from './sign.js';\n/**\n * @description Calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191):\n * `keccak256(\"\\x19Ethereum Signed Message:\\n\" + len(message) + message))`.\n *\n * @returns The signature.\n */\nexport async function signMessage({ message, privateKey, }) {\n    return await sign({ hash: hashMessage(message), privateKey, to: 'hex' });\n}\n//# sourceMappingURL=signMessage.js.map","import { keccak256, } from '../../utils/hash/keccak256.js';\nimport { serializeTransaction, } from '../../utils/transaction/serializeTransaction.js';\nimport { sign } from './sign.js';\nexport async function signTransaction(parameters) {\n    const { privateKey, transaction, serializer = serializeTransaction, } = parameters;\n    const signableTransaction = (() => {\n        // For EIP-4844 Transactions, we want to sign the transaction payload body (tx_payload_body) without the sidecars (ie. without the network wrapper).\n        // See: https://github.com/ethereum/EIPs/blob/e00f4daa66bd56e2dbd5f1d36d09fd613811a48b/EIPS/eip-4844.md#networking\n        if (transaction.type === 'eip4844')\n            return {\n                ...transaction,\n                sidecars: false,\n            };\n        return transaction;\n    })();\n    const signature = await sign({\n        hash: keccak256(await serializer(signableTransaction)),\n        privateKey,\n    });\n    return (await serializer(transaction, signature));\n}\n//# sourceMappingURL=signTransaction.js.map","import { hashTypedData, } from '../../utils/signature/hashTypedData.js';\nimport { sign } from './sign.js';\n/**\n * @description Signs typed data and calculates an Ethereum-specific signature in [https://eips.ethereum.org/EIPS/eip-712](https://eips.ethereum.org/EIPS/eip-712):\n * `sign(keccak256(\"\\x19\\x01\" ‖ domainSeparator ‖ hashStruct(message)))`.\n *\n * @returns The signature.\n */\nexport async function signTypedData(parameters) {\n    const { privateKey, ...typedData } = parameters;\n    return await sign({\n        hash: hashTypedData(typedData),\n        privateKey,\n        to: 'hex',\n    });\n}\n//# sourceMappingURL=signTypedData.js.map","import { secp256k1 } from '@noble/curves/secp256k1';\nimport { toHex } from '../utils/encoding/toHex.js';\nimport { toAccount } from './toAccount.js';\nimport { publicKeyToAddress, } from './utils/publicKeyToAddress.js';\nimport { sign } from './utils/sign.js';\nimport { signAuthorization } from './utils/signAuthorization.js';\nimport { signMessage } from './utils/signMessage.js';\nimport { signTransaction, } from './utils/signTransaction.js';\nimport { signTypedData, } from './utils/signTypedData.js';\n/**\n * @description Creates an Account from a private key.\n *\n * @returns A Private Key Account.\n */\nexport function privateKeyToAccount(privateKey, options = {}) {\n    const { nonceManager } = options;\n    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));\n    const address = publicKeyToAddress(publicKey);\n    const account = toAccount({\n        address,\n        nonceManager,\n        async sign({ hash }) {\n            return sign({ hash, privateKey, to: 'hex' });\n        },\n        async signAuthorization(authorization) {\n            return signAuthorization({ ...authorization, privateKey });\n        },\n        async signMessage({ message }) {\n            return signMessage({ message, privateKey });\n        },\n        async signTransaction(transaction, { serializer } = {}) {\n            return signTransaction({ privateKey, transaction, serializer });\n        },\n        async signTypedData(typedData) {\n            return signTypedData({ ...typedData, privateKey });\n        },\n    });\n    return {\n        ...account,\n        publicKey,\n        source: 'privateKey',\n    };\n}\n//# sourceMappingURL=privateKeyToAccount.js.map","import { toHex } from '../utils/encoding/toHex.js';\nimport { privateKeyToAccount, } from './privateKeyToAccount.js';\n/**\n * @description Creates an Account from a HD Key.\n *\n * @returns A HD Account.\n */\nexport function hdKeyToAccount(hdKey_, { accountIndex = 0, addressIndex = 0, changeIndex = 0, path, ...options } = {}) {\n    const hdKey = hdKey_.derive(path || `m/44'/60'/${accountIndex}'/${changeIndex}/${addressIndex}`);\n    const account = privateKeyToAccount(toHex(hdKey.privateKey), options);\n    return {\n        ...account,\n        getHdKey: () => hdKey,\n        source: 'hd',\n    };\n}\n//# sourceMappingURL=hdKeyToAccount.js.map","import { HDKey } from '@scure/bip32';\nimport { mnemonicToSeedSync } from '@scure/bip39';\nimport { hdKeyToAccount, } from './hdKeyToAccount.js';\n/**\n * @description Creates an Account from a mnemonic phrase.\n *\n * @returns A HD Account.\n */\nexport function mnemonicToAccount(mnemonic, { passphrase, ...hdKeyOpts } = {}) {\n    const seed = mnemonicToSeedSync(mnemonic, passphrase);\n    return hdKeyToAccount(HDKey.fromMasterSeed(seed), hdKeyOpts);\n}\n//# sourceMappingURL=mnemonicToAccount.js.map"],"x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],"mappings":"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"}