superstack-wallet-sdk 0.4.5 → 0.4.7

package/dist/esm/node_modules/viem/_esm/utils/hash/toSignatureHash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toSignatureHash.js","sources":["../../../../../../../node_modules/viem/_esm/utils/hash/toSignatureHash.js"],"sourcesContent":["import { hashSignature } from './hashSignature.js';\nimport { toSignature } from './toSignature.js';\n/**\n * Returns the hash (of the function/event signature) for a given event or function definition.\n */\nexport function toSignatureHash(fn) {\n    return hashSignature(toSignature(fn));\n}\n//# sourceMappingURL=toSignatureHash.js.map"],"names":["toSignatureHash","fn","hashSignature","toSignature"],"mappings":"kGAKO,SAASA,EAAgBC,GAC5B,OAAOC,EAAcC,EAAYF,GACrC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/lru.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lru.js","sources":["../../../../../../node_modules/viem/_esm/utils/lru.js"],"sourcesContent":["/**\n * Map with a LRU (Least recently used) policy.\n *\n * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU\n */\nexport class LruMap extends Map {\n    constructor(size) {\n        super();\n        Object.defineProperty(this, \"maxSize\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        this.maxSize = size;\n    }\n    get(key) {\n        const value = super.get(key);\n        if (super.has(key) && value !== undefined) {\n            this.delete(key);\n            super.set(key, value);\n        }\n        return value;\n    }\n    set(key, value) {\n        super.set(key, value);\n        if (this.maxSize && this.size > this.maxSize) {\n            const firstKey = this.keys().next().value;\n            if (firstKey)\n                this.delete(firstKey);\n        }\n        return this;\n    }\n}\n//# sourceMappingURL=lru.js.map"],"names":["LruMap","Map","constructor","size","super","Object","defineProperty","this","enumerable","configurable","writable","value","maxSize","get","key","has","undefined","delete","set","firstKey","keys","next"],"mappings":"AAKO,MAAMA,UAAeC,IACxB,WAAAC,CAAYC,GACRC,QACAC,OAAOC,eAAeC,KAAM,UAAW,CACnCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,WAAO,IAEXJ,KAAKK,QAAUT,CACnB,CACA,GAAAU,CAAIC,GACA,MAAMH,EAAQP,MAAMS,IAAIC,GAKxB,OAJIV,MAAMW,IAAID,SAAkBE,IAAVL,IAClBJ,KAAKU,OAAOH,GACZV,MAAMc,IAAIJ,EAAKH,IAEZA,CACX,CACA,GAAAO,CAAIJ,EAAKH,GAEL,GADAP,MAAMc,IAAIJ,EAAKH,GACXJ,KAAKK,SAAWL,KAAKJ,KAAOI,KAAKK,QAAS,CAC1C,MAAMO,EAAWZ,KAAKa,OAAOC,OAAOV,MAChCQ,GACAZ,KAAKU,OAAOE,EACpB,CACA,OAAOZ,IACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/observe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"observe.js","sources":["../../../../../../node_modules/viem/_esm/utils/observe.js"],"sourcesContent":["/** @internal */\nexport const listenersCache = /*#__PURE__*/ new Map();\n/** @internal */\nexport const cleanupCache = /*#__PURE__*/ new Map();\nlet callbackCount = 0;\n/**\n * @description Sets up an observer for a given function. If another function\n * is set up under the same observer id, the function will only be called once\n * for both instances of the observer.\n */\nexport function observe(observerId, callbacks, fn) {\n    const callbackId = ++callbackCount;\n    const getListeners = () => listenersCache.get(observerId) || [];\n    const unsubscribe = () => {\n        const listeners = getListeners();\n        listenersCache.set(observerId, listeners.filter((cb) => cb.id !== callbackId));\n    };\n    const unwatch = () => {\n        const listeners = getListeners();\n        if (!listeners.some((cb) => cb.id === callbackId))\n            return;\n        const cleanup = cleanupCache.get(observerId);\n        if (listeners.length === 1 && cleanup) {\n            const p = cleanup();\n            if (p instanceof Promise)\n                p.catch(() => { });\n        }\n        unsubscribe();\n    };\n    const listeners = getListeners();\n    listenersCache.set(observerId, [\n        ...listeners,\n        { id: callbackId, fns: callbacks },\n    ]);\n    if (listeners && listeners.length > 0)\n        return unwatch;\n    const emit = {};\n    for (const key in callbacks) {\n        emit[key] = ((...args) => {\n            const listeners = getListeners();\n            if (listeners.length === 0)\n                return;\n            for (const listener of listeners)\n                listener.fns[key]?.(...args);\n        });\n    }\n    const cleanup = fn(emit);\n    if (typeof cleanup === 'function')\n        cleanupCache.set(observerId, cleanup);\n    return unwatch;\n}\n//# sourceMappingURL=observe.js.map"],"names":["listenersCache","Map","cleanupCache","callbackCount","observe","observerId","callbacks","fn","callbackId","getListeners","get","unwatch","listeners","some","cb","id","cleanup","length","p","Promise","catch","set","filter","unsubscribe","fns","emit","key","args","listener"],"mappings":"AACY,MAACA,EAA+B,IAAIC,IAEnCC,EAA6B,IAAID,IAC9C,IAAIE,EAAgB,EAMb,SAASC,EAAQC,EAAYC,EAAWC,GAC3C,MAAMC,IAAeL,EACfM,EAAe,IAAMT,EAAeU,IAAIL,IAAe,GAKvDM,EAAU,KACZ,MAAMC,EAAYH,IAClB,IAAKG,EAAUC,KAAMC,GAAOA,EAAGC,KAAOP,GAClC,OACJ,MAAMQ,EAAUd,EAAaQ,IAAIL,GACjC,GAAyB,IAArBO,EAAUK,QAAgBD,EAAS,CACnC,MAAME,EAAIF,IACNE,aAAaC,SACbD,EAAEE,MAAM,OAChB,CAbgB,MAChB,MAAMR,EAAYH,IAClBT,EAAeqB,IAAIhB,EAAYO,EAAUU,OAAQR,GAAOA,EAAGC,KAAOP,KAYlEe,IAEEX,EAAYH,IAKlB,GAJAT,EAAeqB,IAAIhB,EAAY,IACxBO,EACH,CAAEG,GAAIP,EAAYgB,IAAKlB,KAEvBM,GAAaA,EAAUK,OAAS,EAChC,OAAON,EACX,MAAMc,EAAO,CAAA,EACb,IAAK,MAAMC,KAAOpB,EACdmB,EAAKC,OAAYC,KACb,MAAMf,EAAYH,IAClB,GAAyB,IAArBG,EAAUK,OAEd,IAAK,MAAMW,KAAYhB,EACnBgB,EAASJ,IAAIE,QAAUC,EAC9B,EAEL,MAAMX,EAAUT,EAAGkB,GAGnB,MAFuB,mBAAZT,GACPd,EAAamB,IAAIhB,EAAYW,GAC1BL,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/poll.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"poll.js","sources":["../../../../../../node_modules/viem/_esm/utils/poll.js"],"sourcesContent":["import { wait } from './wait.js';\n/**\n * @description Polls a function at a specified interval.\n */\nexport function poll(fn, { emitOnBegin, initialWaitTime, interval }) {\n    let active = true;\n    const unwatch = () => (active = false);\n    const watch = async () => {\n        let data;\n        if (emitOnBegin)\n            data = await fn({ unpoll: unwatch });\n        const initialWait = (await initialWaitTime?.(data)) ?? interval;\n        await wait(initialWait);\n        const poll = async () => {\n            if (!active)\n                return;\n            await fn({ unpoll: unwatch });\n            await wait(interval);\n            poll();\n        };\n        poll();\n    };\n    watch();\n    return unwatch;\n}\n//# sourceMappingURL=poll.js.map"],"names":["poll","fn","emitOnBegin","initialWaitTime","interval","active","unwatch","async","data","unpoll","initialWait","wait","watch"],"mappings":"iCAIO,SAASA,EAAKC,GAAIC,YAAEA,EAAWC,gBAAEA,EAAeC,SAAEA,IACrD,IAAIC,GAAS,EACb,MAAMC,EAAU,IAAOD,GAAS,EAiBhC,MAhBcE,WACV,IAAIC,EACAN,IACAM,QAAaP,EAAG,CAAEQ,OAAQH,KAC9B,MAAMI,QAAqBP,IAAkBK,KAAUJ,QACjDO,EAAKD,GACX,MAAMV,EAAOO,UACJF,UAECJ,EAAG,CAAEQ,OAAQH,UACbK,EAAKP,GACXJ,MAEJA,KAEJY,GACON,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/promise/createBatchScheduler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createBatchScheduler.js","sources":["../../../../../../../node_modules/viem/_esm/utils/promise/createBatchScheduler.js"],"sourcesContent":["import { withResolvers } from './withResolvers.js';\nconst schedulerCache = /*#__PURE__*/ new Map();\n/** @internal */\nexport function createBatchScheduler({ fn, id, shouldSplitBatch, wait = 0, sort, }) {\n    const exec = async () => {\n        const scheduler = getScheduler();\n        flush();\n        const args = scheduler.map(({ args }) => args);\n        if (args.length === 0)\n            return;\n        fn(args)\n            .then((data) => {\n            if (sort && Array.isArray(data))\n                data.sort(sort);\n            for (let i = 0; i < scheduler.length; i++) {\n                const { resolve } = scheduler[i];\n                resolve?.([data[i], data]);\n            }\n        })\n            .catch((err) => {\n            for (let i = 0; i < scheduler.length; i++) {\n                const { reject } = scheduler[i];\n                reject?.(err);\n            }\n        });\n    };\n    const flush = () => schedulerCache.delete(id);\n    const getBatchedArgs = () => getScheduler().map(({ args }) => args);\n    const getScheduler = () => schedulerCache.get(id) || [];\n    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);\n    return {\n        flush,\n        async schedule(args) {\n            const { promise, resolve, reject } = withResolvers();\n            const split = shouldSplitBatch?.([...getBatchedArgs(), args]);\n            if (split)\n                exec();\n            const hasActiveScheduler = getScheduler().length > 0;\n            if (hasActiveScheduler) {\n                setScheduler({ args, resolve, reject });\n                return promise;\n            }\n            setScheduler({ args, resolve, reject });\n            setTimeout(exec, wait);\n            return promise;\n        },\n    };\n}\n//# sourceMappingURL=createBatchScheduler.js.map"],"names":["schedulerCache","Map","createBatchScheduler","fn","id","shouldSplitBatch","wait","sort","exec","async","scheduler","getScheduler","flush","args","map","length","then","data","Array","isArray","i","resolve","catch","err","reject","delete","get","setScheduler","item","set","schedule","promise","withResolvers","split","setTimeout"],"mappings":"mDACA,MAAMA,EAA+B,IAAIC,IAElC,SAASC,GAAqBC,GAAEA,EAAEC,GAAEA,EAAEC,iBAAEA,EAAgBC,KAAEA,EAAO,EAACC,KAAEA,IACvE,MAAMC,EAAOC,UACT,MAAMC,EAAYC,IAClBC,IACA,MAAMC,EAAOH,EAAUI,IAAI,EAAGD,UAAWA,GACrB,IAAhBA,EAAKE,QAETZ,EAAGU,GACEG,KAAMC,IACHV,GAAQW,MAAMC,QAAQF,IACtBA,EAAKV,KAAKA,GACd,IAAK,IAAIa,EAAI,EAAGA,EAAIV,EAAUK,OAAQK,IAAK,CACvC,MAAMC,QAAEA,GAAYX,EAAUU,GAC9BC,IAAU,CAACJ,EAAKG,GAAIH,GACxB,IAECK,MAAOC,IACR,IAAK,IAAIH,EAAI,EAAGA,EAAIV,EAAUK,OAAQK,IAAK,CACvC,MAAMI,OAAEA,GAAWd,EAAUU,GAC7BI,IAASD,EACb,KAGFX,EAAQ,IAAMZ,EAAeyB,OAAOrB,GAEpCO,EAAe,IAAMX,EAAe0B,IAAItB,IAAO,GAC/CuB,EAAgBC,GAAS5B,EAAe6B,IAAIzB,EAAI,IAAIO,IAAgBiB,IAC1E,MAAO,CACHhB,QACA,cAAMkB,CAASjB,GACX,MAAMkB,QAAEA,EAAOV,QAAEA,EAAOG,OAAEA,GAAWQ,IAC/BC,EAAQ5B,IAAmB,IAPZM,IAAeG,IAAI,EAAGD,UAAWA,GAOCA,IACnDoB,GACAzB,IAEJ,OAD2BG,IAAeI,OAAS,GAE/CY,EAAa,CAAEd,OAAMQ,UAASG,WACvBO,IAEXJ,EAAa,CAAEd,OAAMQ,UAASG,WAC9BU,WAAW1B,EAAMF,GACVyB,EACX,EAER","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/promise/withCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"withCache.js","sources":["../../../../../../../node_modules/viem/_esm/utils/promise/withCache.js"],"sourcesContent":["/** @internal */\nexport const promiseCache = /*#__PURE__*/ new Map();\n/** @internal */\nexport const responseCache = /*#__PURE__*/ new Map();\nexport function getCache(cacheKey) {\n    const buildCache = (cacheKey, cache) => ({\n        clear: () => cache.delete(cacheKey),\n        get: () => cache.get(cacheKey),\n        set: (data) => cache.set(cacheKey, data),\n    });\n    const promise = buildCache(cacheKey, promiseCache);\n    const response = buildCache(cacheKey, responseCache);\n    return {\n        clear: () => {\n            promise.clear();\n            response.clear();\n        },\n        promise,\n        response,\n    };\n}\n/**\n * @description Returns the result of a given promise, and caches the result for\n * subsequent invocations against a provided cache key.\n */\nexport async function withCache(fn, { cacheKey, cacheTime = Number.POSITIVE_INFINITY }) {\n    const cache = getCache(cacheKey);\n    // If a response exists in the cache, and it's not expired, return it\n    // and do not invoke the promise.\n    // If the max age is 0, the cache is disabled.\n    const response = cache.response.get();\n    if (response && cacheTime > 0) {\n        const age = Date.now() - response.created.getTime();\n        if (age < cacheTime)\n            return response.data;\n    }\n    let promise = cache.promise.get();\n    if (!promise) {\n        promise = fn();\n        // Store the promise in the cache so that subsequent invocations\n        // will wait for the same promise to resolve (deduping).\n        cache.promise.set(promise);\n    }\n    try {\n        const data = await promise;\n        // Store the response in the cache so that subsequent invocations\n        // will return the same response.\n        cache.response.set({ created: new Date(), data });\n        return data;\n    }\n    finally {\n        // Clear the promise cache so that subsequent invocations will\n        // invoke the promise again.\n        cache.promise.clear();\n    }\n}\n//# sourceMappingURL=withCache.js.map"],"names":["promiseCache","Map","responseCache","getCache","cacheKey","buildCache","cache","clear","delete","get","set","data","promise","response","async","withCache","fn","cacheTime","Number","POSITIVE_INFINITY","Date","now","created","getTime"],"mappings":"AACY,MAACA,EAA6B,IAAIC,IAEjCC,EAA8B,IAAID,IACxC,SAASE,EAASC,GACrB,MAAMC,EAAa,CAACD,EAAUE,KAAK,CAC/BC,MAAO,IAAMD,EAAME,OAAOJ,GAC1BK,IAAK,IAAMH,EAAMG,IAAIL,GACrBM,IAAMC,GAASL,EAAMI,IAAIN,EAAUO,KAEjCC,EAAUP,EAAWD,EAAUJ,GAC/Ba,EAAWR,EAAWD,EAAUF,GACtC,MAAO,CACHK,MAAO,KACHK,EAAQL,QACRM,EAASN,SAEbK,UACAC,WAER,CAKOC,eAAeC,EAAUC,GAAIZ,SAAEA,EAAQa,UAAEA,EAAYC,OAAOC,oBAC/D,MAAMb,EAAQH,EAASC,GAIjBS,EAAWP,EAAMO,SAASJ,MAChC,GAAII,GAAYI,EAAY,EAAG,CAE3B,GADYG,KAAKC,MAAQR,EAASS,QAAQC,UAChCN,EACN,OAAOJ,EAASF,IACxB,CACA,IAAIC,EAAUN,EAAMM,QAAQH,MACvBG,IACDA,EAAUI,IAGVV,EAAMM,QAAQF,IAAIE,IAEtB,IACI,MAAMD,QAAaC,EAInB,OADAN,EAAMO,SAASH,IAAI,CAAEY,QAAS,IAAIF,KAAQT,SACnCA,CACX,CACJ,QAGQL,EAAMM,QAAQL,OAClB,CACJ","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/promise/withDedupe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"withDedupe.js","sources":["../../../../../../../node_modules/viem/_esm/utils/promise/withDedupe.js"],"sourcesContent":["import { LruMap } from '../lru.js';\n/** @internal */\nexport const promiseCache = /*#__PURE__*/ new LruMap(8192);\n/** Deduplicates in-flight promises. */\nexport function withDedupe(fn, { enabled = true, id }) {\n    if (!enabled || !id)\n        return fn();\n    if (promiseCache.get(id))\n        return promiseCache.get(id);\n    const promise = fn().finally(() => promiseCache.delete(id));\n    promiseCache.set(id, promise);\n    return promise;\n}\n//# sourceMappingURL=withDedupe.js.map"],"names":["promiseCache","LruMap","withDedupe","fn","enabled","id","get","promise","finally","delete","set"],"mappings":"mCAEY,MAACA,EAA6B,IAAIC,EAAO,MAE9C,SAASC,EAAWC,GAAIC,QAAEA,GAAU,EAAIC,GAAEA,IAC7C,IAAKD,IAAYC,EACb,OAAOF,IACX,GAAIH,EAAaM,IAAID,GACjB,OAAOL,EAAaM,IAAID,GAC5B,MAAME,EAAUJ,IAAKK,QAAQ,IAAMR,EAAaS,OAAOJ,IAEvD,OADAL,EAAaU,IAAIL,EAAIE,GACdA,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/promise/withResolvers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"withResolvers.js","sources":["../../../../../../../node_modules/viem/_esm/utils/promise/withResolvers.js"],"sourcesContent":["/** @internal */\nexport function withResolvers() {\n    let resolve = () => undefined;\n    let reject = () => undefined;\n    const promise = new Promise((resolve_, reject_) => {\n        resolve = resolve_;\n        reject = reject_;\n    });\n    return { promise, resolve, reject };\n}\n//# sourceMappingURL=withResolvers.js.map"],"names":["withResolvers","resolve","reject","promise","Promise","resolve_","reject_"],"mappings":"AACO,SAASA,IACZ,IAAIC,EAAU,OACVC,EAAS,OAKb,MAAO,CAAEC,QAJO,IAAIC,QAAQ,CAACC,EAAUC,KACnCL,EAAUI,EACVH,EAASI,IAEKL,UAASC,SAC/B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/promise/withRetry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"withRetry.js","sources":["../../../../../../../node_modules/viem/_esm/utils/promise/withRetry.js"],"sourcesContent":["import { wait } from '../wait.js';\nexport function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry = () => true, } = {}) {\n    return new Promise((resolve, reject) => {\n        const attemptRetry = async ({ count = 0 } = {}) => {\n            const retry = async ({ error }) => {\n                const delay = typeof delay_ === 'function' ? delay_({ count, error }) : delay_;\n                if (delay)\n                    await wait(delay);\n                attemptRetry({ count: count + 1 });\n            };\n            try {\n                const data = await fn();\n                resolve(data);\n            }\n            catch (err) {\n                if (count < retryCount &&\n                    (await shouldRetry({ count, error: err })))\n                    return retry({ error: err });\n                reject(err);\n            }\n        };\n        attemptRetry();\n    });\n}\n//# sourceMappingURL=withRetry.js.map"],"names":["withRetry","fn","delay","delay_","retryCount","shouldRetry","Promise","resolve","reject","attemptRetry","async","count","data","err","error","wait","retry"],"mappings":"kCACO,SAASA,EAAUC,GAAMC,MAAOC,EAAS,IAAGC,WAAEA,EAAa,EAACC,YAAEA,EAAc,KAAM,GAAU,CAAA,GAC/F,OAAO,IAAIC,QAAQ,CAACC,EAASC,KACzB,MAAMC,EAAeC,OAASC,QAAQ,GAAM,CAAA,KAOxC,IACI,MAAMC,QAAaX,IACnBM,EAAQK,EACZ,CACA,MAAOC,GACH,GAAIF,EAAQP,SACDC,EAAY,CAAEM,QAAOG,MAAOD,IACnC,MAbMH,QAASI,YACnB,MAAMZ,EAA0B,mBAAXC,EAAwBA,EAAO,CAAEQ,QAAOG,UAAWX,EACpED,SACMa,EAAKb,GACfO,EAAa,CAAEE,MAAOA,EAAQ,KASnBK,CAAM,CAAEF,MAAOD,IAC1BL,EAAOK,EACX,GAEJJ,KAER","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/promise/withTimeout.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"withTimeout.js","sources":["../../../../../../../node_modules/viem/_esm/utils/promise/withTimeout.js"],"sourcesContent":["export function withTimeout(fn, { errorInstance = new Error('timed out'), timeout, signal, }) {\n    return new Promise((resolve, reject) => {\n        ;\n        (async () => {\n            let timeoutId;\n            try {\n                const controller = new AbortController();\n                if (timeout > 0) {\n                    timeoutId = setTimeout(() => {\n                        if (signal) {\n                            controller.abort();\n                        }\n                        else {\n                            reject(errorInstance);\n                        }\n                    }, timeout); // need to cast because bun globals.d.ts overrides @types/node\n                }\n                resolve(await fn({ signal: controller?.signal || null }));\n            }\n            catch (err) {\n                if (err?.name === 'AbortError')\n                    reject(errorInstance);\n                reject(err);\n            }\n            finally {\n                clearTimeout(timeoutId);\n            }\n        })();\n    });\n}\n//# sourceMappingURL=withTimeout.js.map"],"names":["withTimeout","fn","errorInstance","Error","timeout","signal","Promise","resolve","reject","timeoutId","controller","AbortController","setTimeout","abort","err","name","clearTimeout"],"mappings":"AAAO,SAASA,EAAYC,GAAIC,cAAEA,EAAgB,IAAIC,MAAM,aAAYC,QAAEA,EAAOC,OAAEA,IAC/E,OAAO,IAAIC,QAAQ,CAACC,EAASC,KAEzB,WACI,IAAIC,EACJ,IACI,MAAMC,EAAa,IAAIC,gBACnBP,EAAU,IACVK,EAAYG,WAAW,KACfP,GACAK,EAAWG,SAKhBT,IAEPG,QAAcN,EAAG,CAAEI,OAAQK,GAAYL,QAAU,OACrD,CACA,MAAOS,GACe,eAAdA,GAAKC,MACLP,EAAON,GACXM,EAAOM,EACX,CACZ,QACgBE,aAAaP,EACjB,CACH,EAxBD,IA0BR","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/regex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"regex.js","sources":["../../../../../../node_modules/viem/_esm/utils/regex.js"],"sourcesContent":["export const arrayRegex = /^(.*)\\[([0-9]*)\\]$/;\n// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`\n// https://regexr.com/6va55\nexport const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;\n// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`\n// https://regexr.com/6v8hp\nexport const integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;\n//# sourceMappingURL=regex.js.map"],"names":["bytesRegex","integerRegex"],"mappings":"AAGY,MAACA,EAAa,uCAGbC,EAAe","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/rpc/http.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"http.js","sources":["../../../../../../../node_modules/viem/_esm/utils/rpc/http.js"],"sourcesContent":["import { HttpRequestError, TimeoutError, } from '../../errors/request.js';\nimport { withTimeout, } from '../promise/withTimeout.js';\nimport { stringify } from '../stringify.js';\nimport { idCache } from './id.js';\nexport function getHttpRpcClient(url, options = {}) {\n    return {\n        async request(params) {\n            const { body, fetchFn = options.fetchFn ?? fetch, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 10_000, } = params;\n            const fetchOptions = {\n                ...(options.fetchOptions ?? {}),\n                ...(params.fetchOptions ?? {}),\n            };\n            const { headers, method, signal: signal_ } = fetchOptions;\n            try {\n                const response = await withTimeout(async ({ signal }) => {\n                    const init = {\n                        ...fetchOptions,\n                        body: Array.isArray(body)\n                            ? stringify(body.map((body) => ({\n                                jsonrpc: '2.0',\n                                id: body.id ?? idCache.take(),\n                                ...body,\n                            })))\n                            : stringify({\n                                jsonrpc: '2.0',\n                                id: body.id ?? idCache.take(),\n                                ...body,\n                            }),\n                        headers: {\n                            'Content-Type': 'application/json',\n                            ...headers,\n                        },\n                        method: method || 'POST',\n                        signal: signal_ || (timeout > 0 ? signal : null),\n                    };\n                    const request = new Request(url, init);\n                    const args = (await onRequest?.(request, init)) ?? { ...init, url };\n                    const response = await fetchFn(args.url ?? url, args);\n                    return response;\n                }, {\n                    errorInstance: new TimeoutError({ body, url }),\n                    timeout,\n                    signal: true,\n                });\n                if (onResponse)\n                    await onResponse(response);\n                let data;\n                if (response.headers.get('Content-Type')?.startsWith('application/json'))\n                    data = await response.json();\n                else {\n                    data = await response.text();\n                    try {\n                        data = JSON.parse(data || '{}');\n                    }\n                    catch (err) {\n                        if (response.ok)\n                            throw err;\n                        data = { error: data };\n                    }\n                }\n                if (!response.ok) {\n                    throw new HttpRequestError({\n                        body,\n                        details: stringify(data.error) || response.statusText,\n                        headers: response.headers,\n                        status: response.status,\n                        url,\n                    });\n                }\n                return data;\n            }\n            catch (err) {\n                if (err instanceof HttpRequestError)\n                    throw err;\n                if (err instanceof TimeoutError)\n                    throw err;\n                throw new HttpRequestError({\n                    body,\n                    cause: err,\n                    url,\n                });\n            }\n        },\n    };\n}\n//# sourceMappingURL=http.js.map"],"names":["getHttpRpcClient","url","options","request","params","body","fetchFn","fetch","onRequest","onResponse","timeout","fetchOptions","headers","method","signal","signal_","response","withTimeout","async","init","Array","isArray","stringify","map","jsonrpc","id","idCache","take","Request","args","errorInstance","TimeoutError","data","get","startsWith","json","text","JSON","parse","err","ok","error","HttpRequestError","details","statusText","status","cause"],"mappings":"mNAIO,SAASA,EAAiBC,EAAKC,EAAU,IAC5C,MAAO,CACH,aAAMC,CAAQC,GACV,MAAMC,KAAEA,EAAIC,QAAEA,EAAUJ,EAAQI,SAAWC,MAAKC,UAAEA,EAAYN,EAAQM,UAASC,WAAEA,EAAaP,EAAQO,WAAUC,QAAEA,EAAUR,EAAQQ,SAAW,KAAYN,EACrJO,EAAe,IACbT,EAAQS,cAAgB,MACxBP,EAAOO,cAAgB,KAEzBC,QAAEA,EAAOC,OAAEA,EAAQC,OAAQC,GAAYJ,EAC7C,IACI,MAAMK,QAAiBC,EAAYC,OAASJ,aACxC,MAAMK,EAAO,IACNR,EACHN,KAAMe,MAAMC,QAAQhB,GACdiB,EAAUjB,EAAKkB,IAAKlB,IAAI,CACtBmB,QAAS,MACTC,GAAIpB,EAAKoB,IAAMC,EAAQC,UACpBtB,MAELiB,EAAU,CACRE,QAAS,MACTC,GAAIpB,EAAKoB,IAAMC,EAAQC,UACpBtB,IAEXO,QAAS,CACL,eAAgB,sBACbA,GAEPC,OAAQA,GAAU,OAClBC,OAAQC,IAAYL,EAAU,EAAII,EAAS,OAEzCX,EAAU,IAAIyB,QAAQ3B,EAAKkB,GAC3BU,QAAcrB,IAAYL,EAASgB,KAAU,IAAKA,EAAMlB,OAE9D,aADuBK,EAAQuB,EAAK5B,KAAOA,EAAK4B,IAEjD,CACCC,cAAe,IAAIC,EAAa,CAAE1B,OAAMJ,QACxCS,UACAI,QAAQ,IAIZ,IAAIkB,EACJ,GAHIvB,SACMA,EAAWO,GAEjBA,EAASJ,QAAQqB,IAAI,iBAAiBC,WAAW,oBACjDF,QAAahB,EAASmB,WACrB,CACDH,QAAahB,EAASoB,OACtB,IACIJ,EAAOK,KAAKC,MAAMN,GAAQ,KAC9B,CACA,MAAOO,GACH,GAAIvB,EAASwB,GACT,MAAMD,EACVP,EAAO,CAAES,MAAOT,EACpB,CACJ,CACA,IAAKhB,EAASwB,GACV,MAAM,IAAIE,EAAiB,CACvBrC,OACAsC,QAASrB,EAAUU,EAAKS,QAAUzB,EAAS4B,WAC3ChC,QAASI,EAASJ,QAClBiC,OAAQ7B,EAAS6B,OACjB5C,QAGR,OAAO+B,CACX,CACA,MAAOO,GACH,GAAIA,aAAeG,EACf,MAAMH,EACV,GAAIA,aAAeR,EACf,MAAMQ,EACV,MAAM,IAAIG,EAAiB,CACvBrC,OACAyC,MAAOP,EACPtC,OAER,CACJ,EAER","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/rpc/id.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"id.js","sources":["../../../../../../../node_modules/viem/_esm/utils/rpc/id.js"],"sourcesContent":["function createIdStore() {\n    return {\n        current: 0,\n        take() {\n            return this.current++;\n        },\n        reset() {\n            this.current = 0;\n        },\n    };\n}\nexport const idCache = /*#__PURE__*/ createIdStore();\n//# sourceMappingURL=id.js.map"],"names":["createIdStore","current","take","this","reset","idCache"],"mappings":"AAAA,SAASA,IACL,MAAO,CACHC,QAAS,EACT,IAAAC,GACI,OAAOC,KAAKF,SAChB,EACA,KAAAG,GACID,KAAKF,QAAU,CACnB,EAER,CACY,MAACI,EAAwBL","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/signature/hashMessage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hashMessage.js","sources":["../../../../../../../node_modules/viem/_esm/utils/signature/hashMessage.js"],"sourcesContent":["import { keccak256 } from '../hash/keccak256.js';\nimport { toPrefixedMessage } from './toPrefixedMessage.js';\nexport function hashMessage(message, to_) {\n    return keccak256(toPrefixedMessage(message), to_);\n}\n//# sourceMappingURL=hashMessage.js.map"],"names":["hashMessage","message","to_","keccak256","toPrefixedMessage"],"mappings":"4GAEO,SAASA,EAAYC,EAASC,GACjC,OAAOC,EAAUC,EAAkBH,GAAUC,EACjD","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/signature/hashTypedData.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hashTypedData.js","sources":["../../../../../../../node_modules/viem/_esm/utils/signature/hashTypedData.js"],"sourcesContent":["// Implementation forked and adapted from https://github.com/MetaMask/eth-sig-util/blob/main/src/sign-typed-data.ts\nimport { encodeAbiParameters, } from '../abi/encodeAbiParameters.js';\nimport { concat } from '../data/concat.js';\nimport { toHex } from '../encoding/toHex.js';\nimport { keccak256 } from '../hash/keccak256.js';\nimport { getTypesForEIP712Domain, validateTypedData, } from '../typedData.js';\nexport function hashTypedData(parameters) {\n    const { domain = {}, message, primaryType, } = parameters;\n    const types = {\n        EIP712Domain: getTypesForEIP712Domain({ domain }),\n        ...parameters.types,\n    };\n    // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc\n    // as we can't statically check this with TypeScript.\n    validateTypedData({\n        domain,\n        message,\n        primaryType,\n        types,\n    });\n    const parts = ['0x1901'];\n    if (domain)\n        parts.push(hashDomain({\n            domain,\n            types: types,\n        }));\n    if (primaryType !== 'EIP712Domain')\n        parts.push(hashStruct({\n            data: message,\n            primaryType,\n            types: types,\n        }));\n    return keccak256(concat(parts));\n}\nexport function hashDomain({ domain, types, }) {\n    return hashStruct({\n        data: domain,\n        primaryType: 'EIP712Domain',\n        types,\n    });\n}\nexport function hashStruct({ data, primaryType, types, }) {\n    const encoded = encodeData({\n        data,\n        primaryType,\n        types,\n    });\n    return keccak256(encoded);\n}\nfunction encodeData({ data, primaryType, types, }) {\n    const encodedTypes = [{ type: 'bytes32' }];\n    const encodedValues = [hashType({ primaryType, types })];\n    for (const field of types[primaryType]) {\n        const [type, value] = encodeField({\n            types,\n            name: field.name,\n            type: field.type,\n            value: data[field.name],\n        });\n        encodedTypes.push(type);\n        encodedValues.push(value);\n    }\n    return encodeAbiParameters(encodedTypes, encodedValues);\n}\nfunction hashType({ primaryType, types, }) {\n    const encodedHashType = toHex(encodeType({ primaryType, types }));\n    return keccak256(encodedHashType);\n}\nexport function encodeType({ primaryType, types, }) {\n    let result = '';\n    const unsortedDeps = findTypeDependencies({ primaryType, types });\n    unsortedDeps.delete(primaryType);\n    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];\n    for (const type of deps) {\n        result += `${type}(${types[type]\n            .map(({ name, type: t }) => `${t} ${name}`)\n            .join(',')})`;\n    }\n    return result;\n}\nfunction findTypeDependencies({ primaryType: primaryType_, types, }, results = new Set()) {\n    const match = primaryType_.match(/^\\w*/u);\n    const primaryType = match?.[0];\n    if (results.has(primaryType) || types[primaryType] === undefined) {\n        return results;\n    }\n    results.add(primaryType);\n    for (const field of types[primaryType]) {\n        findTypeDependencies({ primaryType: field.type, types }, results);\n    }\n    return results;\n}\nfunction encodeField({ types, name, type, value, }) {\n    if (types[type] !== undefined) {\n        return [\n            { type: 'bytes32' },\n            keccak256(encodeData({ data: value, primaryType: type, types })),\n        ];\n    }\n    if (type === 'bytes') {\n        const prepend = value.length % 2 ? '0' : '';\n        value = `0x${prepend + value.slice(2)}`;\n        return [{ type: 'bytes32' }, keccak256(value)];\n    }\n    if (type === 'string')\n        return [{ type: 'bytes32' }, keccak256(toHex(value))];\n    if (type.lastIndexOf(']') === type.length - 1) {\n        const parsedType = type.slice(0, type.lastIndexOf('['));\n        const typeValuePairs = value.map((item) => encodeField({\n            name,\n            type: parsedType,\n            types,\n            value: item,\n        }));\n        return [\n            { type: 'bytes32' },\n            keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v))),\n        ];\n    }\n    return [{ type }, value];\n}\n//# sourceMappingURL=hashTypedData.js.map"],"names":["hashTypedData","parameters","domain","message","primaryType","types","EIP712Domain","getTypesForEIP712Domain","validateTypedData","parts","push","hashDomain","hashStruct","data","keccak256","concat","encoded","encodeData","encodedTypes","type","encodedValues","hashType","field","value","encodeField","name","encodeAbiParameters","encodedHashType","toHex","encodeType","result","unsortedDeps","findTypeDependencies","delete","deps","Array","from","sort","map","t","join","primaryType_","results","Set","match","has","undefined","add","length","slice","lastIndexOf","parsedType","typeValuePairs","item","v"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/signature/recoverAddress.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"recoverAddress.js","sources":["../../../../../../../node_modules/viem/_esm/utils/signature/recoverAddress.js"],"sourcesContent":["import { publicKeyToAddress } from '../../accounts/utils/publicKeyToAddress.js';\nimport { recoverPublicKey } from './recoverPublicKey.js';\nexport async function recoverAddress({ hash, signature, }) {\n    return publicKeyToAddress(await recoverPublicKey({ hash, signature }));\n}\n//# sourceMappingURL=recoverAddress.js.map"],"names":["async","recoverAddress","hash","signature","publicKeyToAddress","recoverPublicKey"],"mappings":"yIAEOA,eAAeC,GAAeC,KAAEA,EAAIC,UAAEA,IACzC,OAAOC,QAAyBC,EAAiB,CAAEH,OAAMC,cAC7D","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/signature/recoverPublicKey.js

