superstack-wallet-sdk 0.4.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.js","sources":["../../../../../../../node_modules/viem/_esm/utils/hash/sha256.js"],"sourcesContent":["import { sha256 as noble_sha256 } from '@noble/hashes/sha256';\nimport { isHex } from '../data/isHex.js';\nimport { toBytes } from '../encoding/toBytes.js';\nimport { toHex } from '../encoding/toHex.js';\nexport function sha256(value, to_) {\n    const to = to_ || 'hex';\n    const bytes = noble_sha256(isHex(value, { strict: false }) ? toBytes(value) : value);\n    if (to === 'bytes')\n        return bytes;\n    return toHex(bytes);\n}\n//# sourceMappingURL=sha256.js.map"],"names":["sha256","value","to_","noble_sha256","isHex","strict","toBytes"],"mappings":"2JAIO,SAASA,EAAOC,EAAOC,GAItB,OAFUC,EAAaC,EAAMH,EAAO,CAAEI,QAAQ,IAAWC,EAAQL,GAASA,EAIlF","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/hash/toEventSelector.js

@@ -0,0 +1,2 @@
+import{toSignatureHash as o}from"./toSignatureHash.js";const t=o;export{t as toEventSelector};
+//# sourceMappingURL=toEventSelector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toEventSelector.js","sources":["../../../../../../../node_modules/viem/_esm/utils/hash/toEventSelector.js"],"sourcesContent":["import { toSignatureHash, } from './toSignatureHash.js';\n/**\n * Returns the event selector for a given event definition.\n *\n * @example\n * const selector = toEventSelector('Transfer(address indexed from, address indexed to, uint256 amount)')\n * // 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef\n */\nexport const toEventSelector = toSignatureHash;\n//# sourceMappingURL=toEventSelector.js.map"],"names":["toEventSelector","toSignatureHash"],"mappings":"uDAQY,MAACA,EAAkBC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/hash/toFunctionSelector.js

@@ -0,0 +1,2 @@
+import{slice as o}from"../data/slice.js";import{toSignatureHash as t}from"./toSignatureHash.js";const r=r=>o(t(r),0,4);export{r as toFunctionSelector};
+//# sourceMappingURL=toFunctionSelector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toFunctionSelector.js","sources":["../../../../../../../node_modules/viem/_esm/utils/hash/toFunctionSelector.js"],"sourcesContent":["import { slice } from '../data/slice.js';\nimport { toSignatureHash, } from './toSignatureHash.js';\n/**\n * Returns the function selector for a given function definition.\n *\n * @example\n * const selector = toFunctionSelector('function ownerOf(uint256 tokenId)')\n * // 0x6352211e\n */\nexport const toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);\n//# sourceMappingURL=toFunctionSelector.js.map"],"names":["toFunctionSelector","fn","slice","toSignatureHash"],"mappings":"gGASY,MAACA,EAAsBC,GAAOC,EAAMC,EAAgBF,GAAK,EAAG","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/hash/toSignature.js

@@ -0,0 +1,2 @@
+import{normalizeSignature as t}from"./normalizeSignature.js";import{formatAbiItem as r}from"../../../../abitype/dist/esm/human-readable/formatAbiItem.js";const e=e=>{const o="string"==typeof e?e:r(e);return t(o)};export{e as toSignature};
+//# sourceMappingURL=toSignature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toSignature.js","sources":["../../../../../../../node_modules/viem/_esm/utils/hash/toSignature.js"],"sourcesContent":["import { formatAbiItem } from 'abitype';\nimport { normalizeSignature, } from './normalizeSignature.js';\n/**\n * Returns the signature for a given function or event definition.\n *\n * @example\n * const signature = toSignature('function ownerOf(uint256 tokenId)')\n * // 'ownerOf(uint256)'\n *\n * @example\n * const signature_3 = toSignature({\n *   name: 'ownerOf',\n *   type: 'function',\n *   inputs: [{ name: 'tokenId', type: 'uint256' }],\n *   outputs: [],\n *   stateMutability: 'view',\n * })\n * // 'ownerOf(uint256)'\n */\nexport const toSignature = (def) => {\n    const def_ = (() => {\n        if (typeof def === 'string')\n            return def;\n        return formatAbiItem(def);\n    })();\n    return normalizeSignature(def_);\n};\n//# sourceMappingURL=toSignature.js.map"],"names":["toSignature","def","def_","formatAbiItem","normalizeSignature"],"mappings":"0JAmBY,MAACA,EAAeC,IACxB,MAAMC,EACiB,iBAARD,EACAA,EACJE,EAAcF,GAEzB,OAAOG,EAAmBF","x_google_ignoreList":[0]}

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