@@ -1,2 +0,0 @@
-import{isHex as r}from"../data/isHex.js";import{size as e}from"../data/size.js";import{hexToBigInt as t,hexToNumber as n}from"../encoding/fromHex.js";import{toHex as o}from"../encoding/toHex.js";async function i({hash:i,signature:a}){const c=r(i)?i:o(i),{secp256k1:u}=await import("../../../node_modules/@noble/curves/esm/secp256k1.js");return`0x${(()=>{if("object"==typeof a&&"r"in a&&"s"in a){const{r:r,s:e,v:n,yParity:o}=a,i=s(Number(o??n));return new u.Signature(t(r),t(e)).addRecoveryBit(i)}const i=r(a)?a:o(a);if(65!==e(i))throw new Error("invalid signature length");const c=s(n(`0x${i.slice(130)}`));return u.Signature.fromCompact(i.substring(2,130)).addRecoveryBit(c)})().recoverPublicKey(c.substring(2)).toHex(!1)}`}function s(r){if(0===r||1===r)return r;if(27===r)return 0;if(28===r)return 1;throw new Error("Invalid yParityOrV value")}export{i as recoverPublicKey};
-//# sourceMappingURL=recoverPublicKey.js.map

package/dist/esm/node_modules/viem/_esm/utils/signature/recoverPublicKey.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"recoverPublicKey.js","sources":["../../../../../../../node_modules/viem/_esm/utils/signature/recoverPublicKey.js"],"sourcesContent":["import { isHex } from '../data/isHex.js';\nimport { size } from '../data/size.js';\nimport { hexToBigInt, hexToNumber, } from '../encoding/fromHex.js';\nimport { toHex } from '../encoding/toHex.js';\nexport async function recoverPublicKey({ hash, signature, }) {\n    const hashHex = isHex(hash) ? hash : toHex(hash);\n    const { secp256k1 } = await import('@noble/curves/secp256k1');\n    const signature_ = (() => {\n        // typeof signature: `Signature`\n        if (typeof signature === 'object' && 'r' in signature && 's' in signature) {\n            const { r, s, v, yParity } = signature;\n            const yParityOrV = Number(yParity ?? v);\n            const recoveryBit = toRecoveryBit(yParityOrV);\n            return new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit);\n        }\n        // typeof signature: `Hex | ByteArray`\n        const signatureHex = isHex(signature) ? signature : toHex(signature);\n        if (size(signatureHex) !== 65)\n            throw new Error('invalid signature length');\n        const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);\n        const recoveryBit = toRecoveryBit(yParityOrV);\n        return secp256k1.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);\n    })();\n    const publicKey = signature_\n        .recoverPublicKey(hashHex.substring(2))\n        .toHex(false);\n    return `0x${publicKey}`;\n}\nfunction toRecoveryBit(yParityOrV) {\n    if (yParityOrV === 0 || yParityOrV === 1)\n        return yParityOrV;\n    if (yParityOrV === 27)\n        return 0;\n    if (yParityOrV === 28)\n        return 1;\n    throw new Error('Invalid yParityOrV value');\n}\n//# sourceMappingURL=recoverPublicKey.js.map"],"names":["async","recoverPublicKey","hash","signature","hashHex","isHex","toHex","secp256k1","import","r","s","v","yParity","recoveryBit","toRecoveryBit","Number","Signature","hexToBigInt","addRecoveryBit","signatureHex","size","Error","hexToNumber","slice","fromCompact","substring","yParityOrV"],"mappings":"mMAIOA,eAAeC,GAAiBC,KAAEA,EAAIC,UAAEA,IAC3C,MAAMC,EAAUC,EAAMH,GAAQA,EAAOI,EAAMJ,IACrCK,UAAEA,SAAoBC,OAAO,wDAoBnC,MAAO,KAnBY,MAEf,GAAyB,iBAAdL,GAA0B,MAAOA,GAAa,MAAOA,EAAW,CACvE,MAAMM,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,QAAEA,GAAYT,EAEvBU,EAAcC,EADDC,OAAOH,GAAWD,IAErC,OAAO,IAAIJ,EAAUS,UAAUC,EAAYR,GAAIQ,EAAYP,IAAIQ,eAAeL,EAClF,CAEA,MAAMM,EAAed,EAAMF,GAAaA,EAAYG,EAAMH,GAC1D,GAA2B,KAAvBiB,EAAKD,GACL,MAAM,IAAIE,MAAM,4BACpB,MACMR,EAAcC,EADDQ,EAAY,KAAKH,EAAaI,MAAM,SAEvD,OAAOhB,EAAUS,UAAUQ,YAAYL,EAAaM,UAAU,EAAG,MAAMP,eAAeL,EACzF,EAfkB,GAiBdZ,iBAAiBG,EAAQqB,UAAU,IACnCnB,OAAM,IAEf,CACA,SAASQ,EAAcY,GACnB,GAAmB,IAAfA,GAAmC,IAAfA,EACpB,OAAOA,EACX,GAAmB,KAAfA,EACA,OAAO,EACX,GAAmB,KAAfA,EACA,OAAO,EACX,MAAM,IAAIL,MAAM,2BACpB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/signature/serializeSignature.js

@@ -1,2 +0,0 @@
-import{secp256k1 as r}from"../../../node_modules/@noble/curves/esm/secp256k1.js";import{hexToBigInt as o}from"../encoding/fromHex.js";import{hexToBytes as e}from"../encoding/toBytes.js";function n({r:n,s:t,to:i="hex",v:m,yParity:s}){const c=(()=>{if(0===s||1===s)return s;if(m&&(27n===m||28n===m||m>=35n))return m%2n==0n?1:0;throw new Error("Invalid `v` or `yParity` value")})(),u=`0x${new r.Signature(o(n),o(t)).toCompactHex()}${0===c?"1b":"1c"}`;return"hex"===i?u:e(u)}export{n as serializeSignature};
-//# sourceMappingURL=serializeSignature.js.map

package/dist/esm/node_modules/viem/_esm/utils/signature/serializeSignature.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializeSignature.js","sources":["../../../../../../../node_modules/viem/_esm/utils/signature/serializeSignature.js"],"sourcesContent":["import { secp256k1 } from '@noble/curves/secp256k1';\nimport { hexToBigInt } from '../encoding/fromHex.js';\nimport { hexToBytes } from '../encoding/toBytes.js';\n/**\n * @description Converts a signature into hex format.\n *\n * @param signature The signature to convert.\n * @returns The signature in hex format.\n *\n * @example\n * serializeSignature({\n *   r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',\n *   s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',\n *   yParity: 1\n * })\n * // \"0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c\"\n */\nexport function serializeSignature({ r, s, to = 'hex', v, yParity, }) {\n    const yParity_ = (() => {\n        if (yParity === 0 || yParity === 1)\n            return yParity;\n        if (v && (v === 27n || v === 28n || v >= 35n))\n            return v % 2n === 0n ? 1 : 0;\n        throw new Error('Invalid `v` or `yParity` value');\n    })();\n    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? '1b' : '1c'}`;\n    if (to === 'hex')\n        return signature;\n    return hexToBytes(signature);\n}\n//# sourceMappingURL=serializeSignature.js.map"],"names":["serializeSignature","r","s","to","v","yParity","yParity_","Error","signature","secp256k1","Signature","hexToBigInt","toCompactHex","hexToBytes"],"mappings":"0LAiBO,SAASA,GAAmBC,EAAEA,EAACC,EAAEA,EAACC,GAAEA,EAAK,MAAKC,EAAEA,EAACC,QAAEA,IACtD,MAAMC,EAAW,MACb,GAAgB,IAAZD,GAA6B,IAAZA,EACjB,OAAOA,EACX,GAAID,IAAY,MAANA,GAAmB,MAANA,GAAaA,GAAK,KACrC,OAAOA,EAAI,IAAO,GAAK,EAAI,EAC/B,MAAM,IAAIG,MAAM,iCACnB,EANgB,GAOXC,EAAY,KAAK,IAAIC,EAAUC,UAAUC,EAAYV,GAAIU,EAAYT,IAAIU,iBAA8B,IAAbN,EAAiB,KAAO,OACxH,MAAW,QAAPH,EACOK,EACJK,EAAWL,EACtB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toPrefixedMessage.js","sources":["../../../../../../../node_modules/viem/_esm/utils/signature/toPrefixedMessage.js"],"sourcesContent":["import { presignMessagePrefix } from '../../constants/strings.js';\nimport { concat } from '../data/concat.js';\nimport { size } from '../data/size.js';\nimport { bytesToHex, stringToHex, } from '../encoding/toHex.js';\nexport function toPrefixedMessage(message_) {\n    const message = (() => {\n        if (typeof message_ === 'string')\n            return stringToHex(message_);\n        if (typeof message_.raw === 'string')\n            return message_.raw;\n        return bytesToHex(message_.raw);\n    })();\n    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);\n    return concat([prefix, message]);\n}\n//# sourceMappingURL=toPrefixedMessage.js.map"],"names":["toPrefixedMessage","message_","message","stringToHex","raw","bytesToHex","prefix","presignMessagePrefix","size","concat"],"mappings":"uNAIO,SAASA,EAAkBC,GAC9B,MAAMC,EACsB,iBAAbD,EACAE,EAAYF,GACK,iBAAjBA,EAASG,IACTH,EAASG,IACbC,EAAWJ,EAASG,KAEzBE,EAASH,EAAY,GAAGI,IAAuBC,EAAKN,MAC1D,OAAOO,EAAO,CAACH,EAAQJ,GAC3B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseSiweMessage.js","sources":["../../../../../../../node_modules/viem/_esm/utils/siwe/parseSiweMessage.js"],"sourcesContent":["/**\n * @description Parses EIP-4361 formatted message into message fields object.\n *\n * @see https://eips.ethereum.org/EIPS/eip-4361\n *\n * @returns EIP-4361 fields object\n */\nexport function parseSiweMessage(message) {\n    const { scheme, statement, ...prefix } = (message.match(prefixRegex)\n        ?.groups ?? {});\n    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = (message.match(suffixRegex)?.groups ?? {});\n    const resources = message.split('Resources:')[1]?.split('\\n- ').slice(1);\n    return {\n        ...prefix,\n        ...suffix,\n        ...(chainId ? { chainId: Number(chainId) } : {}),\n        ...(expirationTime ? { expirationTime: new Date(expirationTime) } : {}),\n        ...(issuedAt ? { issuedAt: new Date(issuedAt) } : {}),\n        ...(notBefore ? { notBefore: new Date(notBefore) } : {}),\n        ...(requestId ? { requestId } : {}),\n        ...(resources ? { resources } : {}),\n        ...(scheme ? { scheme } : {}),\n        ...(statement ? { statement } : {}),\n    };\n}\n// https://regexr.com/80gdj\nconst prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\\/\\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\\n)(?<address>0x[a-fA-F0-9]{40})\\n\\n(?:(?<statement>.*)\\n\\n)?/;\n// https://regexr.com/80gf9\nconst suffixRegex = /(?:URI: (?<uri>.+))\\n(?:Version: (?<version>.+))\\n(?:Chain ID: (?<chainId>\\d+))\\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\\n(?:Issued At: (?<issuedAt>.+))(?:\\nExpiration Time: (?<expirationTime>.+))?(?:\\nNot Before: (?<notBefore>.+))?(?:\\nRequest ID: (?<requestId>.+))?/;\n//# sourceMappingURL=parseSiweMessage.js.map"],"names":["parseSiweMessage","message","scheme","statement","prefix","match","prefixRegex","groups","chainId","expirationTime","issuedAt","notBefore","requestId","suffix","suffixRegex","resources","split","slice","Number","Date"],"mappings":"AAOO,SAASA,EAAiBC,GAC7B,MAAMC,OAAEA,EAAMC,UAAEA,KAAcC,GAAYH,EAAQI,MAAMC,IAClDC,QAAU,CAAA,GACVC,QAAEA,EAAOC,eAAEA,EAAcC,SAAEA,EAAQC,UAAEA,EAASC,UAAEA,KAAcC,GAAYZ,EAAQI,MAAMS,IAAcP,QAAU,CAAA,EAChHQ,EAAYd,EAAQe,MAAM,cAAc,IAAIA,MAAM,QAAQC,MAAM,GACtE,MAAO,IACAb,KACAS,KACCL,EAAU,CAAEA,QAASU,OAAOV,IAAa,MACzCC,EAAiB,CAAEA,eAAgB,IAAIU,KAAKV,IAAoB,MAChEC,EAAW,CAAEA,SAAU,IAAIS,KAAKT,IAAc,MAC9CC,EAAY,CAAEA,UAAW,IAAIQ,KAAKR,IAAe,MACjDC,EAAY,CAAEA,aAAc,MAC5BG,EAAY,CAAEA,aAAc,MAC5Bb,EAAS,CAAEA,UAAW,MACtBC,EAAY,CAAEA,aAAc,GAExC,CAEA,MAAMG,EAAc,2MAEdQ,EAAc","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateSiweMessage.js","sources":["../../../../../../../node_modules/viem/_esm/utils/siwe/validateSiweMessage.js"],"sourcesContent":["import { isAddress } from '../address/isAddress.js';\nimport { isAddressEqual } from '../address/isAddressEqual.js';\n/**\n * @description Validates EIP-4361 message.\n *\n * @see https://eips.ethereum.org/EIPS/eip-4361\n */\nexport function validateSiweMessage(parameters) {\n    const { address, domain, message, nonce, scheme, time = new Date(), } = parameters;\n    if (domain && message.domain !== domain)\n        return false;\n    if (nonce && message.nonce !== nonce)\n        return false;\n    if (scheme && message.scheme !== scheme)\n        return false;\n    if (message.expirationTime && time >= message.expirationTime)\n        return false;\n    if (message.notBefore && time < message.notBefore)\n        return false;\n    try {\n        if (!message.address)\n            return false;\n        if (!isAddress(message.address, { strict: false }))\n            return false;\n        if (address && !isAddressEqual(message.address, address))\n            return false;\n    }\n    catch {\n        return false;\n    }\n    return true;\n}\n//# sourceMappingURL=validateSiweMessage.js.map"],"names":["validateSiweMessage","parameters","address","domain","message","nonce","scheme","time","Date","expirationTime","notBefore","isAddress","strict","isAddressEqual"],"mappings":"kHAOO,SAASA,EAAoBC,GAChC,MAAMC,QAAEA,EAAOC,OAAEA,EAAMC,QAAEA,EAAOC,MAAEA,EAAKC,OAAEA,EAAMC,KAAEA,EAAO,IAAIC,MAAYP,EACxE,GAAIE,GAAUC,EAAQD,SAAWA,EAC7B,OAAO,EACX,GAAIE,GAASD,EAAQC,QAAUA,EAC3B,OAAO,EACX,GAAIC,GAAUF,EAAQE,SAAWA,EAC7B,OAAO,EACX,GAAIF,EAAQK,gBAAkBF,GAAQH,EAAQK,eAC1C,OAAO,EACX,GAAIL,EAAQM,WAAaH,EAAOH,EAAQM,UACpC,OAAO,EACX,IACI,IAAKN,EAAQF,QACT,OAAO,EACX,IAAKS,EAAUP,EAAQF,QAAS,CAAEU,QAAQ,IACtC,OAAO,EACX,GAAIV,IAAYW,EAAeT,EAAQF,QAASA,GAC5C,OAAO,CACf,CACA,MACI,OAAO,CACX,CACA,OAAO,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/stateOverride.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stateOverride.js","sources":["../../../../../../node_modules/viem/_esm/utils/stateOverride.js"],"sourcesContent":["import { InvalidAddressError, } from '../errors/address.js';\nimport { InvalidBytesLengthError, } from '../errors/data.js';\nimport { AccountStateConflictError, StateAssignmentConflictError, } from '../errors/stateOverride.js';\nimport { isAddress } from './address/isAddress.js';\nimport { numberToHex } from './encoding/toHex.js';\n/** @internal */\nexport function serializeStateMapping(stateMapping) {\n    if (!stateMapping || stateMapping.length === 0)\n        return undefined;\n    return stateMapping.reduce((acc, { slot, value }) => {\n        if (slot.length !== 66)\n            throw new InvalidBytesLengthError({\n                size: slot.length,\n                targetSize: 66,\n                type: 'hex',\n            });\n        if (value.length !== 66)\n            throw new InvalidBytesLengthError({\n                size: value.length,\n                targetSize: 66,\n                type: 'hex',\n            });\n        acc[slot] = value;\n        return acc;\n    }, {});\n}\n/** @internal */\nexport function serializeAccountStateOverride(parameters) {\n    const { balance, nonce, state, stateDiff, code } = parameters;\n    const rpcAccountStateOverride = {};\n    if (code !== undefined)\n        rpcAccountStateOverride.code = code;\n    if (balance !== undefined)\n        rpcAccountStateOverride.balance = numberToHex(balance);\n    if (nonce !== undefined)\n        rpcAccountStateOverride.nonce = numberToHex(nonce);\n    if (state !== undefined)\n        rpcAccountStateOverride.state = serializeStateMapping(state);\n    if (stateDiff !== undefined) {\n        if (rpcAccountStateOverride.state)\n            throw new StateAssignmentConflictError();\n        rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);\n    }\n    return rpcAccountStateOverride;\n}\n/** @internal */\nexport function serializeStateOverride(parameters) {\n    if (!parameters)\n        return undefined;\n    const rpcStateOverride = {};\n    for (const { address, ...accountState } of parameters) {\n        if (!isAddress(address, { strict: false }))\n            throw new InvalidAddressError({ address });\n        if (rpcStateOverride[address])\n            throw new AccountStateConflictError({ address: address });\n        rpcStateOverride[address] = serializeAccountStateOverride(accountState);\n    }\n    return rpcStateOverride;\n}\n//# sourceMappingURL=stateOverride.js.map"],"names":["serializeStateMapping","stateMapping","length","reduce","acc","slot","value","InvalidBytesLengthError","size","targetSize","type","serializeAccountStateOverride","parameters","balance","nonce","state","stateDiff","code","rpcAccountStateOverride","undefined","numberToHex","StateAssignmentConflictError","serializeStateOverride","rpcStateOverride","address","accountState","isAddress","strict","InvalidAddressError","AccountStateConflictError"],"mappings":"qUAMO,SAASA,EAAsBC,GAClC,GAAKA,GAAwC,IAAxBA,EAAaC,OAElC,OAAOD,EAAaE,OAAO,CAACC,GAAOC,OAAMC,YACrC,GAAoB,KAAhBD,EAAKH,OACL,MAAM,IAAIK,EAAwB,CAC9BC,KAAMH,EAAKH,OACXO,WAAY,GACZC,KAAM,QAEd,GAAqB,KAAjBJ,EAAMJ,OACN,MAAM,IAAIK,EAAwB,CAC9BC,KAAMF,EAAMJ,OACZO,WAAY,GACZC,KAAM,QAGd,OADAN,EAAIC,GAAQC,EACLF,GACR,CAAA,EACP,CAEO,SAASO,EAA8BC,GAC1C,MAAMC,QAAEA,EAAOC,MAAEA,EAAKC,MAAEA,EAAKC,UAAEA,EAASC,KAAEA,GAASL,EAC7CM,EAA0B,CAAA,EAShC,QARaC,IAATF,IACAC,EAAwBD,KAAOA,QACnBE,IAAZN,IACAK,EAAwBL,QAAUO,EAAYP,SACpCM,IAAVL,IACAI,EAAwBJ,MAAQM,EAAYN,SAClCK,IAAVJ,IACAG,EAAwBH,MAAQf,EAAsBe,SACxCI,IAAdH,EAAyB,CACzB,GAAIE,EAAwBH,MACxB,MAAM,IAAIM,EACdH,EAAwBF,UAAYhB,EAAsBgB,EAC9D,CACA,OAAOE,CACX,CAEO,SAASI,EAAuBV,GACnC,IAAKA,EACD,OACJ,MAAMW,EAAmB,CAAA,EACzB,IAAK,MAAMC,QAAEA,KAAYC,KAAkBb,EAAY,CACnD,IAAKc,EAAUF,EAAS,CAAEG,QAAQ,IAC9B,MAAM,IAAIC,EAAoB,CAAEJ,YACpC,GAAID,EAAiBC,GACjB,MAAM,IAAIK,EAA0B,CAAEL,QAASA,IACnDD,EAAiBC,GAAWb,EAA8Bc,EAC9D,CACA,OAAOF,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/stringify.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stringify.js","sources":["../../../../../../node_modules/viem/_esm/utils/stringify.js"],"sourcesContent":["export const stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {\n    const value = typeof value_ === 'bigint' ? value_.toString() : value_;\n    return typeof replacer === 'function' ? replacer(key, value) : value;\n}, space);\n//# sourceMappingURL=stringify.js.map"],"names":["stringify","value","replacer","space","JSON","key","value_","toString"],"mappings":"AAAY,MAACA,EAAY,CAACC,EAAOC,EAAUC,IAAUC,KAAKJ,UAAUC,EAAO,CAACI,EAAKC,IAC7C,iBAAXA,EAAsBA,EAAOC,WAAaD,EAEhEH","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/transaction/assertRequest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertRequest.js","sources":["../../../../../../../node_modules/viem/_esm/utils/transaction/assertRequest.js"],"sourcesContent":["import { parseAccount, } from '../../accounts/utils/parseAccount.js';\nimport { maxUint256 } from '../../constants/number.js';\nimport { InvalidAddressError, } from '../../errors/address.js';\nimport { FeeCapTooHighError, TipAboveFeeCapError, } from '../../errors/node.js';\nimport { FeeConflictError, } from '../../errors/transaction.js';\nimport { isAddress } from '../address/isAddress.js';\nexport function assertRequest(args) {\n    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to, } = args;\n    const account = account_ ? parseAccount(account_) : undefined;\n    if (account && !isAddress(account.address))\n        throw new InvalidAddressError({ address: account.address });\n    if (to && !isAddress(to))\n        throw new InvalidAddressError({ address: to });\n    if (typeof gasPrice !== 'undefined' &&\n        (typeof maxFeePerGas !== 'undefined' ||\n            typeof maxPriorityFeePerGas !== 'undefined'))\n        throw new FeeConflictError();\n    if (maxFeePerGas && maxFeePerGas > maxUint256)\n        throw new FeeCapTooHighError({ maxFeePerGas });\n    if (maxPriorityFeePerGas &&\n        maxFeePerGas &&\n        maxPriorityFeePerGas > maxFeePerGas)\n        throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });\n}\n//# sourceMappingURL=assertRequest.js.map"],"names":["assertRequest","args","account","account_","gasPrice","maxFeePerGas","maxPriorityFeePerGas","to","parseAccount","undefined","isAddress","address","InvalidAddressError","FeeConflictError","maxUint256","FeeCapTooHighError","TipAboveFeeCapError"],"mappings":"+XAMO,SAASA,EAAcC,GAC1B,MAAQC,QAASC,EAAQC,SAAEA,EAAQC,aAAEA,EAAYC,qBAAEA,EAAoBC,GAAEA,GAAQN,EAC3EC,EAAUC,EAAWK,EAAaL,QAAYM,EACpD,GAAIP,IAAYQ,EAAUR,EAAQS,SAC9B,MAAM,IAAIC,EAAoB,CAAED,QAAST,EAAQS,UACrD,GAAIJ,IAAOG,EAAUH,GACjB,MAAM,IAAIK,EAAoB,CAAED,QAASJ,IAC7C,QAAwB,IAAbH,SACkB,IAAjBC,QAC4B,IAAzBC,GACX,MAAM,IAAIO,EACd,GAAIR,GAAgBA,EAAeS,EAC/B,MAAM,IAAIC,EAAmB,CAAEV,iBACnC,GAAIC,GACAD,GACAC,EAAuBD,EACvB,MAAM,IAAIW,EAAoB,CAAEX,eAAcC,wBACtD","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/transaction/getTransactionType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getTransactionType.js","sources":["../../../../../../../node_modules/viem/_esm/utils/transaction/getTransactionType.js"],"sourcesContent":["import { InvalidSerializableTransactionError, } from '../../errors/transaction.js';\nexport function getTransactionType(transaction) {\n    if (transaction.type)\n        return transaction.type;\n    if (typeof transaction.authorizationList !== 'undefined')\n        return 'eip7702';\n    if (typeof transaction.blobs !== 'undefined' ||\n        typeof transaction.blobVersionedHashes !== 'undefined' ||\n        typeof transaction.maxFeePerBlobGas !== 'undefined' ||\n        typeof transaction.sidecars !== 'undefined')\n        return 'eip4844';\n    if (typeof transaction.maxFeePerGas !== 'undefined' ||\n        typeof transaction.maxPriorityFeePerGas !== 'undefined') {\n        return 'eip1559';\n    }\n    if (typeof transaction.gasPrice !== 'undefined') {\n        if (typeof transaction.accessList !== 'undefined')\n            return 'eip2930';\n        return 'legacy';\n    }\n    throw new InvalidSerializableTransactionError({ transaction });\n}\n//# sourceMappingURL=getTransactionType.js.map"],"names":["getTransactionType","transaction","type","authorizationList","blobs","blobVersionedHashes","maxFeePerBlobGas","sidecars","maxFeePerGas","maxPriorityFeePerGas","gasPrice","accessList","InvalidSerializableTransactionError"],"mappings":"kFACO,SAASA,EAAmBC,GAC/B,GAAIA,EAAYC,KACZ,OAAOD,EAAYC,KACvB,QAA6C,IAAlCD,EAAYE,kBACnB,MAAO,UACX,QAAiC,IAAtBF,EAAYG,YACwB,IAApCH,EAAYI,0BACqB,IAAjCJ,EAAYK,uBACa,IAAzBL,EAAYM,SACnB,MAAO,UACX,QAAwC,IAA7BN,EAAYO,mBACyB,IAArCP,EAAYQ,qBACnB,MAAO,UAEX,QAAoC,IAAzBR,EAAYS,SACnB,YAAsC,IAA3BT,EAAYU,WACZ,UACJ,SAEX,MAAM,IAAIC,EAAoC,CAAEX,eACpD","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/typedData.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"typedData.js","sources":["../../../../../../node_modules/viem/_esm/utils/typedData.js"],"sourcesContent":["import { BytesSizeMismatchError } from '../errors/abi.js';\nimport { InvalidAddressError } from '../errors/address.js';\nimport { InvalidDomainError, InvalidPrimaryTypeError, InvalidStructTypeError, } from '../errors/typedData.js';\nimport { isAddress } from './address/isAddress.js';\nimport { size } from './data/size.js';\nimport { numberToHex } from './encoding/toHex.js';\nimport { bytesRegex, integerRegex } from './regex.js';\nimport { hashDomain, } from './signature/hashTypedData.js';\nimport { stringify } from './stringify.js';\nexport function serializeTypedData(parameters) {\n    const { domain: domain_, message: message_, primaryType, types, } = parameters;\n    const normalizeData = (struct, data_) => {\n        const data = { ...data_ };\n        for (const param of struct) {\n            const { name, type } = param;\n            if (type === 'address')\n                data[name] = data[name].toLowerCase();\n        }\n        return data;\n    };\n    const domain = (() => {\n        if (!types.EIP712Domain)\n            return {};\n        if (!domain_)\n            return {};\n        return normalizeData(types.EIP712Domain, domain_);\n    })();\n    const message = (() => {\n        if (primaryType === 'EIP712Domain')\n            return undefined;\n        return normalizeData(types[primaryType], message_);\n    })();\n    return stringify({ domain, message, primaryType, types });\n}\nexport function validateTypedData(parameters) {\n    const { domain, message, primaryType, types } = parameters;\n    const validateData = (struct, data) => {\n        for (const param of struct) {\n            const { name, type } = param;\n            const value = data[name];\n            const integerMatch = type.match(integerRegex);\n            if (integerMatch &&\n                (typeof value === 'number' || typeof value === 'bigint')) {\n                const [_type, base, size_] = integerMatch;\n                // If number cannot be cast to a sized hex value, it is out of range\n                // and will throw.\n                numberToHex(value, {\n                    signed: base === 'int',\n                    size: Number.parseInt(size_, 10) / 8,\n                });\n            }\n            if (type === 'address' && typeof value === 'string' && !isAddress(value))\n                throw new InvalidAddressError({ address: value });\n            const bytesMatch = type.match(bytesRegex);\n            if (bytesMatch) {\n                const [_type, size_] = bytesMatch;\n                if (size_ && size(value) !== Number.parseInt(size_, 10))\n                    throw new BytesSizeMismatchError({\n                        expectedSize: Number.parseInt(size_, 10),\n                        givenSize: size(value),\n                    });\n            }\n            const struct = types[type];\n            if (struct) {\n                validateReference(type);\n                validateData(struct, value);\n            }\n        }\n    };\n    // Validate domain types.\n    if (types.EIP712Domain && domain) {\n        if (typeof domain !== 'object')\n            throw new InvalidDomainError({ domain });\n        validateData(types.EIP712Domain, domain);\n    }\n    // Validate message types.\n    if (primaryType !== 'EIP712Domain') {\n        if (types[primaryType])\n            validateData(types[primaryType], message);\n        else\n            throw new InvalidPrimaryTypeError({ primaryType, types });\n    }\n}\nexport function getTypesForEIP712Domain({ domain, }) {\n    return [\n        typeof domain?.name === 'string' && { name: 'name', type: 'string' },\n        domain?.version && { name: 'version', type: 'string' },\n        (typeof domain?.chainId === 'number' ||\n            typeof domain?.chainId === 'bigint') && {\n            name: 'chainId',\n            type: 'uint256',\n        },\n        domain?.verifyingContract && {\n            name: 'verifyingContract',\n            type: 'address',\n        },\n        domain?.salt && { name: 'salt', type: 'bytes32' },\n    ].filter(Boolean);\n}\nexport function domainSeparator({ domain }) {\n    return hashDomain({\n        domain,\n        types: {\n            EIP712Domain: getTypesForEIP712Domain({ domain }),\n        },\n    });\n}\n/** @internal */\nfunction validateReference(type) {\n    // Struct type must not be a Solidity type.\n    if (type === 'address' ||\n        type === 'bool' ||\n        type === 'string' ||\n        type.startsWith('bytes') ||\n        type.startsWith('uint') ||\n        type.startsWith('int'))\n        throw new InvalidStructTypeError({ type });\n}\n//# sourceMappingURL=typedData.js.map"],"names":["validateTypedData","parameters","domain","message","primaryType","types","validateData","struct","data","param","name","type","value","integerMatch","match","integerRegex","_type","base","size_","numberToHex","signed","size","Number","parseInt","isAddress","InvalidAddressError","address","bytesMatch","bytesRegex","BytesSizeMismatchError","expectedSize","givenSize","validateReference","EIP712Domain","InvalidDomainError","InvalidPrimaryTypeError","getTypesForEIP712Domain","version","chainId","verifyingContract","salt","filter","Boolean","startsWith","InvalidStructTypeError"],"mappings":"+aAkCO,SAASA,EAAkBC,GAC9B,MAAMC,OAAEA,EAAMC,QAAEA,EAAOC,YAAEA,EAAWC,MAAEA,GAAUJ,EAC1CK,EAAe,CAACC,EAAQC,KAC1B,IAAK,MAAMC,KAASF,EAAQ,CACxB,MAAMG,KAAEA,EAAIC,KAAEA,GAASF,EACjBG,EAAQJ,EAAKE,GACbG,EAAeF,EAAKG,MAAMC,GAChC,GAAIF,IACkB,iBAAVD,GAAuC,iBAAVA,GAAqB,CAC1D,MAAOI,EAAOC,EAAMC,GAASL,EAG7BM,EAAYP,EAAO,CACfQ,OAAiB,QAATH,EACRI,KAAMC,OAAOC,SAASL,EAAO,IAAM,GAE3C,CACA,GAAa,YAATP,GAAuC,iBAAVC,IAAuBY,EAAUZ,GAC9D,MAAM,IAAIa,EAAoB,CAAEC,QAASd,IAC7C,MAAMe,EAAahB,EAAKG,MAAMc,GAC9B,GAAID,EAAY,CACZ,MAAOX,EAAOE,GAASS,EACvB,GAAIT,GAASG,EAAKT,KAAWU,OAAOC,SAASL,EAAO,IAChD,MAAM,IAAIW,EAAuB,CAC7BC,aAAcR,OAAOC,SAASL,EAAO,IACrCa,UAAWV,EAAKT,IAE5B,CACA,MAAML,EAASF,EAAMM,GACjBJ,IACAyB,EAAkBrB,GAClBL,EAAaC,EAAQK,GAE7B,GAGJ,GAAIP,EAAM4B,cAAgB/B,EAAQ,CAC9B,GAAsB,iBAAXA,EACP,MAAM,IAAIgC,EAAmB,CAAEhC,WACnCI,EAAaD,EAAM4B,aAAc/B,EACrC,CAEA,GAAoB,iBAAhBE,EAAgC,CAChC,IAAIC,EAAMD,GAGN,MAAM,IAAI+B,EAAwB,CAAE/B,cAAaC,UAFjDC,EAAaD,EAAMD,GAAcD,EAGzC,CACJ,CACO,SAASiC,GAAwBlC,OAAEA,IACtC,MAAO,CACqB,iBAAjBA,GAAQQ,MAAqB,CAAEA,KAAM,OAAQC,KAAM,UAC1DT,GAAQmC,SAAW,CAAE3B,KAAM,UAAWC,KAAM,WAChB,iBAApBT,GAAQoC,SACe,iBAApBpC,GAAQoC,UAAyB,CACxC5B,KAAM,UACNC,KAAM,WAEVT,GAAQqC,mBAAqB,CACzB7B,KAAM,oBACNC,KAAM,WAEVT,GAAQsC,MAAQ,CAAE9B,KAAM,OAAQC,KAAM,YACxC8B,OAAOC,QACb,CAUA,SAASV,EAAkBrB,GAEvB,GAAa,YAATA,GACS,SAATA,GACS,WAATA,GACAA,EAAKgC,WAAW,UAChBhC,EAAKgC,WAAW,SAChBhC,EAAKgC,WAAW,OAChB,MAAM,IAAIC,EAAuB,CAAEjC,QAC3C","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/uid.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"uid.js","sources":["../../../../../../node_modules/viem/_esm/utils/uid.js"],"sourcesContent":["const size = 256;\nlet index = size;\nlet buffer;\nexport function uid(length = 11) {\n    if (!buffer || index + length > size * 2) {\n        buffer = '';\n        index = 0;\n        for (let i = 0; i < size; i++) {\n            buffer += ((256 + Math.random() * 256) | 0).toString(16).substring(1);\n        }\n    }\n    return buffer.substring(index, index++ + length);\n}\n//# sourceMappingURL=uid.js.map"],"names":["buffer","index","uid","length","size","i","Math","random","toString","substring"],"mappings":"AACA,IACIA,EADAC,EADS,IAGN,SAASC,EAAIC,EAAS,IACzB,IAAKH,GAAUC,EAAQE,EAASC,IAAU,CACtCJ,EAAS,GACTC,EAAQ,EACR,IAAK,IAAII,EAAI,EAAGA,EAPX,IAOqBA,IACtBL,IAAY,IAAsB,IAAhBM,KAAKC,SAAkB,GAAGC,SAAS,IAAIC,UAAU,EAE3E,CACA,OAAOT,EAAOS,UAAUR,EAAOA,IAAUE,EAC7C","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/unit/formatEther.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatEther.js","sources":["../../../../../../../node_modules/viem/_esm/utils/unit/formatEther.js"],"sourcesContent":["import { etherUnits } from '../../constants/unit.js';\nimport { formatUnits } from './formatUnits.js';\n/**\n * Converts numerical wei to a string representation of ether.\n *\n * - Docs: https://viem.sh/docs/utilities/formatEther\n *\n * @example\n * import { formatEther } from 'viem'\n *\n * formatEther(1000000000000000000n)\n * // '1'\n */\nexport function formatEther(wei, unit = 'wei') {\n    return formatUnits(wei, etherUnits[unit]);\n}\n//# sourceMappingURL=formatEther.js.map"],"names":["formatEther","wei","unit","formatUnits","etherUnits"],"mappings":"oGAaO,SAASA,EAAYC,EAAKC,EAAO,OACpC,OAAOC,EAAYF,EAAKG,EAAWF,GACvC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/unit/formatGwei.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatGwei.js","sources":["../../../../../../../node_modules/viem/_esm/utils/unit/formatGwei.js"],"sourcesContent":["import { gweiUnits } from '../../constants/unit.js';\nimport { formatUnits } from './formatUnits.js';\n/**\n * Converts numerical wei to a string representation of gwei.\n *\n * - Docs: https://viem.sh/docs/utilities/formatGwei\n *\n * @example\n * import { formatGwei } from 'viem'\n *\n * formatGwei(1000000000n)\n * // '1'\n */\nexport function formatGwei(wei, unit = 'wei') {\n    return formatUnits(wei, gweiUnits[unit]);\n}\n//# sourceMappingURL=formatGwei.js.map"],"names":["formatGwei","wei","unit","formatUnits","gweiUnits"],"mappings":"mGAaO,SAASA,EAAWC,EAAKC,EAAO,OACnC,OAAOC,EAAYF,EAAKG,EAAUF,GACtC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/unit/formatUnits.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatUnits.js","sources":["../../../../../../../node_modules/viem/_esm/utils/unit/formatUnits.js"],"sourcesContent":["/**\n *  Divides a number by a given exponent of base 10 (10exponent), and formats it into a string representation of the number..\n *\n * - Docs: https://viem.sh/docs/utilities/formatUnits\n *\n * @example\n * import { formatUnits } from 'viem'\n *\n * formatUnits(420000000000n, 9)\n * // '420'\n */\nexport function formatUnits(value, decimals) {\n    let display = value.toString();\n    const negative = display.startsWith('-');\n    if (negative)\n        display = display.slice(1);\n    display = display.padStart(decimals, '0');\n    let [integer, fraction] = [\n        display.slice(0, display.length - decimals),\n        display.slice(display.length - decimals),\n    ];\n    fraction = fraction.replace(/(0+)$/, '');\n    return `${negative ? '-' : ''}${integer || '0'}${fraction ? `.${fraction}` : ''}`;\n}\n//# sourceMappingURL=formatUnits.js.map"],"names":["formatUnits","value","decimals","display","toString","negative","startsWith","slice","padStart","integer","fraction","length","replace"],"mappings":"AAWO,SAASA,EAAYC,EAAOC,GAC/B,IAAIC,EAAUF,EAAMG,WACpB,MAAMC,EAAWF,EAAQG,WAAW,KAChCD,IACAF,EAAUA,EAAQI,MAAM,IAC5BJ,EAAUA,EAAQK,SAASN,EAAU,KACrC,IAAKO,EAASC,GAAY,CACtBP,EAAQI,MAAM,EAAGJ,EAAQQ,OAAST,GAClCC,EAAQI,MAAMJ,EAAQQ,OAAST,IAGnC,OADAQ,EAAWA,EAASE,QAAQ,QAAS,IAC9B,GAAGP,EAAW,IAAM,KAAKI,GAAW,MAAMC,EAAW,IAAIA,IAAa,IACjF","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/wait.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wait.js","sources":["../../../../../../node_modules/viem/_esm/utils/wait.js"],"sourcesContent":["export async function wait(time) {\n    return new Promise((res) => setTimeout(res, time));\n}\n//# sourceMappingURL=wait.js.map"],"names":["async","wait","time","Promise","res","setTimeout"],"mappings":"AAAOA,eAAeC,EAAKC,GACvB,OAAO,IAAIC,QAASC,GAAQC,WAAWD,EAAKF,GAChD","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/node_modules/@noble/curves/esm/_shortw_utils.js

@@ -1,3 +0,0 @@
-import{hmac as s}from"../../../../../@noble/hashes/esm/hmac.js";import{randomBytes as r,concatBytes as t}from"../../../../../@noble/hashes/esm/utils.js";import{weierstrass as e}from"./abstract/weierstrass.js";
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */function o(e){return{hash:e,hmac:(r,...o)=>s(e,r,t(...o)),randomBytes:r}}function m(s,r){const t=r=>e({...s,...o(r)});return{...t(r),create:t}}export{m as createCurve,o as getHash};
-//# sourceMappingURL=_shortw_utils.js.map

package/dist/esm/node_modules/viem/node_modules/@noble/curves/esm/_shortw_utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_shortw_utils.js","sources":["../../../../../../../../node_modules/viem/node_modules/@noble/curves/esm/_shortw_utils.js"],"sourcesContent":["/**\n * Utilities for short weierstrass curves, combined with noble-hashes.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac } from '@noble/hashes/hmac';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils';\nimport { weierstrass } from \"./abstract/weierstrass.js\";\n/** connects noble-curves to noble-hashes */\nexport function getHash(hash) {\n    return {\n        hash,\n        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),\n        randomBytes,\n    };\n}\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });\n    return { ...create(defHash), create };\n}\n//# sourceMappingURL=_shortw_utils.js.map"],"names":["getHash","hash","hmac","key","msgs","concatBytes","randomBytes","createCurve","curveDef","defHash","create","weierstrass"],"mappings":";sEASO,SAASA,EAAQC,GACpB,MAAO,CACHA,OACAC,KAAM,CAACC,KAAQC,IAASF,EAAKD,EAAME,EAAKE,KAAeD,IACvDE,cAER,CACO,SAASC,EAAYC,EAAUC,GAClC,MAAMC,EAAUT,GAASU,EAAY,IAAKH,KAAaR,EAAQC,KAC/D,MAAO,IAAKS,EAAOD,GAAUC,SACjC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/node_modules/@noble/curves/esm/abstract/curve.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"curve.js","sources":["../../../../../../../../../node_modules/viem/node_modules/@noble/curves/esm/abstract/curve.js"],"sourcesContent":["/**\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 { nLength, validateField } from \"./modular.js\";\nimport { bitLen, bitMask, validateObject } from \"./utils.js\";\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nfunction constTimeNegate(condition, item) {\n    const neg = item.negate();\n    return condition ? neg : item;\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    return pointWindowSizes.get(P) || 1;\n}\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\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 function wNAF(c, bits) {\n    return {\n        constTimeNegate,\n        hasPrecomputes(elm) {\n            return getW(elm) !== 1;\n        },\n        // non-const time multiplication ladder\n        unsafeLadder(elm, n, p = c.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 elm Point instance\n         * @param W window size\n         * @returns precomputed point tables flattened to a single array\n         */\n        precomputeWindow(elm, W) {\n            const { windows, windowSize } = calcWOpts(W, bits);\n            const points = [];\n            let p = elm;\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         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @returns real and fake (for const-time) points\n         */\n        wNAF(W, precomputes, n) {\n            // Smaller version:\n            // https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541\n            // TODO: check the scalar is less than group order?\n            // wNAF behavior is undefined otherwise. But have to carefully remove\n            // other checks before wNAF. ORDER == bits here.\n            // Accumulators\n            let p = c.ZERO;\n            let f = c.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, 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(constTimeNegate(isNegF, precomputes[offsetF]));\n                }\n                else {\n                    // bits are 1: add to result point\n                    p = p.add(constTimeNegate(isNeg, precomputes[offset]));\n                }\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 W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @param acc accumulator point to add result of multiplication\n         * @returns point\n         */\n        wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {\n            const wo = calcWOpts(W, 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            return acc;\n        },\n        getPrecomputes(W, P, transform) {\n            // Calculate precomputes on a first run, reuse them after\n            let comp = pointPrecomputes.get(P);\n            if (!comp) {\n                comp = this.precomputeWindow(P, W);\n                if (W !== 1)\n                    pointPrecomputes.set(P, transform(comp));\n            }\n            return comp;\n        },\n        wNAFCached(P, n, transform) {\n            const W = getW(P);\n            return this.wNAF(W, this.getPrecomputes(W, P, transform), n);\n        },\n        wNAFCachedUnsafe(P, n, transform, prev) {\n            const W = getW(P);\n            if (W === 1)\n                return this.unsafeLadder(P, n, prev); // For W=1 ladder is ~x2 faster\n            return this.wNAFUnsafe(W, this.getPrecomputes(W, P, transform), n, 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        setWindowSize(P, W) {\n            validateW(W, bits);\n            pointWindowSizes.set(P, W);\n            pointPrecomputes.delete(P);\n        },\n    };\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 private keys / bigints)\n */\nexport function pippenger(c, fieldN, 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    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, fieldN, 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    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}\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\n//# sourceMappingURL=curve.js.map"],"names":["_0n","BigInt","_1n","constTimeNegate","condition","item","neg","negate","validateW","W","bits","Number","isSafeInteger","Error","calcWOpts","scalarBits","maxNumber","windows","Math","ceil","windowSize","mask","bitMask","shiftBy","calcOffsets","n","window","wOpts","wbits","nextN","offsetStart","offset","abs","isZero","isNeg","isNegF","offsetF","pointPrecomputes","WeakMap","pointWindowSizes","getW","P","get","wNAF","c","hasPrecomputes","elm","unsafeLadder","p","ZERO","d","add","double","precomputeWindow","points","base","push","i","precomputes","f","BASE","wo","wNAFUnsafe","acc","getPrecomputes","transform","comp","this","set","wNAFCached","wNAFCachedUnsafe","prev","setWindowSize","delete","pippenger","fieldN","scalars","Array","isArray","forEach","validateMSMPoints","field","s","isValid","validateMSMScalars","plength","length","slength","zero","bitLen","MASK","buckets","fill","sum","floor","BITS","j","scalar","resI","sumI","validateBasic","curve","validateField","Fp","validateObject","h","Gx","Gy","nBitLength","nByteLength","Object","freeze","nLength","ORDER"],"mappings":";sEAQA,MAAMA,EAAMC,OAAO,GACbC,EAAMD,OAAO,GACnB,SAASE,EAAgBC,EAAWC,GAChC,MAAMC,EAAMD,EAAKE,SACjB,OAAOH,EAAYE,EAAMD,CAC7B,CACA,SAASG,EAAUC,EAAGC,GAClB,IAAKC,OAAOC,cAAcH,IAAMA,GAAK,GAAKA,EAAIC,EAC1C,MAAM,IAAIG,MAAM,qCAAuCH,EAAO,YAAcD,EACpF,CACA,SAASK,EAAUL,EAAGM,GAClBP,EAAUC,EAAGM,GACb,MAEMC,EAAY,GAAKP,EAGvB,MAAO,CAAEQ,QALOC,KAAKC,KAAKJ,EAAaN,GAAK,EAK1BW,WAJC,IAAMX,EAAI,GAICY,KAFjBC,EAAQb,GAEeO,YAAWO,QAD/BtB,OAAOQ,GAE3B,CACA,SAASe,EAAYC,EAAGC,EAAQC,GAC5B,MAAMP,WAAEA,EAAUC,KAAEA,EAAIL,UAAEA,EAASO,QAAEA,GAAYI,EACjD,IAAIC,EAAQjB,OAAOc,EAAIJ,GACnBQ,EAAQJ,GAAKF,EAMbK,EAAQR,IAERQ,GAASZ,EACTa,GAAS3B,GAEb,MAAM4B,EAAcJ,EAASN,EAM7B,MAAO,CAAES,QAAOE,OALDD,EAAcZ,KAAKc,IAAIJ,GAAS,EAKvBK,OAJC,IAAVL,EAIiBM,MAHlBN,EAAQ,EAGiBO,OAFxBT,EAAS,GAAM,EAEiBU,QAD/BN,EAEpB,CAoBA,MAAMO,EAAmB,IAAIC,QACvBC,EAAmB,IAAID,QAC7B,SAASE,EAAKC,GACV,OAAOF,EAAiBG,IAAID,IAAM,CACtC,CAeO,SAASE,EAAKC,EAAGlC,GACpB,MAAO,CACHP,kBACA0C,eAAeC,GACU,IAAdN,EAAKM,GAGhB,YAAAC,CAAaD,EAAKrB,EAAGuB,EAAIJ,EAAEK,MACvB,IAAIC,EAAIJ,EACR,KAAOrB,EAAIzB,GACHyB,EAAIvB,IACJ8C,EAAIA,EAAEG,IAAID,IACdA,EAAIA,EAAEE,SACN3B,IAAMvB,EAEV,OAAO8C,CACX,EAaA,gBAAAK,CAAiBP,EAAKrC,GAClB,MAAMQ,QAAEA,EAAOG,WAAEA,GAAeN,EAAUL,EAAGC,GACvC4C,EAAS,GACf,IAAIN,EAAIF,EACJS,EAAOP,EACX,IAAK,IAAItB,EAAS,EAAGA,EAAST,EAASS,IAAU,CAC7C6B,EAAOP,EACPM,EAAOE,KAAKD,GAEZ,IAAK,IAAIE,EAAI,EAAGA,EAAIrC,EAAYqC,IAC5BF,EAAOA,EAAKJ,IAAIH,GAChBM,EAAOE,KAAKD,GAEhBP,EAAIO,EAAKH,QACb,CACA,OAAOE,CACX,EAQA,IAAAX,CAAKlC,EAAGiD,EAAajC,GAOjB,IAAIuB,EAAIJ,EAAEK,KACNU,EAAIf,EAAEgB,KAMV,MAAMC,EAAK/C,EAAUL,EAAGC,GACxB,IAAK,IAAIgB,EAAS,EAAGA,EAASmC,EAAG5C,QAASS,IAAU,CAEhD,MAAMG,MAAEA,EAAKE,OAAEA,EAAME,OAAEA,EAAMC,MAAEA,EAAKC,OAAEA,EAAMC,QAAEA,GAAYZ,EAAYC,EAAGC,EAAQmC,GACjFpC,EAAII,EACAI,EAGA0B,EAAIA,EAAER,IAAIhD,EAAgBgC,EAAQuB,EAAYtB,KAI9CY,EAAIA,EAAEG,IAAIhD,EAAgB+B,EAAOwB,EAAY3B,IAErD,CAIA,MAAO,CAAEiB,IAAGW,IAChB,EASA,UAAAG,CAAWrD,EAAGiD,EAAajC,EAAGsC,EAAMnB,EAAEK,MAClC,MAAMY,EAAK/C,EAAUL,EAAGC,GACxB,IAAK,IAAIgB,EAAS,EAAGA,EAASmC,EAAG5C,SACzBQ,IAAMzB,EAD4B0B,IAAU,CAGhD,MAAMG,MAAEA,EAAKE,OAAEA,EAAME,OAAEA,EAAMC,MAAEA,GAAUV,EAAYC,EAAGC,EAAQmC,GAEhE,GADApC,EAAII,GACAI,EAKC,CACD,MAAM5B,EAAOqD,EAAY3B,GACzBgC,EAAMA,EAAIZ,IAAIjB,EAAQ7B,EAAKE,SAAWF,EAC1C,CACJ,CACA,OAAO0D,CACX,EACA,cAAAC,CAAevD,EAAGgC,EAAGwB,GAEjB,IAAIC,EAAO7B,EAAiBK,IAAID,GAMhC,OALKyB,IACDA,EAAOC,KAAKd,iBAAiBZ,EAAGhC,GACtB,IAANA,GACA4B,EAAiB+B,IAAI3B,EAAGwB,EAAUC,KAEnCA,CACX,EACA,UAAAG,CAAW5B,EAAGhB,EAAGwC,GACb,MAAMxD,EAAI+B,EAAKC,GACf,OAAO0B,KAAKxB,KAAKlC,EAAG0D,KAAKH,eAAevD,EAAGgC,EAAGwB,GAAYxC,EAC9D,EACA,gBAAA6C,CAAiB7B,EAAGhB,EAAGwC,EAAWM,GAC9B,MAAM9D,EAAI+B,EAAKC,GACf,OAAU,IAANhC,EACO0D,KAAKpB,aAAaN,EAAGhB,EAAG8C,GAC5BJ,KAAKL,WAAWrD,EAAG0D,KAAKH,eAAevD,EAAGgC,EAAGwB,GAAYxC,EAAG8C,EACvE,EAIA,aAAAC,CAAc/B,EAAGhC,GACbD,EAAUC,EAAGC,GACb6B,EAAiB6B,IAAI3B,EAAGhC,GACxB4B,EAAiBoC,OAAOhC,EAC5B,EAER,CAWO,SAASiC,EAAU9B,EAAG+B,EAAQrB,EAAQsB,IAhM7C,SAA2BtB,EAAQV,GAC/B,IAAKiC,MAAMC,QAAQxB,GACf,MAAM,IAAIzC,MAAM,kBACpByC,EAAOyB,QAAQ,CAAC/B,EAAGS,KACf,KAAMT,aAAaJ,GACf,MAAM,IAAI/B,MAAM,0BAA4B4C,IAExD,CAgMIuB,CAAkB1B,EAAQV,GA/L9B,SAA4BgC,EAASK,GACjC,IAAKJ,MAAMC,QAAQF,GACf,MAAM,IAAI/D,MAAM,6BACpB+D,EAAQG,QAAQ,CAACG,EAAGzB,KAChB,IAAKwB,EAAME,QAAQD,GACf,MAAM,IAAIrE,MAAM,2BAA6B4C,IAEzD,CAyLI2B,CAAmBR,EAASD,GAC5B,MAAMU,EAAU/B,EAAOgC,OACjBC,EAAUX,EAAQU,OACxB,GAAID,IAAYE,EACZ,MAAM,IAAI1E,MAAM,uDAEpB,MAAM2E,EAAO5C,EAAEK,KACTrB,EAAQ6D,EAAOxF,OAAOoF,IAC5B,IAAIjE,EAAa,EACbQ,EAAQ,GACRR,EAAaQ,EAAQ,EAChBA,EAAQ,EACbR,EAAaQ,EAAQ,EAChBA,EAAQ,IACbR,EAAa,GACjB,MAAMsE,EAAOpE,EAAQF,GACfuE,EAAU,IAAId,MAAMlE,OAAO+E,GAAQ,GAAGE,KAAKJ,GAEjD,IAAIK,EAAML,EACV,IAAK,IAAI/B,EAFQvC,KAAK4E,OAAOnB,EAAOoB,KAAO,GAAK3E,GAAcA,EAEvCqC,GAAK,EAAGA,GAAKrC,EAAY,CAC5CuE,EAAQC,KAAKJ,GACb,IAAK,IAAIQ,EAAI,EAAGA,EAAIT,EAASS,IAAK,CAC9B,MAAMC,EAASrB,EAAQoB,GACjBpE,EAAQjB,OAAQsF,GAAUhG,OAAOwD,GAAMiC,GAC7CC,EAAQ/D,GAAS+D,EAAQ/D,GAAOuB,IAAIG,EAAO0C,GAC/C,CACA,IAAIE,EAAOV,EAEX,IAAK,IAAIQ,EAAIL,EAAQL,OAAS,EAAGa,EAAOX,EAAMQ,EAAI,EAAGA,IACjDG,EAAOA,EAAKhD,IAAIwC,EAAQK,IACxBE,EAAOA,EAAK/C,IAAIgD,GAGpB,GADAN,EAAMA,EAAI1C,IAAI+C,GACJ,IAANzC,EACA,IAAK,IAAIuC,EAAI,EAAGA,EAAI5E,EAAY4E,IAC5BH,EAAMA,EAAIzC,QACtB,CACA,OAAOyC,CACX,CAgFO,SAASO,EAAcC,GAY1B,OAXAC,EAAcD,EAAME,IACpBC,EAAeH,EAAO,CAClB5E,EAAG,SACHgF,EAAG,SACHC,GAAI,QACJC,GAAI,SACL,CACCC,WAAY,gBACZC,YAAa,kBAGVC,OAAOC,OAAO,IACdC,EAAQX,EAAM5E,EAAG4E,EAAMO,eACvBP,EACErD,EAAGqD,EAAME,GAAGU,OAEzB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/node_modules/@noble/curves/esm/abstract/modular.js

@@ -1,4 +0,0 @@
-import{anumber as t}from"../../../../../../@noble/hashes/esm/utils.js";import{numberToBytesLE as r,numberToBytesBE as n,bitMask as e,bytesToNumberLE as o,bytesToNumberBE as i,validateObject as u}from"./utils.js";
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-const s=BigInt(0),f=BigInt(1),l=BigInt(2),c=BigInt(3),d=BigInt(4),w=BigInt(5),E=BigInt(8);function g(t,r){const n=t%r;return n>=s?n:r+n}function a(t,r,n){let e=t;for(;r-- >s;)e*=e,e%=n;return e}function h(t,r){if(t===s)throw new Error("invert: expected non-zero number");if(r<=s)throw new Error("invert: expected positive modulus, got "+r);let n=g(t,r),e=r,o=s,i=f;for(;n!==s;){const t=e%n,r=o-i*(e/n);e=n,n=t,o=i,i=r}if(e!==f)throw new Error("invert: does not exist");return g(o,r)}function m(t,r){const n=(t.ORDER+f)/d,e=t.pow(r,n);if(!t.eql(t.sqr(e),r))throw new Error("Cannot find square root");return e}function p(t,r){const n=(t.ORDER-w)/E,e=t.mul(r,l),o=t.pow(e,n),i=t.mul(r,o),u=t.mul(t.mul(i,l),o),s=t.mul(i,t.sub(u,t.ONE));if(!t.eql(t.sqr(s),r))throw new Error("Cannot find square root");return s}function q(t){if(t<BigInt(3))throw new Error("sqrt is not defined for small field");let r=t-f,n=0;for(;r%l===s;)r/=l,n++;let e=l;const o=I(t);for(;1===N(o,e);)if(e++>1e3)throw new Error("Cannot find square root: probably non-prime P");if(1===n)return m;let i=o.pow(e,r);const u=(r+f)/l;return function(t,e){if(t.is0(e))return e;if(1!==N(t,e))throw new Error("Cannot find square root");let o=n,s=t.mul(t.ONE,i),l=t.pow(e,r),c=t.pow(e,u);for(;!t.eql(l,t.ONE);){if(t.is0(l))return t.ZERO;let r=1,n=t.sqr(l);for(;!t.eql(n,t.ONE);)if(r++,n=t.sqr(n),r===o)throw new Error("Cannot find square root");const e=f<<BigInt(o-r-1),i=t.pow(s,e);o=r,s=t.sqr(i),l=t.mul(l,s),c=t.mul(c,i)}return c}}function O(t){return t%d===c?m:t%E===w?p:q(t)}const b=["create","isValid","is0","neg","inv","sqrt","sqr","eql","add","sub","mul","pow","div","addN","subN","mulN","sqrN"];function B(t){const r=b.reduce((t,r)=>(t[r]="function",t),{ORDER:"bigint",MASK:"bigint",BYTES:"isSafeInteger",BITS:"isSafeInteger"});return u(t,r)}function v(t,r,n){if(n<s)throw new Error("invalid exponent, negatives unsupported");if(n===s)return t.ONE;if(n===f)return r;let e=t.ONE,o=r;for(;n>s;)n&f&&(e=t.mul(e,o)),o=t.sqr(o),n>>=f;return e}function R(t,r,n=!1){const e=new Array(r.length).fill(n?t.ZERO:void 0),o=r.reduce((r,n,o)=>t.is0(n)?r:(e[o]=r,t.mul(r,n)),t.ONE),i=t.inv(o);return r.reduceRight((r,n,o)=>t.is0(n)?r:(e[o]=t.mul(r,e[o]),t.mul(r,n)),i),e}function N(t,r){const n=(t.ORDER-f)/l,e=t.pow(r,n),o=t.eql(e,t.ONE),i=t.eql(e,t.ZERO),u=t.eql(e,t.neg(t.ONE));if(!o&&!i&&!u)throw new Error("invalid Legendre symbol result");return o?1:i?0:-1}function y(r,n){void 0!==n&&t(n);const e=void 0!==n?n:r.toString(2).length;return{nBitLength:e,nByteLength:Math.ceil(e/8)}}function I(t,u,l=!1,c={}){if(t<=s)throw new Error("invalid field: expected ORDER > 0, got "+t);const{nBitLength:d,nByteLength:w}=y(t,u);if(w>2048)throw new Error("invalid field: expected ORDER of <= 2048 bytes");let E;const a=Object.freeze({ORDER:t,isLE:l,BITS:d,BYTES:w,MASK:e(d),ZERO:s,ONE:f,create:r=>g(r,t),isValid:r=>{if("bigint"!=typeof r)throw new Error("invalid field element: expected bigint, got "+typeof r);return s<=r&&r<t},is0:t=>t===s,isOdd:t=>(t&f)===f,neg:r=>g(-r,t),eql:(t,r)=>t===r,sqr:r=>g(r*r,t),add:(r,n)=>g(r+n,t),sub:(r,n)=>g(r-n,t),mul:(r,n)=>g(r*n,t),pow:(t,r)=>v(a,t,r),div:(r,n)=>g(r*h(n,t),t),sqrN:t=>t*t,addN:(t,r)=>t+r,subN:(t,r)=>t-r,mulN:(t,r)=>t*r,inv:r=>h(r,t),sqrt:c.sqrt||(r=>(E||(E=O(t)),E(a,r))),toBytes:t=>l?r(t,w):n(t,w),fromBytes:t=>{if(t.length!==w)throw new Error("Field.fromBytes: expected "+w+" bytes, got "+t.length);return l?o(t):i(t)},invertBatch:t=>R(a,t),cmov:(t,r,n)=>n?r:t});return Object.freeze(a)}function x(t){if("bigint"!=typeof t)throw new Error("field order must be bigint");const r=t.toString(2).length;return Math.ceil(r/8)}function S(t){const r=x(t);return r+Math.ceil(r/2)}function D(t,e,u=!1){const s=t.length,l=x(e),c=S(e);if(s<16||s<c||s>1024)throw new Error("expected "+c+"-1024 bytes of input, got "+s);const d=g(u?o(t):i(t),e-f)+f;return u?r(d,l):n(d,l)}export{I as Field,R as FpInvertBatch,N as FpLegendre,v as FpPow,O as FpSqrt,x as getFieldBytesLength,S as getMinHashLength,h as invert,D as mapHashToField,g as mod,y as nLength,a as pow2,q as tonelliShanks,B as validateField};
-//# sourceMappingURL=modular.js.map

package/dist/esm/node_modules/viem/node_modules/@noble/curves/esm/abstract/modular.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"modular.js","sources":["../../../../../../../../../node_modules/viem/node_modules/@noble/curves/esm/abstract/modular.js"],"sourcesContent":["/**\n * Utils for modular division and finite fields.\n * A finite field over 11 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 { anumber } from '@noble/hashes/utils';\nimport { bitMask, bytesToNumberBE, bytesToNumberLE, ensureBytes, numberToBytesBE, numberToBytesLE, validateObject, } from \"./utils.js\";\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3);\n// prettier-ignore\nconst _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5), _8n = /* @__PURE__ */ BigInt(8);\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 * TODO: remove.\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}\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    // Throw if root^2 != n\n    if (!Fp.eql(Fp.sqr(root), n))\n        throw new Error('Cannot find square root');\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    if (!Fp.eql(Fp.sqr(root), n))\n        throw new Error('Cannot find square root');\n    return root;\n}\n// TODO: Commented-out for now. Provide test vectors.\n// Tonelli is too slow for extension fields Fp2.\n// That means we can't use sqrt (c1, c2...) even for initialization constants.\n// if (P % _16n === _9n) return sqrt9mod16;\n// // prettier-ignore\n// function sqrt9mod16<T>(Fp: IField<T>, n: T, p7div16?: bigint) {\n//   if (p7div16 === undefined) p7div16 = (Fp.ORDER + BigInt(7)) / _16n;\n//   const c1 = Fp.sqrt(Fp.neg(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n//   const c2 = Fp.sqrt(c1);             //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n//   const c3 = Fp.sqrt(Fp.neg(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n//   const c4 = p7div16;                 //  4. c4 = (q + 7) / 16        # Integer arithmetic\n//   let tv1 = Fp.pow(n, c4);            //  1. tv1 = x^c4\n//   let tv2 = Fp.mul(c1, tv1);          //  2. tv2 = c1 * tv1\n//   const tv3 = Fp.mul(c2, tv1);        //  3. tv3 = c2 * tv1\n//   let tv4 = Fp.mul(c3, tv1);          //  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//   return Fp.cmov(tv1, tv2, e3); // 10.  z = CMOV(tv1, tv2, e3) # Select the sqrt from tv1 and tv2\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    if (P < BigInt(3))\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. 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) not implemented, see above\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        MASK: 'bigint',\n        BYTES: 'isSafeInteger',\n        BITS: 'isSafeInteger',\n    };\n    const opts = FIELD_FIELDS.reduce((map, val) => {\n        map[val] = 'function';\n        return map;\n    }, initial);\n    return validateObject(field, opts);\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}\n/**\n * Initializes a finite field over prime.\n * Major performance optimizations:\n * * a) denormalized operations like mulN instead of mul\n * * b) same object shape: never add or remove keys\n * * c) 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 * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: 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, bitLen, isLE = false, redef = {}) {\n    if (ORDER <= _0n)\n        throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);\n    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n    if (BYTES > 2048)\n        throw new Error('invalid field: expected ORDER of <= 2048 bytes');\n    let sqrtP; // cached sqrtP\n    const f = Object.freeze({\n        ORDER,\n        isLE,\n        BITS,\n        BYTES,\n        MASK: bitMask(BITS),\n        ZERO: _0n,\n        ONE: _1n,\n        create: (num) => mod(num, ORDER),\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 < ORDER; // 0 is valid element, but it's not invertible\n        },\n        is0: (num) => num === _0n,\n        isOdd: (num) => (num & _1n) === _1n,\n        neg: (num) => mod(-num, ORDER),\n        eql: (lhs, rhs) => lhs === rhs,\n        sqr: (num) => mod(num * num, ORDER),\n        add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n        sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n        mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n        pow: (num, power) => FpPow(f, num, power),\n        div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n        // Same as above, but doesn't normalize\n        sqrN: (num) => num * num,\n        addN: (lhs, rhs) => lhs + rhs,\n        subN: (lhs, rhs) => lhs - rhs,\n        mulN: (lhs, rhs) => lhs * rhs,\n        inv: (num) => invert(num, ORDER),\n        sqrt: redef.sqrt ||\n            ((n) => {\n                if (!sqrtP)\n                    sqrtP = FpSqrt(ORDER);\n                return sqrtP(f, n);\n            }),\n        toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n        fromBytes: (bytes) => {\n            if (bytes.length !== BYTES)\n                throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);\n            return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n        },\n        // TODO: we don't need it here, move out to separate fn\n        invertBatch: (lst) => FpInvertBatch(f, lst),\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, c) => (c ? b : a),\n    });\n    return Object.freeze(f);\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 * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use `mapKeyToField` instead\n */\nexport function hashToPrivateScalar(hash, groupOrder, isLE = false) {\n    hash = ensureBytes('privateHash', hash);\n    const hashLen = hash.length;\n    const minLen = nLength(groupOrder).nByteLength + 8;\n    if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n        throw new Error('hashToPrivateScalar: expected ' + minLen + '-1024 bytes of input, got ' + hashLen);\n    const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n    return mod(num, groupOrder - _1n) + _1n;\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.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\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"],"names":["_0n","BigInt","_1n","_2n","_3n","_4n","_5n","_8n","mod","a","b","result","pow2","x","power","modulo","res","invert","number","Error","u","r","m","sqrt3mod4","Fp","n","p1div4","ORDER","root","pow","eql","sqr","sqrt5mod8","p5div8","n2","mul","v","nv","i","sub","ONE","tonelliShanks","P","Q","S","Z","_Fp","Field","FpLegendre","cc","Q1div2","is0","M","c","t","R","ZERO","t_tmp","exponent","FpSqrt","FIELD_FIELDS","validateField","field","opts","reduce","map","val","MASK","BYTES","BITS","validateObject","FpPow","num","p","d","FpInvertBatch","nums","passZero","inverted","Array","length","fill","undefined","multipliedAcc","acc","invertedAcc","inv","reduceRight","p1mod2","powered","yes","zero","no","neg","nLength","nBitLength","anumber","_nBitLength","toString","nByteLength","Math","ceil","bitLen","isLE","redef","sqrtP","f","Object","freeze","bitMask","create","isValid","isOdd","lhs","rhs","add","div","sqrN","addN","subN","mulN","sqrt","toBytes","numberToBytesLE","numberToBytesBE","fromBytes","bytes","bytesToNumberLE","bytesToNumberBE","invertBatch","lst","cmov","getFieldBytesLength","fieldOrder","bitLength","getMinHashLength","mapHashToField","key","len","fieldLen","minLen","reduced"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/node_modules/@noble/curves/esm/abstract/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sources":["../../../../../../../../../node_modules/viem/node_modules/@noble/curves/esm/abstract/utils.js"],"sourcesContent":["/**\n * Hex, bytes and number utilities.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\nexport function abytes(item) {\n    if (!isBytes(item))\n        throw new Error('Uint8Array expected');\n}\nexport function abool(title, value) {\n    if (typeof value !== 'boolean')\n        throw new Error(title + ' boolean expected, got ' + value);\n}\n// Used in weierstrass, der\nexport function numberToHexUnpadded(num) {\n    const hex = 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// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = \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// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    abytes(bytes);\n    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\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(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes(hex);\n        }\n        catch (e) {\n            throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);\n        }\n    }\n    else if (isBytes(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(title + ' must be hex string or Uint8Array');\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);\n    return res;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\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 * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n// 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// DRBG\nconst u8n = (len) => new Uint8Array(len); // creates Uint8Array\nconst u8fr = (arr) => Uint8Array.from(arr); // another shortcut\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\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 = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n(0)) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8fr([0x01]), 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++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\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}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || isBytes(val),\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error('invalid validator function');\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error('param ' + String(fieldName) + ' is invalid. Expected ' + type + ', got ' + val);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\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"],"names":["_0n","BigInt","_1n","isBytes","a","Uint8Array","ArrayBuffer","isView","constructor","name","abytes","item","Error","abool","title","value","numberToHexUnpadded","num","hex","toString","length","hexToNumber","hasHexBuiltin","from","toHex","fromHex","hexes","Array","_","i","padStart","bytesToHex","bytes","asciis","asciiToBase16","ch","hexToBytes","hl","al","array","ai","hi","n1","charCodeAt","n2","undefined","char","bytesToNumberBE","bytesToNumberLE","reverse","numberToBytesBE","n","len","numberToBytesLE","ensureBytes","expectedLength","res","e","concatBytes","arrays","sum","pad","set","isPosBig","inRange","min","max","aInRange","bitLen","bitMask","u8n","u8fr","arr","createHmacDrbg","hashLen","qByteLen","hmacFn","v","k","reset","fill","h","b","reseed","seed","gen","out","sl","slice","push","pred","validatorFns","bigint","val","function","boolean","string","stringOrUint8Array","isSafeInteger","Number","isArray","field","object","Fp","isValid","hash","outputLen","validateObject","validators","optValidators","checkField","fieldName","type","isOptional","checkVal","String","Object","entries","memoized","fn","map","WeakMap","arg","args","get","computed"],"mappings":"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","x_google_ignoreList":[0]}