@@ -0,0 +1,2 @@
+import{hashSignature as r}from"./hashSignature.js";import{toSignature as t}from"./toSignature.js";function o(o){return r(t(o))}export{o as toSignatureHash};
+//# sourceMappingURL=toSignatureHash.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+class e extends Map{constructor(e){super(),Object.defineProperty(this,"maxSize",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.maxSize=e}get(e){const t=super.get(e);return super.has(e)&&void 0!==t&&(this.delete(e),super.set(e,t)),t}set(e,t){if(super.set(e,t),this.maxSize&&this.size>this.maxSize){const e=this.keys().next().value;e&&this.delete(e)}return this}}export{e as LruMap};
+//# sourceMappingURL=lru.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+const t=new Map,n=new Map;let o=0;function e(e,s,c){const f=++o,i=()=>t.get(e)||[],r=()=>{const o=i();if(!o.some(t=>t.id===f))return;const s=n.get(e);if(1===o.length&&s){const t=s();t instanceof Promise&&t.catch(()=>{})}(()=>{const n=i();t.set(e,n.filter(t=>t.id!==f))})()},g=i();if(t.set(e,[...g,{id:f,fns:s}]),g&&g.length>0)return r;const l={};for(const t in s)l[t]=(...n)=>{const o=i();if(0!==o.length)for(const e of o)e.fns[t]?.(...n)};const u=c(l);return"function"==typeof u&&n.set(e,u),r}export{n as cleanupCache,t as listenersCache,e as observe};
+//# sourceMappingURL=observe.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{wait as t}from"./wait.js";function a(a,{emitOnBegin:i,initialWaitTime:n,interval:o}){let e=!0;const l=()=>e=!1;return(async()=>{let c;i&&(c=await a({unpoll:l}));const r=await(n?.(c))??o;await t(r);const s=async()=>{e&&(await a({unpoll:l}),await t(o),s())};s()})(),l}export{a as poll};
+//# sourceMappingURL=poll.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{withResolvers as e}from"./withResolvers.js";const t=new Map;function r({fn:r,id:s,shouldSplitBatch:o,wait:n=0,sort:c}){const l=async()=>{const e=h();a();const t=e.map(({args:e})=>e);0!==t.length&&r(t).then(t=>{c&&Array.isArray(t)&&t.sort(c);for(let r=0;r<e.length;r++){const{resolve:s}=e[r];s?.([t[r],t])}}).catch(t=>{for(let r=0;r<e.length;r++){const{reject:s}=e[r];s?.(t)}})},a=()=>t.delete(s),h=()=>t.get(s)||[],g=e=>t.set(s,[...h(),e]);return{flush:a,async schedule(t){const{promise:r,resolve:s,reject:c}=e(),a=o?.([...h().map(({args:e})=>e),t]);a&&l();return h().length>0?(g({args:t,resolve:s,reject:c}),r):(g({args:t,resolve:s,reject:c}),setTimeout(l,n),r)}}}export{r as createBatchScheduler};
+//# sourceMappingURL=createBatchScheduler.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+const e=new Map,t=new Map;function r(r){const a=(e,t)=>({clear:()=>t.delete(e),get:()=>t.get(e),set:r=>t.set(e,r)}),n=a(r,e),s=a(r,t);return{clear:()=>{n.clear(),s.clear()},promise:n,response:s}}async function a(e,{cacheKey:t,cacheTime:a=Number.POSITIVE_INFINITY}){const n=r(t),s=n.response.get();if(s&&a>0){if(Date.now()-s.created.getTime()<a)return s.data}let c=n.promise.get();c||(c=e(),n.promise.set(c));try{const e=await c;return n.response.set({created:new Date,data:e}),e}finally{n.promise.clear()}}export{r as getCache,e as promiseCache,t as responseCache,a as withCache};
+//# sourceMappingURL=withCache.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{LruMap as e}from"../lru.js";const t=new e(8192);function n(e,{enabled:n=!0,id:r}){if(!n||!r)return e();if(t.get(r))return t.get(r);const i=e().finally(()=>t.delete(r));return t.set(r,i),i}export{t as promiseCache,n as withDedupe};
+//# sourceMappingURL=withDedupe.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+function e(){let e=()=>{},r=()=>{};return{promise:new Promise((o,t)=>{e=o,r=t}),resolve:e,reject:r}}export{e as withResolvers};
+//# sourceMappingURL=withResolvers.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{wait as r}from"../wait.js";function t(t,{delay:o=100,retryCount:n=2,shouldRetry:c=()=>!0}={}){return new Promise((e,a)=>{const u=async({count:i=0}={})=>{try{const r=await t();e(r)}catch(t){if(i<n&&await c({count:i,error:t}))return(async({error:t})=>{const n="function"==typeof o?o({count:i,error:t}):o;n&&await r(n),u({count:i+1})})({error:t});a(t)}};u()})}export{t as withRetry};
+//# sourceMappingURL=withRetry.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+function r(r,{errorInstance:t=new Error("timed out"),timeout:e,signal:n}){return new Promise((o,a)=>{(async()=>{let i;try{const t=new AbortController;e>0&&(i=setTimeout(()=>{n&&t.abort()},e)),o(await r({signal:t?.signal||null}))}catch(r){"AbortError"===r?.name&&a(t),a(r)}finally{clearTimeout(i)}})()})}export{r as withTimeout};
+//# sourceMappingURL=withTimeout.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+const t=/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/,e=/^(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)?$/;export{t as bytesRegex,e as integerRegex};
+//# sourceMappingURL=regex.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{TimeoutError as t,HttpRequestError as e}from"../../errors/request.js";import{withTimeout as r}from"../promise/withTimeout.js";import{stringify as o}from"../stringify.js";import{idCache as s}from"./id.js";function n(n,a={}){return{async request(i){const{body:c,fetchFn:u=a.fetchFn??fetch,onRequest:h=a.onRequest,onResponse:p=a.onResponse,timeout:d=a.timeout??1e4}=i,f={...a.fetchOptions??{},...i.fetchOptions??{}},{headers:l,method:m,signal:w}=f;try{const a=await r(async({signal:t})=>{const e={...f,body:Array.isArray(c)?o(c.map(t=>({jsonrpc:"2.0",id:t.id??s.take(),...t}))):o({jsonrpc:"2.0",id:c.id??s.take(),...c}),headers:{"Content-Type":"application/json",...l},method:m||"POST",signal:w||(d>0?t:null)},r=new Request(n,e),a=await(h?.(r,e))??{...e,url:n};return await u(a.url??n,a)},{errorInstance:new t({body:c,url:n}),timeout:d,signal:!0});let i;if(p&&await p(a),a.headers.get("Content-Type")?.startsWith("application/json"))i=await a.json();else{i=await a.text();try{i=JSON.parse(i||"{}")}catch(t){if(a.ok)throw t;i={error:i}}}if(!a.ok)throw new e({body:c,details:o(i.error)||a.statusText,headers:a.headers,status:a.status,url:n});return i}catch(r){if(r instanceof e)throw r;if(r instanceof t)throw r;throw new e({body:c,cause:r,url:n})}}}}export{n as getHttpRpcClient};
+//# sourceMappingURL=http.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+function r(){return{current:0,take(){return this.current++},reset(){this.current=0}}}const t=r();export{t as idCache};
+//# sourceMappingURL=id.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{keccak256 as r}from"../hash/keccak256.js";import{toPrefixedMessage as e}from"./toPrefixedMessage.js";function o(o,t){return r(e(o),t)}export{o as hashMessage};
+//# sourceMappingURL=hashMessage.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{encodeAbiParameters as e}from"../abi/encodeAbiParameters.js";import{concat as t}from"../data/concat.js";import{toHex as p}from"../encoding/toHex.js";import{keccak256 as r}from"../hash/keccak256.js";import{getTypesForEIP712Domain as y,validateTypedData as n}from"../typedData.js";function a(e){const{domain:p={},message:a,primaryType:i}=e,m={EIP712Domain:y({domain:p}),...e.types};n({domain:p,message:a,primaryType:i,types:m});const c=["0x1901"];return p&&c.push(s({domain:p,types:m})),"EIP712Domain"!==i&&c.push(o({data:a,primaryType:i,types:m})),r(t(c))}function s({domain:e,types:t}){return o({data:e,primaryType:"EIP712Domain",types:t})}function o({data:e,primaryType:t,types:p}){const y=i({data:e,primaryType:t,types:p});return r(y)}function i({data:t,primaryType:p,types:r}){const y=[{type:"bytes32"}],n=[m({primaryType:p,types:r})];for(const e of r[p]){const[p,a]=f({types:r,name:e.name,type:e.type,value:t[e.name]});y.push(p),n.push(a)}return e(y,n)}function m({primaryType:e,types:t}){const y=p(c({primaryType:e,types:t}));return r(y)}function c({primaryType:e,types:t}){let p="";const r=u({primaryType:e,types:t});r.delete(e);const y=[e,...Array.from(r).sort()];for(const e of y)p+=`${e}(${t[e].map(({name:e,type:t})=>`${t} ${e}`).join(",")})`;return p}function u({primaryType:e,types:t},p=new Set){const r=e.match(/^\w*/u),y=r?.[0];if(p.has(y)||void 0===t[y])return p;p.add(y);for(const e of t[y])u({primaryType:e.type,types:t},p);return p}function f({types:t,name:y,type:n,value:a}){if(void 0!==t[n])return[{type:"bytes32"},r(i({data:a,primaryType:n,types:t}))];if("bytes"===n){return a=`0x${(a.length%2?"0":"")+a.slice(2)}`,[{type:"bytes32"},r(a)]}if("string"===n)return[{type:"bytes32"},r(p(a))];if(n.lastIndexOf("]")===n.length-1){const p=n.slice(0,n.lastIndexOf("[")),s=a.map(e=>f({name:y,type:p,types:t,value:e}));return[{type:"bytes32"},r(e(s.map(([e])=>e),s.map(([,e])=>e)))]}return[{type:n},a]}export{c as encodeType,s as hashDomain,o as hashStruct,a as hashTypedData};
+//# sourceMappingURL=hashTypedData.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{publicKeyToAddress as r}from"../../accounts/utils/publicKeyToAddress.js";import{recoverPublicKey as s}from"./recoverPublicKey.js";async function t({hash:t,signature:e}){return r(await s({hash:t,signature:e}))}export{t as recoverAddress};
+//# sourceMappingURL=recoverAddress.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{presignMessagePrefix as t}from"../../constants/strings.js";import{concat as o}from"../data/concat.js";import{size as r}from"../data/size.js";import{stringToHex as n,bytesToHex as s}from"../encoding/toHex.js";function i(i){const a="string"==typeof i?n(i):"string"==typeof i.raw?i.raw:s(i.raw),m=n(`${t}${r(a)}`);return o([m,a])}export{i as toPrefixedMessage};
+//# sourceMappingURL=toPrefixedMessage.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+function e(e){const{scheme:s,statement:i,...o}=e.match(n)?.groups??{},{chainId:r,expirationTime:a,issuedAt:u,notBefore:c,requestId:m,...d}=e.match(t)?.groups??{},h=e.split("Resources:")[1]?.split("\n- ").slice(1);return{...o,...d,...r?{chainId:Number(r)}:{},...a?{expirationTime:new Date(a)}:{},...u?{issuedAt:new Date(u)}:{},...c?{notBefore:new Date(c)}:{},...m?{requestId:m}:{},...h?{resources:h}:{},...s?{scheme:s}:{},...i?{statement:i}:{}}}const n=/^(?:(?<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)?/,t=/(?: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>.+))?/;export{e as parseSiweMessage};
+//# sourceMappingURL=parseSiweMessage.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{isAddress as r}from"../address/isAddress.js";import{isAddressEqual as e}from"../address/isAddressEqual.js";function s(s){const{address:t,domain:n,message:i,nonce:d,scheme:o,time:a=new Date}=s;if(n&&i.domain!==n)return!1;if(d&&i.nonce!==d)return!1;if(o&&i.scheme!==o)return!1;if(i.expirationTime&&a>=i.expirationTime)return!1;if(i.notBefore&&a<i.notBefore)return!1;try{if(!i.address)return!1;if(!r(i.address,{strict:!1}))return!1;if(t&&!e(i.address,t))return!1}catch{return!1}return!0}export{s as validateSiweMessage};
+//# sourceMappingURL=validateSiweMessage.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{InvalidAddressError as e}from"../errors/address.js";import{InvalidBytesLengthError as t}from"../errors/data.js";import{AccountStateConflictError as r,StateAssignmentConflictError as o}from"../errors/stateOverride.js";import{isAddress as s}from"./address/isAddress.js";import{numberToHex as n}from"./encoding/toHex.js";function i(e){if(e&&0!==e.length)return e.reduce((e,{slot:r,value:o})=>{if(66!==r.length)throw new t({size:r.length,targetSize:66,type:"hex"});if(66!==o.length)throw new t({size:o.length,targetSize:66,type:"hex"});return e[r]=o,e},{})}function d(e){const{balance:t,nonce:r,state:s,stateDiff:d,code:f}=e,a={};if(void 0!==f&&(a.code=f),void 0!==t&&(a.balance=n(t)),void 0!==r&&(a.nonce=n(r)),void 0!==s&&(a.state=i(s)),void 0!==d){if(a.state)throw new o;a.stateDiff=i(d)}return a}function f(t){if(!t)return;const o={};for(const{address:n,...i}of t){if(!s(n,{strict:!1}))throw new e({address:n});if(o[n])throw new r({address:n});o[n]=d(i)}return o}export{d as serializeAccountStateOverride,i as serializeStateMapping,f as serializeStateOverride};
+//# sourceMappingURL=stateOverride.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+const t=(t,i,n)=>JSON.stringify(t,(t,i)=>"bigint"==typeof i?i.toString():i,n);export{t as stringify};
+//# sourceMappingURL=stringify.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{parseAccount as r}from"../../accounts/utils/parseAccount.js";import{maxUint256 as s}from"../../constants/number.js";import{InvalidAddressError as o}from"../../errors/address.js";import{FeeCapTooHighError as e,TipAboveFeeCapError as t}from"../../errors/node.js";import{FeeConflictError as i}from"../../errors/transaction.js";import{isAddress as a}from"../address/isAddress.js";function d(d){const{account:m,gasPrice:n,maxFeePerGas:f,maxPriorityFeePerGas:c,to:w}=d,p=m?r(m):void 0;if(p&&!a(p.address))throw new o({address:p.address});if(w&&!a(w))throw new o({address:w});if(void 0!==n&&(void 0!==f||void 0!==c))throw new i;if(f&&f>s)throw new e({maxFeePerGas:f});if(c&&f&&c>f)throw new t({maxFeePerGas:f,maxPriorityFeePerGas:c})}export{d as assertRequest};
+//# sourceMappingURL=assertRequest.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{InvalidSerializableTransactionError as i}from"../../errors/transaction.js";function e(e){if(e.type)return e.type;if(void 0!==e.authorizationList)return"eip7702";if(void 0!==e.blobs||void 0!==e.blobVersionedHashes||void 0!==e.maxFeePerBlobGas||void 0!==e.sidecars)return"eip4844";if(void 0!==e.maxFeePerGas||void 0!==e.maxPriorityFeePerGas)return"eip1559";if(void 0!==e.gasPrice)return void 0!==e.accessList?"eip2930":"legacy";throw new i({transaction:e})}export{e as getTransactionType};
+//# sourceMappingURL=getTransactionType.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{BytesSizeMismatchError as t}from"../errors/abi.js";import{InvalidAddressError as e}from"../errors/address.js";import{InvalidDomainError as r,InvalidPrimaryTypeError as n,InvalidStructTypeError as i}from"../errors/typedData.js";import{isAddress as o}from"./address/isAddress.js";import{size as s}from"./data/size.js";import{numberToHex as a}from"./encoding/toHex.js";import{integerRegex as m,bytesRegex as p}from"./regex.js";function f(i){const{domain:f,message:d,primaryType:c,types:g}=i,h=(r,n)=>{for(const i of r){const{name:r,type:f}=i,d=n[r],c=f.match(m);if(c&&("number"==typeof d||"bigint"==typeof d)){const[t,e,r]=c;a(d,{signed:"int"===e,size:Number.parseInt(r,10)/8})}if("address"===f&&"string"==typeof d&&!o(d))throw new e({address:d});const b=f.match(p);if(b){const[e,r]=b;if(r&&s(d)!==Number.parseInt(r,10))throw new t({expectedSize:Number.parseInt(r,10),givenSize:s(d)})}const u=g[f];u&&(y(f),h(u,d))}};if(g.EIP712Domain&&f){if("object"!=typeof f)throw new r({domain:f});h(g.EIP712Domain,f)}if("EIP712Domain"!==c){if(!g[c])throw new n({primaryType:c,types:g});h(g[c],d)}}function d({domain:t}){return["string"==typeof t?.name&&{name:"name",type:"string"},t?.version&&{name:"version",type:"string"},("number"==typeof t?.chainId||"bigint"==typeof t?.chainId)&&{name:"chainId",type:"uint256"},t?.verifyingContract&&{name:"verifyingContract",type:"address"},t?.salt&&{name:"salt",type:"bytes32"}].filter(Boolean)}function y(t){if("address"===t||"bool"===t||"string"===t||t.startsWith("bytes")||t.startsWith("uint")||t.startsWith("int"))throw new i({type:t})}export{d as getTypesForEIP712Domain,f as validateTypedData};
+//# sourceMappingURL=typedData.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+let t,r=256;function n(n=11){if(!t||r+n>512){t="",r=0;for(let r=0;r<256;r++)t+=(256+256*Math.random()|0).toString(16).substring(1)}return t.substring(r,r+++n)}export{n as uid};
+//# sourceMappingURL=uid.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{etherUnits as t}from"../../constants/unit.js";import{formatUnits as o}from"./formatUnits.js";function r(r,n="wei"){return o(r,t[n])}export{r as formatEther};
+//# sourceMappingURL=formatEther.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{gweiUnits as t}from"../../constants/unit.js";import{formatUnits as o}from"./formatUnits.js";function r(r,n="wei"){return o(r,t[n])}export{r as formatGwei};
+//# sourceMappingURL=formatGwei.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+function t(t,e){let l=t.toString();const n=l.startsWith("-");n&&(l=l.slice(1)),l=l.padStart(e,"0");let[r,c]=[l.slice(0,l.length-e),l.slice(l.length-e)];return c=c.replace(/(0+)$/,""),`${n?"-":""}${r||"0"}${c?`.${c}`:""}`}export{t as formatUnits};
+//# sourceMappingURL=formatUnits.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+async function e(e){return new Promise(n=>setTimeout(n,e))}export{e as wait};
+//# sourceMappingURL=wait.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,3 @@
+import{validateField as e,nLength as t}from"./modular.js";import{validateObject as n,bitLen as r,bitMask as o}from"./utils.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */const i=BigInt(0),s=BigInt(1);function a(e,t){const n=t.negate();return e?n:t}function f(e,t){if(!Number.isSafeInteger(e)||e<=0||e>t)throw new Error("invalid window size, expected [1.."+t+"], got W="+e)}function d(e,t){f(e,t);const n=2**e;return{windows:Math.ceil(t/e)+1,windowSize:2**(e-1),mask:o(e),maxNumber:n,shiftBy:BigInt(e)}}function c(e,t,n){const{windowSize:r,mask:o,maxNumber:i,shiftBy:a}=n;let f=Number(e&o),d=e>>a;f>r&&(f-=i,d+=s);const c=t*r;return{nextN:d,offset:c+Math.abs(f)-1,isZero:0===f,isNeg:f<0,isNegF:t%2!=0,offsetF:c}}const u=new WeakMap,l=new WeakMap;function w(e){return l.get(e)||1}function h(e,t){return{constTimeNegate:a,hasPrecomputes:e=>1!==w(e),unsafeLadder(t,n,r=e.ZERO){let o=t;for(;n>i;)n&s&&(r=r.add(o)),o=o.double(),n>>=s;return r},precomputeWindow(e,n){const{windows:r,windowSize:o}=d(n,t),i=[];let s=e,a=s;for(let e=0;e<r;e++){a=s,i.push(a);for(let e=1;e<o;e++)a=a.add(s),i.push(a);s=a.double()}return i},wNAF(n,r,o){let i=e.ZERO,s=e.BASE;const f=d(n,t);for(let e=0;e<f.windows;e++){const{nextN:t,offset:n,isZero:d,isNeg:u,isNegF:l,offsetF:w}=c(o,e,f);o=t,d?s=s.add(a(l,r[w])):i=i.add(a(u,r[n]))}return{p:i,f:s}},wNAFUnsafe(n,r,o,s=e.ZERO){const a=d(n,t);for(let e=0;e<a.windows&&o!==i;e++){const{nextN:t,offset:n,isZero:i,isNeg:f}=c(o,e,a);if(o=t,!i){const e=r[n];s=s.add(f?e.negate():e)}}return s},getPrecomputes(e,t,n){let r=u.get(t);return r||(r=this.precomputeWindow(t,e),1!==e&&u.set(t,n(r))),r},wNAFCached(e,t,n){const r=w(e);return this.wNAF(r,this.getPrecomputes(r,e,n),t)},wNAFCachedUnsafe(e,t,n,r){const o=w(e);return 1===o?this.unsafeLadder(e,t,r):this.wNAFUnsafe(o,this.getPrecomputes(o,e,n),t,r)},setWindowSize(e,n){f(n,t),l.set(e,n),u.delete(e)}}}function g(e,t,n,i){!function(e,t){if(!Array.isArray(e))throw new Error("array expected");e.forEach((e,n)=>{if(!(e instanceof t))throw new Error("invalid point at index "+n)})}(n,e),function(e,t){if(!Array.isArray(e))throw new Error("array of scalars expected");e.forEach((e,n)=>{if(!t.isValid(e))throw new Error("invalid scalar at index "+n)})}(i,t);const s=n.length,a=i.length;if(s!==a)throw new Error("arrays of points and scalars must have equal length");const f=e.ZERO,d=r(BigInt(s));let c=1;d>12?c=d-3:d>4?c=d-2:d>0&&(c=2);const u=o(c),l=new Array(Number(u)+1).fill(f);let w=f;for(let e=Math.floor((t.BITS-1)/c)*c;e>=0;e-=c){l.fill(f);for(let t=0;t<a;t++){const r=i[t],o=Number(r>>BigInt(e)&u);l[o]=l[o].add(n[t])}let t=f;for(let e=l.length-1,n=f;e>0;e--)n=n.add(l[e]),t=t.add(n);if(w=w.add(t),0!==e)for(let e=0;e<c;e++)w=w.double()}return w}function p(r){return e(r.Fp),n(r,{n:"bigint",h:"bigint",Gx:"field",Gy:"field"},{nBitLength:"isSafeInteger",nByteLength:"isSafeInteger"}),Object.freeze({...t(r.n,r.nBitLength),...r,p:r.Fp.ORDER})}export{g as pippenger,p as validateBasic,h as wNAF};
+//# sourceMappingURL=curve.js.map

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

@@ -0,0 +1 @@
+{"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":"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","x_google_ignoreList":[0]}