superstack-wallet-sdk 0.4.5 → 0.4.8

package/dist/esm/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"commitmentToVersionedHash.js","sources":["../../../../../../../node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js"],"sourcesContent":["import { bytesToHex } from '../encoding/toHex.js';\nimport { sha256 } from '../hash/sha256.js';\n/**\n * Transform a commitment to it's versioned hash.\n *\n * @example\n * ```ts\n * import {\n *   blobsToCommitments,\n *   commitmentToVersionedHash,\n *   toBlobs\n * } from 'viem'\n * import { kzg } from './kzg'\n *\n * const blobs = toBlobs({ data: '0x1234' })\n * const [commitment] = blobsToCommitments({ blobs, kzg })\n * const versionedHash = commitmentToVersionedHash({ commitment })\n * ```\n */\nexport function commitmentToVersionedHash(parameters) {\n    const { commitment, version = 1 } = parameters;\n    const to = parameters.to ?? (typeof commitment === 'string' ? 'hex' : 'bytes');\n    const versionedHash = sha256(commitment, 'bytes');\n    versionedHash.set([version], 0);\n    return (to === 'bytes' ? versionedHash : bytesToHex(versionedHash));\n}\n//# sourceMappingURL=commitmentToVersionedHash.js.map"],"names":["commitmentToVersionedHash","parameters","commitment","version","to","versionedHash","sha256","set","bytesToHex"],"mappings":"6FAmBO,SAASA,EAA0BC,GACtC,MAAMC,WAAEA,EAAUC,QAAEA,EAAU,GAAMF,EAC9BG,EAAKH,EAAWG,KAA6B,iBAAfF,EAA0B,MAAQ,SAChEG,EAAgBC,EAAOJ,GAE7B,OADAG,EAAcE,IAAI,CAACJ,GAAU,GACd,UAAPC,EAAiBC,EAAgBG,EAAWH,EACxD","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"commitmentsToVersionedHashes.js","sources":["../../../../../../../node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js"],"sourcesContent":["import { commitmentToVersionedHash, } from './commitmentToVersionedHash.js';\n/**\n * Transform a list of commitments to their versioned hashes.\n *\n * @example\n * ```ts\n * import {\n *   blobsToCommitments,\n *   commitmentsToVersionedHashes,\n *   toBlobs\n * } from 'viem'\n * import { kzg } from './kzg'\n *\n * const blobs = toBlobs({ data: '0x1234' })\n * const commitments = blobsToCommitments({ blobs, kzg })\n * const versionedHashes = commitmentsToVersionedHashes({ commitments })\n * ```\n */\nexport function commitmentsToVersionedHashes(parameters) {\n    const { commitments, version } = parameters;\n    const to = parameters.to ?? (typeof commitments[0] === 'string' ? 'hex' : 'bytes');\n    const hashes = [];\n    for (const commitment of commitments) {\n        hashes.push(commitmentToVersionedHash({\n            commitment,\n            to,\n            version,\n        }));\n    }\n    return hashes;\n}\n//# sourceMappingURL=commitmentsToVersionedHashes.js.map"],"names":["commitmentsToVersionedHashes","parameters","commitments","version","to","hashes","commitment","push","commitmentToVersionedHash"],"mappings":"2EAkBO,SAASA,EAA6BC,GACzC,MAAMC,YAAEA,EAAWC,QAAEA,GAAYF,EAC3BG,EAAKH,EAAWG,GAChBC,EAAS,GACf,IAAK,MAAMC,KAAcJ,EACrBG,EAAOE,KAAKC,EAA0B,CAClCF,aACAF,KACAD,aAGR,OAAOE,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/blob/toBlobSidecars.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toBlobSidecars.js","sources":["../../../../../../../node_modules/viem/_esm/utils/blob/toBlobSidecars.js"],"sourcesContent":["import { blobsToCommitments, } from './blobsToCommitments.js';\nimport { blobsToProofs } from './blobsToProofs.js';\nimport { toBlobs } from './toBlobs.js';\n/**\n * Transforms arbitrary data (or blobs, commitments, & proofs) into a sidecar array.\n *\n * @example\n * ```ts\n * import { toBlobSidecars, stringToHex } from 'viem'\n *\n * const sidecars = toBlobSidecars({ data: stringToHex('hello world') })\n * ```\n *\n * @example\n * ```ts\n * import {\n *   blobsToCommitments,\n *   toBlobs,\n *   blobsToProofs,\n *   toBlobSidecars,\n *   stringToHex\n * } from 'viem'\n *\n * const blobs = toBlobs({ data: stringToHex('hello world') })\n * const commitments = blobsToCommitments({ blobs, kzg })\n * const proofs = blobsToProofs({ blobs, commitments, kzg })\n *\n * const sidecars = toBlobSidecars({ blobs, commitments, proofs })\n * ```\n */\nexport function toBlobSidecars(parameters) {\n    const { data, kzg, to } = parameters;\n    const blobs = parameters.blobs ?? toBlobs({ data: data, to });\n    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg: kzg, to });\n    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg: kzg, to });\n    const sidecars = [];\n    for (let i = 0; i < blobs.length; i++)\n        sidecars.push({\n            blob: blobs[i],\n            commitment: commitments[i],\n            proof: proofs[i],\n        });\n    return sidecars;\n}\n//# sourceMappingURL=toBlobSidecars.js.map"],"names":["toBlobSidecars","parameters","data","kzg","to","blobs","toBlobs","commitments","blobsToCommitments","proofs","blobsToProofs","sidecars","i","length","push","blob","commitment","proof"],"mappings":"uJA8BO,SAASA,EAAeC,GAC3B,MAAMC,KAAEA,EAAIC,IAAEA,EAAGC,GAAEA,GAAOH,EACpBI,EAAQJ,EAAWI,OAASC,EAAQ,CAAEJ,KAAMA,IAC5CK,EAAcN,EAAWM,aAAeC,EAAmB,CAAEH,QAAOF,IAAKA,EAAKC,OAC9EK,EAASR,EAAWQ,QAAUC,EAAc,CAAEL,QAAOE,cAAaJ,IAAKA,EAAKC,OAC5EO,EAAW,GACjB,IAAK,IAAIC,EAAI,EAAGA,EAAIP,EAAMQ,OAAQD,IAC9BD,EAASG,KAAK,CACVC,KAAMV,EAAMO,GACZI,WAAYT,EAAYK,GACxBK,MAAOR,EAAOG,KAEtB,OAAOD,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/blob/toBlobs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toBlobs.js","sources":["../../../../../../../node_modules/viem/_esm/utils/blob/toBlobs.js"],"sourcesContent":["import { bytesPerBlob, bytesPerFieldElement, fieldElementsPerBlob, maxBytesPerTransaction, } from '../../constants/blob.js';\nimport { BlobSizeTooLargeError, EmptyBlobError, } from '../../errors/blob.js';\nimport { createCursor } from '../cursor.js';\nimport { size } from '../data/size.js';\nimport { hexToBytes } from '../encoding/toBytes.js';\nimport { bytesToHex } from '../encoding/toHex.js';\n/**\n * Transforms arbitrary data to blobs.\n *\n * @example\n * ```ts\n * import { toBlobs, stringToHex } from 'viem'\n *\n * const blobs = toBlobs({ data: stringToHex('hello world') })\n * ```\n */\nexport function toBlobs(parameters) {\n    const to = parameters.to ?? (typeof parameters.data === 'string' ? 'hex' : 'bytes');\n    const data = (typeof parameters.data === 'string'\n        ? hexToBytes(parameters.data)\n        : parameters.data);\n    const size_ = size(data);\n    if (!size_)\n        throw new EmptyBlobError();\n    if (size_ > maxBytesPerTransaction)\n        throw new BlobSizeTooLargeError({\n            maxSize: maxBytesPerTransaction,\n            size: size_,\n        });\n    const blobs = [];\n    let active = true;\n    let position = 0;\n    while (active) {\n        const blob = createCursor(new Uint8Array(bytesPerBlob));\n        let size = 0;\n        while (size < fieldElementsPerBlob) {\n            const bytes = data.slice(position, position + (bytesPerFieldElement - 1));\n            // Push a zero byte so the field element doesn't overflow the BLS modulus.\n            blob.pushByte(0x00);\n            // Push the current segment of data bytes.\n            blob.pushBytes(bytes);\n            // If we detect that the current segment of data bytes is less than 31 bytes,\n            // we can stop processing and push a terminator byte to indicate the end of the blob.\n            if (bytes.length < 31) {\n                blob.pushByte(0x80);\n                active = false;\n                break;\n            }\n            size++;\n            position += 31;\n        }\n        blobs.push(blob);\n    }\n    return (to === 'bytes'\n        ? blobs.map((x) => x.bytes)\n        : blobs.map((x) => bytesToHex(x.bytes)));\n}\n//# sourceMappingURL=toBlobs.js.map"],"names":["toBlobs","parameters","data","hexToBytes","size_","size","EmptyBlobError","maxBytesPerTransaction","BlobSizeTooLargeError","maxSize","blobs","active","position","blob","createCursor","Uint8Array","bytesPerBlob","fieldElementsPerBlob","bytes","slice","bytesPerFieldElement","pushByte","pushBytes","length","push","map","x","bytesToHex"],"mappings":"iZAgBO,SAASA,EAAQC,GAEpB,MAAMC,EAAmC,iBAApBD,EAAWC,KAC1BC,EAAWF,EAAWC,MACtBD,EAAWC,KACXE,EAAQC,EAAKH,GACnB,IAAKE,EACD,MAAM,IAAIE,EACd,GAAIF,EAAQG,EACR,MAAM,IAAIC,EAAsB,CAC5BC,QAASF,EACTF,KAAMD,IAEd,MAAMM,EAAQ,GACd,IAAIC,GAAS,EACTC,EAAW,EACf,KAAOD,GAAQ,CACX,MAAME,EAAOC,EAAa,IAAIC,WAAWC,IACzC,IAAIX,EAAO,EACX,KAAOA,EAAOY,GAAsB,CAChC,MAAMC,EAAQhB,EAAKiB,MAAMP,EAAUA,GAAYQ,EAAuB,IAOtE,GALAP,EAAKQ,SAAS,GAEdR,EAAKS,UAAUJ,GAGXA,EAAMK,OAAS,GAAI,CACnBV,EAAKQ,SAAS,KACdV,GAAS,EACT,KACJ,CACAN,IACAO,GAAY,EAChB,CACAF,EAAMc,KAAKX,EACf,CACA,OAEMH,EAAMe,IAAKC,GAAMC,EAAWD,EAAER,OACxC","x_google_ignoreList":[0]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"buildRequest.js","sources":["../../../../../../node_modules/viem/_esm/utils/buildRequest.js"],"sourcesContent":["import { BaseError } from '../errors/base.js';\nimport { HttpRequestError, } from '../errors/request.js';\nimport { AtomicityNotSupportedError, AtomicReadyWalletRejectedUpgradeError, BundleTooLargeError, ChainDisconnectedError, DuplicateIdError, InternalRpcError, InvalidInputRpcError, InvalidParamsRpcError, InvalidRequestRpcError, JsonRpcVersionUnsupportedError, LimitExceededRpcError, MethodNotFoundRpcError, MethodNotSupportedRpcError, ParseRpcError, ProviderDisconnectedError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, SwitchChainError, TransactionRejectedRpcError, UnauthorizedProviderError, UnknownBundleIdError, UnknownRpcError, UnsupportedChainIdError, UnsupportedNonOptionalCapabilityError, UnsupportedProviderMethodError, UserRejectedRequestError, } from '../errors/rpc.js';\nimport { stringToHex } from './encoding/toHex.js';\nimport { withDedupe } from './promise/withDedupe.js';\nimport { withRetry } from './promise/withRetry.js';\nimport { stringify } from './stringify.js';\nexport function buildRequest(request, options = {}) {\n    return async (args, overrideOptions = {}) => {\n        const { dedupe = false, methods, retryDelay = 150, retryCount = 3, uid, } = {\n            ...options,\n            ...overrideOptions,\n        };\n        const { method } = args;\n        if (methods?.exclude?.includes(method))\n            throw new MethodNotSupportedRpcError(new Error('method not supported'), {\n                method,\n            });\n        if (methods?.include && !methods.include.includes(method))\n            throw new MethodNotSupportedRpcError(new Error('method not supported'), {\n                method,\n            });\n        const requestId = dedupe\n            ? stringToHex(`${uid}.${stringify(args)}`)\n            : undefined;\n        return withDedupe(() => withRetry(async () => {\n            try {\n                return await request(args);\n            }\n            catch (err_) {\n                const err = err_;\n                switch (err.code) {\n                    // -32700\n                    case ParseRpcError.code:\n                        throw new ParseRpcError(err);\n                    // -32600\n                    case InvalidRequestRpcError.code:\n                        throw new InvalidRequestRpcError(err);\n                    // -32601\n                    case MethodNotFoundRpcError.code:\n                        throw new MethodNotFoundRpcError(err, { method: args.method });\n                    // -32602\n                    case InvalidParamsRpcError.code:\n                        throw new InvalidParamsRpcError(err);\n                    // -32603\n                    case InternalRpcError.code:\n                        throw new InternalRpcError(err);\n                    // -32000\n                    case InvalidInputRpcError.code:\n                        throw new InvalidInputRpcError(err);\n                    // -32001\n                    case ResourceNotFoundRpcError.code:\n                        throw new ResourceNotFoundRpcError(err);\n                    // -32002\n                    case ResourceUnavailableRpcError.code:\n                        throw new ResourceUnavailableRpcError(err);\n                    // -32003\n                    case TransactionRejectedRpcError.code:\n                        throw new TransactionRejectedRpcError(err);\n                    // -32004\n                    case MethodNotSupportedRpcError.code:\n                        throw new MethodNotSupportedRpcError(err, {\n                            method: args.method,\n                        });\n                    // -32005\n                    case LimitExceededRpcError.code:\n                        throw new LimitExceededRpcError(err);\n                    // -32006\n                    case JsonRpcVersionUnsupportedError.code:\n                        throw new JsonRpcVersionUnsupportedError(err);\n                    // 4001\n                    case UserRejectedRequestError.code:\n                        throw new UserRejectedRequestError(err);\n                    // 4100\n                    case UnauthorizedProviderError.code:\n                        throw new UnauthorizedProviderError(err);\n                    // 4200\n                    case UnsupportedProviderMethodError.code:\n                        throw new UnsupportedProviderMethodError(err);\n                    // 4900\n                    case ProviderDisconnectedError.code:\n                        throw new ProviderDisconnectedError(err);\n                    // 4901\n                    case ChainDisconnectedError.code:\n                        throw new ChainDisconnectedError(err);\n                    // 4902\n                    case SwitchChainError.code:\n                        throw new SwitchChainError(err);\n                    // 5700\n                    case UnsupportedNonOptionalCapabilityError.code:\n                        throw new UnsupportedNonOptionalCapabilityError(err);\n                    // 5710\n                    case UnsupportedChainIdError.code:\n                        throw new UnsupportedChainIdError(err);\n                    // 5720\n                    case DuplicateIdError.code:\n                        throw new DuplicateIdError(err);\n                    // 5730\n                    case UnknownBundleIdError.code:\n                        throw new UnknownBundleIdError(err);\n                    // 5740\n                    case BundleTooLargeError.code:\n                        throw new BundleTooLargeError(err);\n                    // 5750\n                    case AtomicReadyWalletRejectedUpgradeError.code:\n                        throw new AtomicReadyWalletRejectedUpgradeError(err);\n                    // 5760\n                    case AtomicityNotSupportedError.code:\n                        throw new AtomicityNotSupportedError(err);\n                    // CAIP-25: User Rejected Error\n                    // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25\n                    case 5000:\n                        throw new UserRejectedRequestError(err);\n                    default:\n                        if (err_ instanceof BaseError)\n                            throw err_;\n                        throw new UnknownRpcError(err);\n                }\n            }\n        }, {\n            delay: ({ count, error }) => {\n                // If we find a Retry-After header, let's retry after the given time.\n                if (error && error instanceof HttpRequestError) {\n                    const retryAfter = error?.headers?.get('Retry-After');\n                    if (retryAfter?.match(/\\d/))\n                        return Number.parseInt(retryAfter, 10) * 1000;\n                }\n                // Otherwise, let's retry with an exponential backoff.\n                return ~~(1 << count) * retryDelay;\n            },\n            retryCount,\n            shouldRetry: ({ error }) => shouldRetry(error),\n        }), { enabled: dedupe, id: requestId });\n    };\n}\n/** @internal */\nexport function shouldRetry(error) {\n    if ('code' in error && typeof error.code === 'number') {\n        if (error.code === -1)\n            return true; // Unknown error\n        if (error.code === LimitExceededRpcError.code)\n            return true;\n        if (error.code === InternalRpcError.code)\n            return true;\n        return false;\n    }\n    if (error instanceof HttpRequestError && error.status) {\n        // Forbidden\n        if (error.status === 403)\n            return true;\n        // Request Timeout\n        if (error.status === 408)\n            return true;\n        // Request Entity Too Large\n        if (error.status === 413)\n            return true;\n        // Too Many Requests\n        if (error.status === 429)\n            return true;\n        // Internal Server Error\n        if (error.status === 500)\n            return true;\n        // Bad Gateway\n        if (error.status === 502)\n            return true;\n        // Service Unavailable\n        if (error.status === 503)\n            return true;\n        // Gateway Timeout\n        if (error.status === 504)\n            return true;\n        return false;\n    }\n    return true;\n}\n//# sourceMappingURL=buildRequest.js.map"],"names":["buildRequest","request","options","async","args","overrideOptions","dedupe","methods","retryDelay","retryCount","uid","method","exclude","includes","MethodNotSupportedRpcError","Error","include","requestId","stringToHex","stringify","undefined","withDedupe","withRetry","err_","err","code","ParseRpcError","InvalidRequestRpcError","MethodNotFoundRpcError","InvalidParamsRpcError","InternalRpcError","InvalidInputRpcError","ResourceNotFoundRpcError","ResourceUnavailableRpcError","TransactionRejectedRpcError","LimitExceededRpcError","JsonRpcVersionUnsupportedError","UserRejectedRequestError","UnauthorizedProviderError","UnsupportedProviderMethodError","ProviderDisconnectedError","ChainDisconnectedError","SwitchChainError","UnsupportedNonOptionalCapabilityError","UnsupportedChainIdError","DuplicateIdError","UnknownBundleIdError","BundleTooLargeError","AtomicReadyWalletRejectedUpgradeError","AtomicityNotSupportedError","BaseError","UnknownRpcError","delay","count","error","HttpRequestError","retryAfter","headers","get","match","Number","parseInt","shouldRetry","enabled","id","status"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"ccip.js","sources":["../../../../../../node_modules/viem/_esm/utils/ccip.js"],"sourcesContent":["import { call } from '../actions/public/call.js';\nimport { OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError, } from '../errors/ccip.js';\nimport { HttpRequestError, } from '../errors/request.js';\nimport { decodeErrorResult } from './abi/decodeErrorResult.js';\nimport { encodeAbiParameters } from './abi/encodeAbiParameters.js';\nimport { isAddressEqual } from './address/isAddressEqual.js';\nimport { concat } from './data/concat.js';\nimport { isHex } from './data/isHex.js';\nimport { localBatchGatewayRequest, localBatchGatewayUrl, } from './ens/localBatchGatewayRequest.js';\nimport { stringify } from './stringify.js';\nexport const offchainLookupSignature = '0x556f1830';\nexport const offchainLookupAbiItem = {\n    name: 'OffchainLookup',\n    type: 'error',\n    inputs: [\n        {\n            name: 'sender',\n            type: 'address',\n        },\n        {\n            name: 'urls',\n            type: 'string[]',\n        },\n        {\n            name: 'callData',\n            type: 'bytes',\n        },\n        {\n            name: 'callbackFunction',\n            type: 'bytes4',\n        },\n        {\n            name: 'extraData',\n            type: 'bytes',\n        },\n    ],\n};\nexport async function offchainLookup(client, { blockNumber, blockTag, data, to, }) {\n    const { args } = decodeErrorResult({\n        data,\n        abi: [offchainLookupAbiItem],\n    });\n    const [sender, urls, callData, callbackSelector, extraData] = args;\n    const { ccipRead } = client;\n    const ccipRequest_ = ccipRead && typeof ccipRead?.request === 'function'\n        ? ccipRead.request\n        : ccipRequest;\n    try {\n        if (!isAddressEqual(to, sender))\n            throw new OffchainLookupSenderMismatchError({ sender, to });\n        const result = urls.includes(localBatchGatewayUrl)\n            ? await localBatchGatewayRequest({\n                data: callData,\n                ccipRequest: ccipRequest_,\n            })\n            : await ccipRequest_({ data: callData, sender, urls });\n        const { data: data_ } = await call(client, {\n            blockNumber,\n            blockTag,\n            data: concat([\n                callbackSelector,\n                encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }], [result, extraData]),\n            ]),\n            to,\n        });\n        return data_;\n    }\n    catch (err) {\n        throw new OffchainLookupError({\n            callbackSelector,\n            cause: err,\n            data,\n            extraData,\n            sender,\n            urls,\n        });\n    }\n}\nexport async function ccipRequest({ data, sender, urls, }) {\n    let error = new Error('An unknown error occurred.');\n    for (let i = 0; i < urls.length; i++) {\n        const url = urls[i];\n        const method = url.includes('{data}') ? 'GET' : 'POST';\n        const body = method === 'POST' ? { data, sender } : undefined;\n        const headers = method === 'POST' ? { 'Content-Type': 'application/json' } : {};\n        try {\n            const response = await fetch(url.replace('{sender}', sender.toLowerCase()).replace('{data}', data), {\n                body: JSON.stringify(body),\n                headers,\n                method,\n            });\n            let result;\n            if (response.headers.get('Content-Type')?.startsWith('application/json')) {\n                result = (await response.json()).data;\n            }\n            else {\n                result = (await response.text());\n            }\n            if (!response.ok) {\n                error = new HttpRequestError({\n                    body,\n                    details: result?.error\n                        ? stringify(result.error)\n                        : response.statusText,\n                    headers: response.headers,\n                    status: response.status,\n                    url,\n                });\n                continue;\n            }\n            if (!isHex(result)) {\n                error = new OffchainLookupResponseMalformedError({\n                    result,\n                    url,\n                });\n                continue;\n            }\n            return result;\n        }\n        catch (err) {\n            error = new HttpRequestError({\n                body,\n                details: err.message,\n                url,\n            });\n        }\n    }\n    throw error;\n}\n//# sourceMappingURL=ccip.js.map"],"names":["offchainLookupSignature","offchainLookupAbiItem","name","type","inputs","async","offchainLookup","client","blockNumber","blockTag","data","to","args","decodeErrorResult","abi","sender","urls","callData","callbackSelector","extraData","ccipRead","ccipRequest_","request","ccipRequest","isAddressEqual","OffchainLookupSenderMismatchError","result","includes","localBatchGatewayUrl","localBatchGatewayRequest","data_","call","concat","encodeAbiParameters","err","OffchainLookupError","cause","error","Error","i","length","url","method","body","undefined","headers","response","fetch","replace","toLowerCase","JSON","stringify","get","startsWith","json","text","ok","HttpRequestError","details","statusText","status","isHex","OffchainLookupResponseMalformedError","message"],"mappings":"qpBAUY,MAACA,EAA0B,aAC1BC,EAAwB,CACjCC,KAAM,iBACNC,KAAM,QACNC,OAAQ,CACJ,CACIF,KAAM,SACNC,KAAM,WAEV,CACID,KAAM,OACNC,KAAM,YAEV,CACID,KAAM,WACNC,KAAM,SAEV,CACID,KAAM,mBACNC,KAAM,UAEV,CACID,KAAM,YACNC,KAAM,WAIXE,eAAeC,EAAeC,GAAQC,YAAEA,EAAWC,SAAEA,EAAQC,KAAEA,EAAIC,GAAEA,IACxE,MAAMC,KAAEA,GAASC,EAAkB,CAC/BH,OACAI,IAAK,CAACb,MAEHc,EAAQC,EAAMC,EAAUC,EAAkBC,GAAaP,GACxDQ,SAAEA,GAAab,EACfc,EAAeD,GAAyC,mBAAtBA,GAAUE,QAC5CF,EAASE,QACTC,EACN,IACI,IAAKC,EAAeb,EAAII,GACpB,MAAM,IAAIU,EAAkC,CAAEV,SAAQJ,OAC1D,MAAMe,EAASV,EAAKW,SAASC,SACjBC,EAAyB,CAC7BnB,KAAMO,EACNM,YAAaF,UAETA,EAAa,CAAEX,KAAMO,EAAUF,SAAQC,UAC3CN,KAAMoB,SAAgBC,EAAKxB,EAAQ,CACvCC,cACAC,WACAC,KAAMsB,EAAO,CACTd,EACAe,EAAoB,CAAC,CAAE9B,KAAM,SAAW,CAAEA,KAAM,UAAY,CAACuB,EAAQP,MAEzER,OAEJ,OAAOmB,CACX,CACA,MAAOI,GACH,MAAM,IAAIC,EAAoB,CAC1BjB,mBACAkB,MAAOF,EACPxB,OACAS,YACAJ,SACAC,QAER,CACJ,CACOX,eAAekB,GAAYb,KAAEA,EAAIK,OAAEA,EAAMC,KAAEA,IAC9C,IAAIqB,EAAQ,IAAIC,MAAM,8BACtB,IAAK,IAAIC,EAAI,EAAGA,EAAIvB,EAAKwB,OAAQD,IAAK,CAClC,MAAME,EAAMzB,EAAKuB,GACXG,EAASD,EAAId,SAAS,UAAY,MAAQ,OAC1CgB,EAAkB,SAAXD,EAAoB,CAAEhC,OAAMK,eAAW6B,EAC9CC,EAAqB,SAAXH,EAAoB,CAAE,eAAgB,oBAAuB,CAAA,EAC7E,IACI,MAAMI,QAAiBC,MAAMN,EAAIO,QAAQ,WAAYjC,EAAOkC,eAAeD,QAAQ,SAAUtC,GAAO,CAChGiC,KAAMO,KAAKC,UAAUR,GACrBE,UACAH,WAEJ,IAAIhB,EAOJ,GALIA,EADAoB,EAASD,QAAQO,IAAI,iBAAiBC,WAAW,2BACjCP,EAASQ,QAAQ5C,WAGjBoC,EAASS,QAExBT,EAASU,GAAI,CACdnB,EAAQ,IAAIoB,EAAiB,CACzBd,OACAe,QAAShC,GAAQW,MACXc,EAAUzB,EAAOW,OACjBS,EAASa,WACfd,QAASC,EAASD,QAClBe,OAAQd,EAASc,OACjBnB,QAEJ,QACJ,CACA,IAAKoB,EAAMnC,GAAS,CAChBW,EAAQ,IAAIyB,EAAqC,CAC7CpC,SACAe,QAEJ,QACJ,CACA,OAAOf,CACX,CACA,MAAOQ,GACHG,EAAQ,IAAIoB,EAAiB,CACzBd,OACAe,QAASxB,EAAI6B,QACbtB,OAER,CACJ,CACA,MAAMJ,CACV","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/chain/getChainContractAddress.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getChainContractAddress.js","sources":["../../../../../../../node_modules/viem/_esm/utils/chain/getChainContractAddress.js"],"sourcesContent":["import { ChainDoesNotSupportContract, } from '../../errors/chain.js';\nexport function getChainContractAddress({ blockNumber, chain, contract: name, }) {\n    const contract = chain?.contracts?.[name];\n    if (!contract)\n        throw new ChainDoesNotSupportContract({\n            chain,\n            contract: { name },\n        });\n    if (blockNumber &&\n        contract.blockCreated &&\n        contract.blockCreated > blockNumber)\n        throw new ChainDoesNotSupportContract({\n            blockNumber,\n            chain,\n            contract: {\n                name,\n                blockCreated: contract.blockCreated,\n            },\n        });\n    return contract.address;\n}\n//# sourceMappingURL=getChainContractAddress.js.map"],"names":["getChainContractAddress","blockNumber","chain","contract","name","contracts","ChainDoesNotSupportContract","blockCreated","address"],"mappings":"oEACO,SAASA,GAAwBC,YAAEA,EAAWC,MAAEA,EAAOC,SAAUC,IACpE,MAAMD,EAAWD,GAAOG,YAAYD,GACpC,IAAKD,EACD,MAAM,IAAIG,EAA4B,CAClCJ,QACAC,SAAU,CAAEC,UAEpB,GAAIH,GACAE,EAASI,cACTJ,EAASI,aAAeN,EACxB,MAAM,IAAIK,EAA4B,CAClCL,cACAC,QACAC,SAAU,CACNC,OACAG,aAAcJ,EAASI,gBAGnC,OAAOJ,EAASK,OACpB","x_google_ignoreList":[0]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"cursor.js","sources":["../../../../../../node_modules/viem/_esm/utils/cursor.js"],"sourcesContent":["import { NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError, } from '../errors/cursor.js';\nconst staticCursor = {\n    bytes: new Uint8Array(),\n    dataView: new DataView(new ArrayBuffer(0)),\n    position: 0,\n    positionReadCount: new Map(),\n    recursiveReadCount: 0,\n    recursiveReadLimit: Number.POSITIVE_INFINITY,\n    assertReadLimit() {\n        if (this.recursiveReadCount >= this.recursiveReadLimit)\n            throw new RecursiveReadLimitExceededError({\n                count: this.recursiveReadCount + 1,\n                limit: this.recursiveReadLimit,\n            });\n    },\n    assertPosition(position) {\n        if (position < 0 || position > this.bytes.length - 1)\n            throw new PositionOutOfBoundsError({\n                length: this.bytes.length,\n                position,\n            });\n    },\n    decrementPosition(offset) {\n        if (offset < 0)\n            throw new NegativeOffsetError({ offset });\n        const position = this.position - offset;\n        this.assertPosition(position);\n        this.position = position;\n    },\n    getReadCount(position) {\n        return this.positionReadCount.get(position || this.position) || 0;\n    },\n    incrementPosition(offset) {\n        if (offset < 0)\n            throw new NegativeOffsetError({ offset });\n        const position = this.position + offset;\n        this.assertPosition(position);\n        this.position = position;\n    },\n    inspectByte(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position);\n        return this.bytes[position];\n    },\n    inspectBytes(length, position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position + length - 1);\n        return this.bytes.subarray(position, position + length);\n    },\n    inspectUint8(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position);\n        return this.bytes[position];\n    },\n    inspectUint16(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position + 1);\n        return this.dataView.getUint16(position);\n    },\n    inspectUint24(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position + 2);\n        return ((this.dataView.getUint16(position) << 8) +\n            this.dataView.getUint8(position + 2));\n    },\n    inspectUint32(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position + 3);\n        return this.dataView.getUint32(position);\n    },\n    pushByte(byte) {\n        this.assertPosition(this.position);\n        this.bytes[this.position] = byte;\n        this.position++;\n    },\n    pushBytes(bytes) {\n        this.assertPosition(this.position + bytes.length - 1);\n        this.bytes.set(bytes, this.position);\n        this.position += bytes.length;\n    },\n    pushUint8(value) {\n        this.assertPosition(this.position);\n        this.bytes[this.position] = value;\n        this.position++;\n    },\n    pushUint16(value) {\n        this.assertPosition(this.position + 1);\n        this.dataView.setUint16(this.position, value);\n        this.position += 2;\n    },\n    pushUint24(value) {\n        this.assertPosition(this.position + 2);\n        this.dataView.setUint16(this.position, value >> 8);\n        this.dataView.setUint8(this.position + 2, value & ~4294967040);\n        this.position += 3;\n    },\n    pushUint32(value) {\n        this.assertPosition(this.position + 3);\n        this.dataView.setUint32(this.position, value);\n        this.position += 4;\n    },\n    readByte() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectByte();\n        this.position++;\n        return value;\n    },\n    readBytes(length, size) {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectBytes(length);\n        this.position += size ?? length;\n        return value;\n    },\n    readUint8() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectUint8();\n        this.position += 1;\n        return value;\n    },\n    readUint16() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectUint16();\n        this.position += 2;\n        return value;\n    },\n    readUint24() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectUint24();\n        this.position += 3;\n        return value;\n    },\n    readUint32() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectUint32();\n        this.position += 4;\n        return value;\n    },\n    get remaining() {\n        return this.bytes.length - this.position;\n    },\n    setPosition(position) {\n        const oldPosition = this.position;\n        this.assertPosition(position);\n        this.position = position;\n        return () => (this.position = oldPosition);\n    },\n    _touch() {\n        if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)\n            return;\n        const count = this.getReadCount();\n        this.positionReadCount.set(this.position, count + 1);\n        if (count > 0)\n            this.recursiveReadCount++;\n    },\n};\nexport function createCursor(bytes, { recursiveReadLimit = 8_192 } = {}) {\n    const cursor = Object.create(staticCursor);\n    cursor.bytes = bytes;\n    cursor.dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    cursor.positionReadCount = new Map();\n    cursor.recursiveReadLimit = recursiveReadLimit;\n    return cursor;\n}\n//# sourceMappingURL=cursor.js.map"],"names":["staticCursor","bytes","Uint8Array","dataView","DataView","ArrayBuffer","position","positionReadCount","Map","recursiveReadCount","recursiveReadLimit","Number","POSITIVE_INFINITY","assertReadLimit","this","RecursiveReadLimitExceededError","count","limit","assertPosition","length","PositionOutOfBoundsError","decrementPosition","offset","NegativeOffsetError","getReadCount","get","incrementPosition","inspectByte","position_","inspectBytes","subarray","inspectUint8","inspectUint16","getUint16","inspectUint24","getUint8","inspectUint32","getUint32","pushByte","byte","pushBytes","set","pushUint8","value","pushUint16","setUint16","pushUint24","setUint8","pushUint32","setUint32","readByte","_touch","readBytes","size","readUint8","readUint16","readUint24","readUint32","remaining","setPosition","oldPosition","createCursor","cursor","Object","create","buffer","byteOffset","byteLength"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/data/concat.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"concat.js","sources":["../../../../../../../node_modules/viem/_esm/utils/data/concat.js"],"sourcesContent":["export function concat(values) {\n    if (typeof values[0] === 'string')\n        return concatHex(values);\n    return concatBytes(values);\n}\nexport function concatBytes(values) {\n    let length = 0;\n    for (const arr of values) {\n        length += arr.length;\n    }\n    const result = new Uint8Array(length);\n    let offset = 0;\n    for (const arr of values) {\n        result.set(arr, offset);\n        offset += arr.length;\n    }\n    return result;\n}\nexport function concatHex(values) {\n    return `0x${values.reduce((acc, x) => acc + x.replace('0x', ''), '')}`;\n}\n//# sourceMappingURL=concat.js.map"],"names":["concat","values","concatHex","concatBytes","length","arr","result","Uint8Array","offset","set","reduce","acc","x","replace"],"mappings":"AAAO,SAASA,EAAOC,GACnB,MAAyB,iBAAdA,EAAO,GACPC,EAAUD,GACdE,EAAYF,EACvB,CACO,SAASE,EAAYF,GACxB,IAAIG,EAAS,EACb,IAAK,MAAMC,KAAOJ,EACdG,GAAUC,EAAID,OAElB,MAAME,EAAS,IAAIC,WAAWH,GAC9B,IAAII,EAAS,EACb,IAAK,MAAMH,KAAOJ,EACdK,EAAOG,IAAIJ,EAAKG,GAChBA,GAAUH,EAAID,OAElB,OAAOE,CACX,CACO,SAASJ,EAAUD,GACtB,MAAO,KAAKA,EAAOS,OAAO,CAACC,EAAKC,IAAMD,EAAMC,EAAEC,QAAQ,KAAM,IAAK,KACrE","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/data/isHex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isHex.js","sources":["../../../../../../../node_modules/viem/_esm/utils/data/isHex.js"],"sourcesContent":["export function isHex(value, { strict = true } = {}) {\n    if (!value)\n        return false;\n    if (typeof value !== 'string')\n        return false;\n    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith('0x');\n}\n//# sourceMappingURL=isHex.js.map"],"names":["isHex","value","strict","test","startsWith"],"mappings":"AAAO,SAASA,EAAMC,GAAOC,OAAEA,GAAS,GAAS,CAAA,GAC7C,QAAKD,IAEgB,iBAAVA,IAEJC,EAAS,mBAAmBC,KAAKF,GAASA,EAAMG,WAAW,OACtE","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/data/pad.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pad.js","sources":["../../../../../../../node_modules/viem/_esm/utils/data/pad.js"],"sourcesContent":["import { SizeExceedsPaddingSizeError, } from '../../errors/data.js';\nexport function pad(hexOrBytes, { dir, size = 32 } = {}) {\n    if (typeof hexOrBytes === 'string')\n        return padHex(hexOrBytes, { dir, size });\n    return padBytes(hexOrBytes, { dir, size });\n}\nexport function padHex(hex_, { dir, size = 32 } = {}) {\n    if (size === null)\n        return hex_;\n    const hex = hex_.replace('0x', '');\n    if (hex.length > size * 2)\n        throw new SizeExceedsPaddingSizeError({\n            size: Math.ceil(hex.length / 2),\n            targetSize: size,\n            type: 'hex',\n        });\n    return `0x${hex[dir === 'right' ? 'padEnd' : 'padStart'](size * 2, '0')}`;\n}\nexport function padBytes(bytes, { dir, size = 32 } = {}) {\n    if (size === null)\n        return bytes;\n    if (bytes.length > size)\n        throw new SizeExceedsPaddingSizeError({\n            size: bytes.length,\n            targetSize: size,\n            type: 'bytes',\n        });\n    const paddedBytes = new Uint8Array(size);\n    for (let i = 0; i < size; i++) {\n        const padEnd = dir === 'right';\n        paddedBytes[padEnd ? i : size - i - 1] =\n            bytes[padEnd ? i : bytes.length - i - 1];\n    }\n    return paddedBytes;\n}\n//# sourceMappingURL=pad.js.map"],"names":["pad","hexOrBytes","dir","size","padHex","padBytes","hex_","hex","replace","length","SizeExceedsPaddingSizeError","Math","ceil","targetSize","type","bytes","paddedBytes","Uint8Array","i","padEnd"],"mappings":"mEACO,SAASA,EAAIC,GAAYC,IAAEA,EAAGC,KAAEA,EAAO,IAAO,IACjD,MAA0B,iBAAfF,EACAG,EAAOH,EAAY,CAAEC,MAAKC,SAC9BE,EAASJ,EAAY,CAAEC,MAAKC,QACvC,CACO,SAASC,EAAOE,GAAMJ,IAAEA,EAAGC,KAAEA,EAAO,IAAO,IAC9C,GAAa,OAATA,EACA,OAAOG,EACX,MAAMC,EAAMD,EAAKE,QAAQ,KAAM,IAC/B,GAAID,EAAIE,OAAgB,EAAPN,EACb,MAAM,IAAIO,EAA4B,CAClCP,KAAMQ,KAAKC,KAAKL,EAAIE,OAAS,GAC7BI,WAAYV,EACZW,KAAM,QAEd,MAAO,KAAKP,EAAY,UAARL,EAAkB,SAAW,YAAmB,EAAPC,EAAU,MACvE,CACO,SAASE,EAASU,GAAOb,IAAEA,EAAGC,KAAEA,EAAO,IAAO,IACjD,GAAa,OAATA,EACA,OAAOY,EACX,GAAIA,EAAMN,OAASN,EACf,MAAM,IAAIO,EAA4B,CAClCP,KAAMY,EAAMN,OACZI,WAAYV,EACZW,KAAM,UAEd,MAAME,EAAc,IAAIC,WAAWd,GACnC,IAAK,IAAIe,EAAI,EAAGA,EAAIf,EAAMe,IAAK,CAC3B,MAAMC,EAAiB,UAARjB,EACfc,EAAYG,EAASD,EAAIf,EAAOe,EAAI,GAChCH,EAAMI,EAASD,EAAIH,EAAMN,OAASS,EAAI,EAC9C,CACA,OAAOF,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/data/size.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"size.js","sources":["../../../../../../../node_modules/viem/_esm/utils/data/size.js"],"sourcesContent":["import { isHex } from './isHex.js';\n/**\n * @description Retrieves the size of the value (in bytes).\n *\n * @param value The value (hex or byte array) to retrieve the size of.\n * @returns The size of the value (in bytes).\n */\nexport function size(value) {\n    if (isHex(value, { strict: false }))\n        return Math.ceil((value.length - 2) / 2);\n    return value.length;\n}\n//# sourceMappingURL=size.js.map"],"names":["size","value","isHex","strict","Math","ceil","length"],"mappings":"mCAOO,SAASA,EAAKC,GACjB,OAAIC,EAAMD,EAAO,CAAEE,QAAQ,IAChBC,KAAKC,MAAMJ,EAAMK,OAAS,GAAK,GACnCL,EAAMK,MACjB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/data/slice.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"slice.js","sources":["../../../../../../../node_modules/viem/_esm/utils/data/slice.js"],"sourcesContent":["import { SliceOffsetOutOfBoundsError, } from '../../errors/data.js';\nimport { isHex } from './isHex.js';\nimport { size } from './size.js';\n/**\n * @description Returns a section of the hex or byte array given a start/end bytes offset.\n *\n * @param value The hex or byte array to slice.\n * @param start The start offset (in bytes).\n * @param end The end offset (in bytes).\n */\nexport function slice(value, start, end, { strict } = {}) {\n    if (isHex(value, { strict: false }))\n        return sliceHex(value, start, end, {\n            strict,\n        });\n    return sliceBytes(value, start, end, {\n        strict,\n    });\n}\nfunction assertStartOffset(value, start) {\n    if (typeof start === 'number' && start > 0 && start > size(value) - 1)\n        throw new SliceOffsetOutOfBoundsError({\n            offset: start,\n            position: 'start',\n            size: size(value),\n        });\n}\nfunction assertEndOffset(value, start, end) {\n    if (typeof start === 'number' &&\n        typeof end === 'number' &&\n        size(value) !== end - start) {\n        throw new SliceOffsetOutOfBoundsError({\n            offset: end,\n            position: 'end',\n            size: size(value),\n        });\n    }\n}\n/**\n * @description Returns a section of the byte array given a start/end bytes offset.\n *\n * @param value The byte array to slice.\n * @param start The start offset (in bytes).\n * @param end The end offset (in bytes).\n */\nexport function sliceBytes(value_, start, end, { strict } = {}) {\n    assertStartOffset(value_, start);\n    const value = value_.slice(start, end);\n    if (strict)\n        assertEndOffset(value, start, end);\n    return value;\n}\n/**\n * @description Returns a section of the hex value given a start/end bytes offset.\n *\n * @param value The hex value to slice.\n * @param start The start offset (in bytes).\n * @param end The end offset (in bytes).\n */\nexport function sliceHex(value_, start, end, { strict } = {}) {\n    assertStartOffset(value_, start);\n    const value = `0x${value_\n        .replace('0x', '')\n        .slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;\n    if (strict)\n        assertEndOffset(value, start, end);\n    return value;\n}\n//# sourceMappingURL=slice.js.map"],"names":["slice","value","start","end","strict","isHex","sliceHex","sliceBytes","assertStartOffset","size","SliceOffsetOutOfBoundsError","offset","position","assertEndOffset","value_","replace","length"],"mappings":"uIAUO,SAASA,EAAMC,EAAOC,EAAOC,GAAKC,OAAEA,GAAW,IAClD,OAAIC,EAAMJ,EAAO,CAAEG,QAAQ,IAChBE,EAASL,EAAOC,EAAOC,EAAK,CAC/BC,WAEDG,EAAWN,EAAOC,EAAOC,EAAK,CACjCC,UAER,CACA,SAASI,EAAkBP,EAAOC,GAC9B,GAAqB,iBAAVA,GAAsBA,EAAQ,GAAKA,EAAQO,EAAKR,GAAS,EAChE,MAAM,IAAIS,EAA4B,CAClCC,OAAQT,EACRU,SAAU,QACVH,KAAMA,EAAKR,IAEvB,CACA,SAASY,EAAgBZ,EAAOC,EAAOC,GACnC,GAAqB,iBAAVD,GACQ,iBAARC,GACPM,EAAKR,KAAWE,EAAMD,EACtB,MAAM,IAAIQ,EAA4B,CAClCC,OAAQR,EACRS,SAAU,MACVH,KAAMA,EAAKR,IAGvB,CAQO,SAASM,EAAWO,EAAQZ,EAAOC,GAAKC,OAAEA,GAAW,IACxDI,EAAkBM,EAAQZ,GAC1B,MAAMD,EAAQa,EAAOd,MAAME,EAAOC,GAGlC,OAFIC,GACAS,EAAgBZ,EAAOC,EAAOC,GAC3BF,CACX,CAQO,SAASK,EAASQ,EAAQZ,EAAOC,GAAKC,OAAEA,GAAW,IACtDI,EAAkBM,EAAQZ,GAC1B,MAAMD,EAAQ,KAAKa,EACdC,QAAQ,KAAM,IACdf,MAAqB,GAAdE,GAAS,GAAiC,GAAxBC,GAAOW,EAAOE,WAG5C,OAFIZ,GACAS,EAAgBZ,EAAOC,EAAOC,GAC3BF,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/data/trim.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"trim.js","sources":["../../../../../../../node_modules/viem/_esm/utils/data/trim.js"],"sourcesContent":["export function trim(hexOrBytes, { dir = 'left' } = {}) {\n    let data = typeof hexOrBytes === 'string' ? hexOrBytes.replace('0x', '') : hexOrBytes;\n    let sliceLength = 0;\n    for (let i = 0; i < data.length - 1; i++) {\n        if (data[dir === 'left' ? i : data.length - i - 1].toString() === '0')\n            sliceLength++;\n        else\n            break;\n    }\n    data =\n        dir === 'left'\n            ? data.slice(sliceLength)\n            : data.slice(0, data.length - sliceLength);\n    if (typeof hexOrBytes === 'string') {\n        if (data.length === 1 && dir === 'right')\n            data = `${data}0`;\n        return `0x${data.length % 2 === 1 ? `0${data}` : data}`;\n    }\n    return data;\n}\n//# sourceMappingURL=trim.js.map"],"names":["trim","hexOrBytes","dir","data","replace","sliceLength","i","length","toString","slice"],"mappings":"AAAO,SAASA,EAAKC,GAAYC,IAAEA,EAAM,QAAW,CAAA,GAChD,IAAIC,EAA6B,iBAAfF,EAA0BA,EAAWG,QAAQ,KAAM,IAAMH,EACvEI,EAAc,EAClB,IAAK,IAAIC,EAAI,EAAGA,EAAIH,EAAKI,OAAS,GACoC,MAA9DJ,EAAa,SAARD,EAAiBI,EAAIH,EAAKI,OAASD,EAAI,GAAGE,WADlBF,IAE7BD,IAQR,OAJAF,EACY,SAARD,EACMC,EAAKM,MAAMJ,GACXF,EAAKM,MAAM,EAAGN,EAAKI,OAASF,GACZ,iBAAfJ,GACa,IAAhBE,EAAKI,QAAwB,UAARL,IACrBC,EAAO,GAAGA,MACP,KAAKA,EAAKI,OAAS,GAAM,EAAI,IAAIJ,IAASA,KAE9CA,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/encoding/fromBytes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fromBytes.js","sources":["../../../../../../../node_modules/viem/_esm/utils/encoding/fromBytes.js"],"sourcesContent":["import { InvalidBytesBooleanError } from '../../errors/encoding.js';\nimport { trim } from '../data/trim.js';\nimport { assertSize, hexToBigInt, hexToNumber, } from './fromHex.js';\nimport { bytesToHex } from './toHex.js';\n/**\n * Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.\n *\n * - Docs: https://viem.sh/docs/utilities/fromBytes\n * - Example: https://viem.sh/docs/utilities/fromBytes#usage\n *\n * @param bytes Byte array to decode.\n * @param toOrOpts Type to convert to or options.\n * @returns Decoded value.\n *\n * @example\n * import { fromBytes } from 'viem'\n * const data = fromBytes(new Uint8Array([1, 164]), 'number')\n * // 420\n *\n * @example\n * import { fromBytes } from 'viem'\n * const data = fromBytes(\n *   new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),\n *   'string'\n * )\n * // 'Hello world'\n */\nexport function fromBytes(bytes, toOrOpts) {\n    const opts = typeof toOrOpts === 'string' ? { to: toOrOpts } : toOrOpts;\n    const to = opts.to;\n    if (to === 'number')\n        return bytesToNumber(bytes, opts);\n    if (to === 'bigint')\n        return bytesToBigInt(bytes, opts);\n    if (to === 'boolean')\n        return bytesToBool(bytes, opts);\n    if (to === 'string')\n        return bytesToString(bytes, opts);\n    return bytesToHex(bytes, opts);\n}\n/**\n * Decodes a byte array into a bigint.\n *\n * - Docs: https://viem.sh/docs/utilities/fromBytes#bytestobigint\n *\n * @param bytes Byte array to decode.\n * @param opts Options.\n * @returns BigInt value.\n *\n * @example\n * import { bytesToBigInt } from 'viem'\n * const data = bytesToBigInt(new Uint8Array([1, 164]))\n * // 420n\n */\nexport function bytesToBigInt(bytes, opts = {}) {\n    if (typeof opts.size !== 'undefined')\n        assertSize(bytes, { size: opts.size });\n    const hex = bytesToHex(bytes, opts);\n    return hexToBigInt(hex, opts);\n}\n/**\n * Decodes a byte array into a boolean.\n *\n * - Docs: https://viem.sh/docs/utilities/fromBytes#bytestobool\n *\n * @param bytes Byte array to decode.\n * @param opts Options.\n * @returns Boolean value.\n *\n * @example\n * import { bytesToBool } from 'viem'\n * const data = bytesToBool(new Uint8Array([1]))\n * // true\n */\nexport function bytesToBool(bytes_, opts = {}) {\n    let bytes = bytes_;\n    if (typeof opts.size !== 'undefined') {\n        assertSize(bytes, { size: opts.size });\n        bytes = trim(bytes);\n    }\n    if (bytes.length > 1 || bytes[0] > 1)\n        throw new InvalidBytesBooleanError(bytes);\n    return Boolean(bytes[0]);\n}\n/**\n * Decodes a byte array into a number.\n *\n * - Docs: https://viem.sh/docs/utilities/fromBytes#bytestonumber\n *\n * @param bytes Byte array to decode.\n * @param opts Options.\n * @returns Number value.\n *\n * @example\n * import { bytesToNumber } from 'viem'\n * const data = bytesToNumber(new Uint8Array([1, 164]))\n * // 420\n */\nexport function bytesToNumber(bytes, opts = {}) {\n    if (typeof opts.size !== 'undefined')\n        assertSize(bytes, { size: opts.size });\n    const hex = bytesToHex(bytes, opts);\n    return hexToNumber(hex, opts);\n}\n/**\n * Decodes a byte array into a UTF-8 string.\n *\n * - Docs: https://viem.sh/docs/utilities/fromBytes#bytestostring\n *\n * @param bytes Byte array to decode.\n * @param opts Options.\n * @returns String value.\n *\n * @example\n * import { bytesToString } from 'viem'\n * const data = bytesToString(new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))\n * // 'Hello world'\n */\nexport function bytesToString(bytes_, opts = {}) {\n    let bytes = bytes_;\n    if (typeof opts.size !== 'undefined') {\n        assertSize(bytes, { size: opts.size });\n        bytes = trim(bytes, { dir: 'right' });\n    }\n    return new TextDecoder().decode(bytes);\n}\n//# sourceMappingURL=fromBytes.js.map"],"names":["bytesToBigInt","bytes","opts","size","assertSize","hex","bytesToHex","hexToBigInt","bytesToBool","bytes_","trim","length","InvalidBytesBooleanError","Boolean","bytesToNumber","hexToNumber","bytesToString","dir","TextDecoder","decode"],"mappings":"+NAsDO,SAASA,EAAcC,EAAOC,EAAO,SACf,IAAdA,EAAKC,MACZC,EAAWH,EAAO,CAAEE,KAAMD,EAAKC,OACnC,MAAME,EAAMC,EAAWL,EAAOC,GAC9B,OAAOK,EAAYF,EAAKH,EAC5B,CAeO,SAASM,EAAYC,EAAQP,EAAO,IACvC,IAAID,EAAQQ,EAKZ,QAJyB,IAAdP,EAAKC,OACZC,EAAWH,EAAO,CAAEE,KAAMD,EAAKC,OAC/BF,EAAQS,EAAKT,IAEbA,EAAMU,OAAS,GAAKV,EAAM,GAAK,EAC/B,MAAM,IAAIW,EAAyBX,GACvC,OAAOY,QAAQZ,EAAM,GACzB,CAeO,SAASa,EAAcb,EAAOC,EAAO,SACf,IAAdA,EAAKC,MACZC,EAAWH,EAAO,CAAEE,KAAMD,EAAKC,OACnC,MAAME,EAAMC,EAAWL,EAAOC,GAC9B,OAAOa,EAAYV,EAAKH,EAC5B,CAeO,SAASc,EAAcP,EAAQP,EAAO,IACzC,IAAID,EAAQQ,EAKZ,YAJyB,IAAdP,EAAKC,OACZC,EAAWH,EAAO,CAAEE,KAAMD,EAAKC,OAC/BF,EAAQS,EAAKT,EAAO,CAAEgB,IAAK,YAExB,IAAIC,aAAcC,OAAOlB,EACpC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/encoding/fromHex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fromHex.js","sources":["../../../../../../../node_modules/viem/_esm/utils/encoding/fromHex.js"],"sourcesContent":["import { InvalidHexBooleanError, SizeOverflowError, } from '../../errors/encoding.js';\nimport { size as size_ } from '../data/size.js';\nimport { trim } from '../data/trim.js';\nimport { hexToBytes } from './toBytes.js';\nexport function assertSize(hexOrBytes, { size }) {\n    if (size_(hexOrBytes) > size)\n        throw new SizeOverflowError({\n            givenSize: size_(hexOrBytes),\n            maxSize: size,\n        });\n}\n/**\n * Decodes a hex string into a string, number, bigint, boolean, or byte array.\n *\n * - Docs: https://viem.sh/docs/utilities/fromHex\n * - Example: https://viem.sh/docs/utilities/fromHex#usage\n *\n * @param hex Hex string to decode.\n * @param toOrOpts Type to convert to or options.\n * @returns Decoded value.\n *\n * @example\n * import { fromHex } from 'viem'\n * const data = fromHex('0x1a4', 'number')\n * // 420\n *\n * @example\n * import { fromHex } from 'viem'\n * const data = fromHex('0x48656c6c6f20576f726c6421', 'string')\n * // 'Hello world'\n *\n * @example\n * import { fromHex } from 'viem'\n * const data = fromHex('0x48656c6c6f20576f726c64210000000000000000000000000000000000000000', {\n *   size: 32,\n *   to: 'string'\n * })\n * // 'Hello world'\n */\nexport function fromHex(hex, toOrOpts) {\n    const opts = typeof toOrOpts === 'string' ? { to: toOrOpts } : toOrOpts;\n    const to = opts.to;\n    if (to === 'number')\n        return hexToNumber(hex, opts);\n    if (to === 'bigint')\n        return hexToBigInt(hex, opts);\n    if (to === 'string')\n        return hexToString(hex, opts);\n    if (to === 'boolean')\n        return hexToBool(hex, opts);\n    return hexToBytes(hex, opts);\n}\n/**\n * Decodes a hex value into a bigint.\n *\n * - Docs: https://viem.sh/docs/utilities/fromHex#hextobigint\n *\n * @param hex Hex value to decode.\n * @param opts Options.\n * @returns BigInt value.\n *\n * @example\n * import { hexToBigInt } from 'viem'\n * const data = hexToBigInt('0x1a4', { signed: true })\n * // 420n\n *\n * @example\n * import { hexToBigInt } from 'viem'\n * const data = hexToBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })\n * // 420n\n */\nexport function hexToBigInt(hex, opts = {}) {\n    const { signed } = opts;\n    if (opts.size)\n        assertSize(hex, { size: opts.size });\n    const value = BigInt(hex);\n    if (!signed)\n        return value;\n    const size = (hex.length - 2) / 2;\n    const max = (1n << (BigInt(size) * 8n - 1n)) - 1n;\n    if (value <= max)\n        return value;\n    return value - BigInt(`0x${'f'.padStart(size * 2, 'f')}`) - 1n;\n}\n/**\n * Decodes a hex value into a boolean.\n *\n * - Docs: https://viem.sh/docs/utilities/fromHex#hextobool\n *\n * @param hex Hex value to decode.\n * @param opts Options.\n * @returns Boolean value.\n *\n * @example\n * import { hexToBool } from 'viem'\n * const data = hexToBool('0x01')\n * // true\n *\n * @example\n * import { hexToBool } from 'viem'\n * const data = hexToBool('0x0000000000000000000000000000000000000000000000000000000000000001', { size: 32 })\n * // true\n */\nexport function hexToBool(hex_, opts = {}) {\n    let hex = hex_;\n    if (opts.size) {\n        assertSize(hex, { size: opts.size });\n        hex = trim(hex);\n    }\n    if (trim(hex) === '0x00')\n        return false;\n    if (trim(hex) === '0x01')\n        return true;\n    throw new InvalidHexBooleanError(hex);\n}\n/**\n * Decodes a hex string into a number.\n *\n * - Docs: https://viem.sh/docs/utilities/fromHex#hextonumber\n *\n * @param hex Hex value to decode.\n * @param opts Options.\n * @returns Number value.\n *\n * @example\n * import { hexToNumber } from 'viem'\n * const data = hexToNumber('0x1a4')\n * // 420\n *\n * @example\n * import { hexToNumber } from 'viem'\n * const data = hexToBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })\n * // 420\n */\nexport function hexToNumber(hex, opts = {}) {\n    return Number(hexToBigInt(hex, opts));\n}\n/**\n * Decodes a hex value into a UTF-8 string.\n *\n * - Docs: https://viem.sh/docs/utilities/fromHex#hextostring\n *\n * @param hex Hex value to decode.\n * @param opts Options.\n * @returns String value.\n *\n * @example\n * import { hexToString } from 'viem'\n * const data = hexToString('0x48656c6c6f20576f726c6421')\n * // 'Hello world!'\n *\n * @example\n * import { hexToString } from 'viem'\n * const data = hexToString('0x48656c6c6f20576f726c64210000000000000000000000000000000000000000', {\n *  size: 32,\n * })\n * // 'Hello world'\n */\nexport function hexToString(hex, opts = {}) {\n    let bytes = hexToBytes(hex);\n    if (opts.size) {\n        assertSize(bytes, { size: opts.size });\n        bytes = trim(bytes, { dir: 'right' });\n    }\n    return new TextDecoder().decode(bytes);\n}\n//# sourceMappingURL=fromHex.js.map"],"names":["assertSize","hexOrBytes","size","size_","SizeOverflowError","givenSize","maxSize","hexToBigInt","hex","opts","signed","value","BigInt","length","padStart","hexToBool","hex_","trim","InvalidHexBooleanError","hexToNumber","Number"],"mappings":"uKAIO,SAASA,EAAWC,GAAYC,KAAEA,IACrC,GAAIC,EAAMF,GAAcC,EACpB,MAAM,IAAIE,EAAkB,CACxBC,UAAWF,EAAMF,GACjBK,QAASJ,GAErB,CA6DO,SAASK,EAAYC,EAAKC,EAAO,IACpC,MAAMC,OAAEA,GAAWD,EACfA,EAAKP,MACLF,EAAWQ,EAAK,CAAEN,KAAMO,EAAKP,OACjC,MAAMS,EAAQC,OAAOJ,GACrB,IAAKE,EACD,OAAOC,EACX,MAAMT,GAAQM,EAAIK,OAAS,GAAK,EAEhC,OAAIF,IADS,IAAsB,GAAfC,OAAOV,GAAa,IAAO,GAEpCS,EACJA,EAAQC,OAAO,KAAK,IAAIE,SAAgB,EAAPZ,EAAU,QAAU,EAChE,CAoBO,SAASa,EAAUC,EAAMP,EAAO,IACnC,IAAID,EAAMQ,EAKV,GAJIP,EAAKP,OACLF,EAAWQ,EAAK,CAAEN,KAAMO,EAAKP,OAC7BM,EAAMS,EAAKT,IAEG,SAAdS,EAAKT,GACL,OAAO,EACX,GAAkB,SAAdS,EAAKT,GACL,OAAO,EACX,MAAM,IAAIU,EAAuBV,EACrC,CAoBO,SAASW,EAAYX,EAAKC,EAAO,IACpC,OAAOW,OAAOb,EAAYC,EAAKC,GACnC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/encoding/toBytes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toBytes.js","sources":["../../../../../../../node_modules/viem/_esm/utils/encoding/toBytes.js"],"sourcesContent":["import { BaseError } from '../../errors/base.js';\nimport { isHex } from '../data/isHex.js';\nimport { pad } from '../data/pad.js';\nimport { assertSize } from './fromHex.js';\nimport { numberToHex, } from './toHex.js';\nconst encoder = /*#__PURE__*/ new TextEncoder();\n/**\n * Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.\n *\n * - Docs: https://viem.sh/docs/utilities/toBytes\n * - Example: https://viem.sh/docs/utilities/toBytes#usage\n *\n * @param value Value to encode.\n * @param opts Options.\n * @returns Byte array value.\n *\n * @example\n * import { toBytes } from 'viem'\n * const data = toBytes('Hello world')\n * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])\n *\n * @example\n * import { toBytes } from 'viem'\n * const data = toBytes(420)\n * // Uint8Array([1, 164])\n *\n * @example\n * import { toBytes } from 'viem'\n * const data = toBytes(420, { size: 4 })\n * // Uint8Array([0, 0, 1, 164])\n */\nexport function toBytes(value, opts = {}) {\n    if (typeof value === 'number' || typeof value === 'bigint')\n        return numberToBytes(value, opts);\n    if (typeof value === 'boolean')\n        return boolToBytes(value, opts);\n    if (isHex(value))\n        return hexToBytes(value, opts);\n    return stringToBytes(value, opts);\n}\n/**\n * Encodes a boolean into a byte array.\n *\n * - Docs: https://viem.sh/docs/utilities/toBytes#booltobytes\n *\n * @param value Boolean value to encode.\n * @param opts Options.\n * @returns Byte array value.\n *\n * @example\n * import { boolToBytes } from 'viem'\n * const data = boolToBytes(true)\n * // Uint8Array([1])\n *\n * @example\n * import { boolToBytes } from 'viem'\n * const data = boolToBytes(true, { size: 32 })\n * // Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])\n */\nexport function boolToBytes(value, opts = {}) {\n    const bytes = new Uint8Array(1);\n    bytes[0] = Number(value);\n    if (typeof opts.size === 'number') {\n        assertSize(bytes, { size: opts.size });\n        return pad(bytes, { size: opts.size });\n    }\n    return bytes;\n}\n// We use very optimized technique to convert hex string to byte array\nconst charCodeMap = {\n    zero: 48,\n    nine: 57,\n    A: 65,\n    F: 70,\n    a: 97,\n    f: 102,\n};\nfunction charCodeToBase16(char) {\n    if (char >= charCodeMap.zero && char <= charCodeMap.nine)\n        return char - charCodeMap.zero;\n    if (char >= charCodeMap.A && char <= charCodeMap.F)\n        return char - (charCodeMap.A - 10);\n    if (char >= charCodeMap.a && char <= charCodeMap.f)\n        return char - (charCodeMap.a - 10);\n    return undefined;\n}\n/**\n * Encodes a hex string into a byte array.\n *\n * - Docs: https://viem.sh/docs/utilities/toBytes#hextobytes\n *\n * @param hex Hex string to encode.\n * @param opts Options.\n * @returns Byte array value.\n *\n * @example\n * import { hexToBytes } from 'viem'\n * const data = hexToBytes('0x48656c6c6f20776f726c6421')\n * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])\n *\n * @example\n * import { hexToBytes } from 'viem'\n * const data = hexToBytes('0x48656c6c6f20776f726c6421', { size: 32 })\n * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n */\nexport function hexToBytes(hex_, opts = {}) {\n    let hex = hex_;\n    if (opts.size) {\n        assertSize(hex, { size: opts.size });\n        hex = pad(hex, { dir: 'right', size: opts.size });\n    }\n    let hexString = hex.slice(2);\n    if (hexString.length % 2)\n        hexString = `0${hexString}`;\n    const length = hexString.length / 2;\n    const bytes = new Uint8Array(length);\n    for (let index = 0, j = 0; index < length; index++) {\n        const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));\n        const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));\n        if (nibbleLeft === undefined || nibbleRight === undefined) {\n            throw new BaseError(`Invalid byte sequence (\"${hexString[j - 2]}${hexString[j - 1]}\" in \"${hexString}\").`);\n        }\n        bytes[index] = nibbleLeft * 16 + nibbleRight;\n    }\n    return bytes;\n}\n/**\n * Encodes a number into a byte array.\n *\n * - Docs: https://viem.sh/docs/utilities/toBytes#numbertobytes\n *\n * @param value Number to encode.\n * @param opts Options.\n * @returns Byte array value.\n *\n * @example\n * import { numberToBytes } from 'viem'\n * const data = numberToBytes(420)\n * // Uint8Array([1, 164])\n *\n * @example\n * import { numberToBytes } from 'viem'\n * const data = numberToBytes(420, { size: 4 })\n * // Uint8Array([0, 0, 1, 164])\n */\nexport function numberToBytes(value, opts) {\n    const hex = numberToHex(value, opts);\n    return hexToBytes(hex);\n}\n/**\n * Encodes a UTF-8 string into a byte array.\n *\n * - Docs: https://viem.sh/docs/utilities/toBytes#stringtobytes\n *\n * @param value String to encode.\n * @param opts Options.\n * @returns Byte array value.\n *\n * @example\n * import { stringToBytes } from 'viem'\n * const data = stringToBytes('Hello world!')\n * // Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])\n *\n * @example\n * import { stringToBytes } from 'viem'\n * const data = stringToBytes('Hello world!', { size: 32 })\n * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n */\nexport function stringToBytes(value, opts = {}) {\n    const bytes = encoder.encode(value);\n    if (typeof opts.size === 'number') {\n        assertSize(bytes, { size: opts.size });\n        return pad(bytes, { dir: 'right', size: opts.size });\n    }\n    return bytes;\n}\n//# sourceMappingURL=toBytes.js.map"],"names":["encoder","TextEncoder","toBytes","value","opts","numberToBytes","boolToBytes","isHex","hexToBytes","stringToBytes","bytes","Uint8Array","Number","size","assertSize","pad","charCodeMap","zero","nine","A","F","a","f","charCodeToBase16","char","hex_","hex","dir","hexString","slice","length","index","j","nibbleLeft","charCodeAt","nibbleRight","undefined","BaseError","numberToHex","encode"],"mappings":"kNAKA,MAAMA,EAAwB,IAAIC,YA0B3B,SAASC,EAAQC,EAAOC,EAAO,IAClC,MAAqB,iBAAVD,GAAuC,iBAAVA,EAC7BE,EAAcF,EAAOC,GACX,kBAAVD,EACAG,EAAYH,EAAOC,GAC1BG,EAAMJ,GACCK,EAAWL,EAAOC,GACtBK,EAAcN,EAAOC,EAChC,CAoBO,SAASE,EAAYH,EAAOC,EAAO,IACtC,MAAMM,EAAQ,IAAIC,WAAW,GAE7B,OADAD,EAAM,GAAKE,OAAOT,GACO,iBAAdC,EAAKS,MACZC,EAAWJ,EAAO,CAAEG,KAAMT,EAAKS,OACxBE,EAAIL,EAAO,CAAEG,KAAMT,EAAKS,QAE5BH,CACX,CAEA,MAAMM,EAAc,CAChBC,KAAM,GACNC,KAAM,GACNC,EAAG,GACHC,EAAG,GACHC,EAAG,GACHC,EAAG,KAEP,SAASC,EAAiBC,GACtB,OAAIA,GAAQR,EAAYC,MAAQO,GAAQR,EAAYE,KACzCM,EAAOR,EAAYC,KAC1BO,GAAQR,EAAYG,GAAKK,GAAQR,EAAYI,EACtCI,GAAQR,EAAYG,EAAI,IAC/BK,GAAQR,EAAYK,GAAKG,GAAQR,EAAYM,EACtCE,GAAQR,EAAYK,EAAI,SADnC,CAGJ,CAoBO,SAASb,EAAWiB,EAAMrB,EAAO,IACpC,IAAIsB,EAAMD,EACNrB,EAAKS,OACLC,EAAWY,EAAK,CAAEb,KAAMT,EAAKS,OAC7Ba,EAAMX,EAAIW,EAAK,CAAEC,IAAK,QAASd,KAAMT,EAAKS,QAE9C,IAAIe,EAAYF,EAAIG,MAAM,GACtBD,EAAUE,OAAS,IACnBF,EAAY,IAAIA,KACpB,MAAME,EAASF,EAAUE,OAAS,EAC5BpB,EAAQ,IAAIC,WAAWmB,GAC7B,IAAK,IAAIC,EAAQ,EAAGC,EAAI,EAAGD,EAAQD,EAAQC,IAAS,CAChD,MAAME,EAAaV,EAAiBK,EAAUM,WAAWF,MACnDG,EAAcZ,EAAiBK,EAAUM,WAAWF,MAC1D,QAAmBI,IAAfH,QAA4CG,IAAhBD,EAC5B,MAAM,IAAIE,EAAU,2BAA2BT,EAAUI,EAAI,KAAKJ,EAAUI,EAAI,WAAWJ,QAE/FlB,EAAMqB,GAAsB,GAAbE,EAAkBE,CACrC,CACA,OAAOzB,CACX,CAoBO,SAASL,EAAcF,EAAOC,GAEjC,OAAOI,EADK8B,EAAYnC,EAAOC,GAEnC,CAoBO,SAASK,EAAcN,EAAOC,EAAO,IACxC,MAAMM,EAAQV,EAAQuC,OAAOpC,GAC7B,MAAyB,iBAAdC,EAAKS,MACZC,EAAWJ,EAAO,CAAEG,KAAMT,EAAKS,OACxBE,EAAIL,EAAO,CAAEiB,IAAK,QAASd,KAAMT,EAAKS,QAE1CH,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/encoding/toHex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toHex.js","sources":["../../../../../../../node_modules/viem/_esm/utils/encoding/toHex.js"],"sourcesContent":["import { IntegerOutOfRangeError, } from '../../errors/encoding.js';\nimport { pad } from '../data/pad.js';\nimport { assertSize } from './fromHex.js';\nconst hexes = /*#__PURE__*/ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, '0'));\n/**\n * Encodes a string, number, bigint, or ByteArray into a hex string\n *\n * - Docs: https://viem.sh/docs/utilities/toHex\n * - Example: https://viem.sh/docs/utilities/toHex#usage\n *\n * @param value Value to encode.\n * @param opts Options.\n * @returns Hex value.\n *\n * @example\n * import { toHex } from 'viem'\n * const data = toHex('Hello world')\n * // '0x48656c6c6f20776f726c6421'\n *\n * @example\n * import { toHex } from 'viem'\n * const data = toHex(420)\n * // '0x1a4'\n *\n * @example\n * import { toHex } from 'viem'\n * const data = toHex('Hello world', { size: 32 })\n * // '0x48656c6c6f20776f726c64210000000000000000000000000000000000000000'\n */\nexport function toHex(value, opts = {}) {\n    if (typeof value === 'number' || typeof value === 'bigint')\n        return numberToHex(value, opts);\n    if (typeof value === 'string') {\n        return stringToHex(value, opts);\n    }\n    if (typeof value === 'boolean')\n        return boolToHex(value, opts);\n    return bytesToHex(value, opts);\n}\n/**\n * Encodes a boolean into a hex string\n *\n * - Docs: https://viem.sh/docs/utilities/toHex#booltohex\n *\n * @param value Value to encode.\n * @param opts Options.\n * @returns Hex value.\n *\n * @example\n * import { boolToHex } from 'viem'\n * const data = boolToHex(true)\n * // '0x1'\n *\n * @example\n * import { boolToHex } from 'viem'\n * const data = boolToHex(false)\n * // '0x0'\n *\n * @example\n * import { boolToHex } from 'viem'\n * const data = boolToHex(true, { size: 32 })\n * // '0x0000000000000000000000000000000000000000000000000000000000000001'\n */\nexport function boolToHex(value, opts = {}) {\n    const hex = `0x${Number(value)}`;\n    if (typeof opts.size === 'number') {\n        assertSize(hex, { size: opts.size });\n        return pad(hex, { size: opts.size });\n    }\n    return hex;\n}\n/**\n * Encodes a bytes array into a hex string\n *\n * - Docs: https://viem.sh/docs/utilities/toHex#bytestohex\n *\n * @param value Value to encode.\n * @param opts Options.\n * @returns Hex value.\n *\n * @example\n * import { bytesToHex } from 'viem'\n * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])\n * // '0x48656c6c6f20576f726c6421'\n *\n * @example\n * import { bytesToHex } from 'viem'\n * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]), { size: 32 })\n * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'\n */\nexport function bytesToHex(value, opts = {}) {\n    let string = '';\n    for (let i = 0; i < value.length; i++) {\n        string += hexes[value[i]];\n    }\n    const hex = `0x${string}`;\n    if (typeof opts.size === 'number') {\n        assertSize(hex, { size: opts.size });\n        return pad(hex, { dir: 'right', size: opts.size });\n    }\n    return hex;\n}\n/**\n * Encodes a number or bigint into a hex string\n *\n * - Docs: https://viem.sh/docs/utilities/toHex#numbertohex\n *\n * @param value Value to encode.\n * @param opts Options.\n * @returns Hex value.\n *\n * @example\n * import { numberToHex } from 'viem'\n * const data = numberToHex(420)\n * // '0x1a4'\n *\n * @example\n * import { numberToHex } from 'viem'\n * const data = numberToHex(420, { size: 32 })\n * // '0x00000000000000000000000000000000000000000000000000000000000001a4'\n */\nexport function numberToHex(value_, opts = {}) {\n    const { signed, size } = opts;\n    const value = BigInt(value_);\n    let maxValue;\n    if (size) {\n        if (signed)\n            maxValue = (1n << (BigInt(size) * 8n - 1n)) - 1n;\n        else\n            maxValue = 2n ** (BigInt(size) * 8n) - 1n;\n    }\n    else if (typeof value_ === 'number') {\n        maxValue = BigInt(Number.MAX_SAFE_INTEGER);\n    }\n    const minValue = typeof maxValue === 'bigint' && signed ? -maxValue - 1n : 0;\n    if ((maxValue && value > maxValue) || value < minValue) {\n        const suffix = typeof value_ === 'bigint' ? 'n' : '';\n        throw new IntegerOutOfRangeError({\n            max: maxValue ? `${maxValue}${suffix}` : undefined,\n            min: `${minValue}${suffix}`,\n            signed,\n            size,\n            value: `${value_}${suffix}`,\n        });\n    }\n    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size * 8)) + BigInt(value) : value).toString(16)}`;\n    if (size)\n        return pad(hex, { size });\n    return hex;\n}\nconst encoder = /*#__PURE__*/ new TextEncoder();\n/**\n * Encodes a UTF-8 string into a hex string\n *\n * - Docs: https://viem.sh/docs/utilities/toHex#stringtohex\n *\n * @param value Value to encode.\n * @param opts Options.\n * @returns Hex value.\n *\n * @example\n * import { stringToHex } from 'viem'\n * const data = stringToHex('Hello World!')\n * // '0x48656c6c6f20576f726c6421'\n *\n * @example\n * import { stringToHex } from 'viem'\n * const data = stringToHex('Hello World!', { size: 32 })\n * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'\n */\nexport function stringToHex(value_, opts = {}) {\n    const value = encoder.encode(value_);\n    return bytesToHex(value, opts);\n}\n//# sourceMappingURL=toHex.js.map"],"names":["hexes","Array","from","length","_v","i","toString","padStart","toHex","value","opts","numberToHex","stringToHex","boolToHex","bytesToHex","hex","Number","size","assertSize","pad","string","dir","value_","signed","BigInt","maxValue","MAX_SAFE_INTEGER","minValue","suffix","IntegerOutOfRangeError","max","undefined","min","encoder","TextEncoder","encode"],"mappings":"iJAGA,MAAMA,EAAsBC,MAAMC,KAAK,CAAEC,OAAQ,KAAO,CAACC,EAAIC,IAAMA,EAAEC,SAAS,IAAIC,SAAS,EAAG,MA0BvF,SAASC,EAAMC,EAAOC,EAAO,IAChC,MAAqB,iBAAVD,GAAuC,iBAAVA,EAC7BE,EAAYF,EAAOC,GACT,iBAAVD,EACAG,EAAYH,EAAOC,GAET,kBAAVD,EACAI,EAAUJ,EAAOC,GACrBI,EAAWL,EAAOC,EAC7B,CAyBO,SAASG,EAAUJ,EAAOC,EAAO,IACpC,MAAMK,EAAM,KAAKC,OAAOP,KACxB,MAAyB,iBAAdC,EAAKO,MACZC,EAAWH,EAAK,CAAEE,KAAMP,EAAKO,OACtBE,EAAIJ,EAAK,CAAEE,KAAMP,EAAKO,QAE1BF,CACX,CAoBO,SAASD,EAAWL,EAAOC,EAAO,IACrC,IAAIU,EAAS,GACb,IAAK,IAAIf,EAAI,EAAGA,EAAII,EAAMN,OAAQE,IAC9Be,GAAUpB,EAAMS,EAAMJ,IAE1B,MAAMU,EAAM,KAAKK,IACjB,MAAyB,iBAAdV,EAAKO,MACZC,EAAWH,EAAK,CAAEE,KAAMP,EAAKO,OACtBE,EAAIJ,EAAK,CAAEM,IAAK,QAASJ,KAAMP,EAAKO,QAExCF,CACX,CAoBO,SAASJ,EAAYW,EAAQZ,EAAO,IACvC,MAAMa,OAAEA,EAAMN,KAAEA,GAASP,EACnBD,EAAQe,OAAOF,GACrB,IAAIG,EACAR,EAEIQ,EADAF,GACY,IAAsB,GAAfC,OAAOP,GAAa,IAAO,GAEnC,KAAsB,GAAfO,OAAOP,IAAc,GAEpB,iBAAXK,IACZG,EAAWD,OAAOR,OAAOU,mBAE7B,MAAMC,EAA+B,iBAAbF,GAAyBF,GAAUE,EAAW,GAAK,EAC3E,GAAKA,GAAYhB,EAAQgB,GAAahB,EAAQkB,EAAU,CACpD,MAAMC,EAA2B,iBAAXN,EAAsB,IAAM,GAClD,MAAM,IAAIO,EAAuB,CAC7BC,IAAKL,EAAW,GAAGA,IAAWG,SAAWG,EACzCC,IAAK,GAAGL,IAAWC,IACnBL,SACAN,OACAR,MAAO,GAAGa,IAASM,KAE3B,CACA,MAAMb,EAAM,MAAMQ,GAAUd,EAAQ,GAAK,IAAMe,OAAc,EAAPP,IAAaO,OAAOf,GAASA,GAAOH,SAAS,MACnG,OAAIW,EACOE,EAAIJ,EAAK,CAAEE,SACfF,CACX,CACA,MAAMkB,EAAwB,IAAIC,YAoB3B,SAAStB,EAAYU,EAAQZ,EAAO,IAEvC,OAAOI,EADOmB,EAAQE,OAAOb,GACJZ,EAC7B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/encoding/toRlp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toRlp.js","sources":["../../../../../../../node_modules/viem/_esm/utils/encoding/toRlp.js"],"sourcesContent":["import { BaseError } from '../../errors/base.js';\nimport { createCursor, } from '../cursor.js';\nimport { hexToBytes } from './toBytes.js';\nimport { bytesToHex } from './toHex.js';\nexport function toRlp(bytes, to = 'hex') {\n    const encodable = getEncodable(bytes);\n    const cursor = createCursor(new Uint8Array(encodable.length));\n    encodable.encode(cursor);\n    if (to === 'hex')\n        return bytesToHex(cursor.bytes);\n    return cursor.bytes;\n}\nexport function bytesToRlp(bytes, to = 'bytes') {\n    return toRlp(bytes, to);\n}\nexport function hexToRlp(hex, to = 'hex') {\n    return toRlp(hex, to);\n}\nfunction getEncodable(bytes) {\n    if (Array.isArray(bytes))\n        return getEncodableList(bytes.map((x) => getEncodable(x)));\n    return getEncodableBytes(bytes);\n}\nfunction getEncodableList(list) {\n    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);\n    const sizeOfBodyLength = getSizeOfLength(bodyLength);\n    const length = (() => {\n        if (bodyLength <= 55)\n            return 1 + bodyLength;\n        return 1 + sizeOfBodyLength + bodyLength;\n    })();\n    return {\n        length,\n        encode(cursor) {\n            if (bodyLength <= 55) {\n                cursor.pushByte(0xc0 + bodyLength);\n            }\n            else {\n                cursor.pushByte(0xc0 + 55 + sizeOfBodyLength);\n                if (sizeOfBodyLength === 1)\n                    cursor.pushUint8(bodyLength);\n                else if (sizeOfBodyLength === 2)\n                    cursor.pushUint16(bodyLength);\n                else if (sizeOfBodyLength === 3)\n                    cursor.pushUint24(bodyLength);\n                else\n                    cursor.pushUint32(bodyLength);\n            }\n            for (const { encode } of list) {\n                encode(cursor);\n            }\n        },\n    };\n}\nfunction getEncodableBytes(bytesOrHex) {\n    const bytes = typeof bytesOrHex === 'string' ? hexToBytes(bytesOrHex) : bytesOrHex;\n    const sizeOfBytesLength = getSizeOfLength(bytes.length);\n    const length = (() => {\n        if (bytes.length === 1 && bytes[0] < 0x80)\n            return 1;\n        if (bytes.length <= 55)\n            return 1 + bytes.length;\n        return 1 + sizeOfBytesLength + bytes.length;\n    })();\n    return {\n        length,\n        encode(cursor) {\n            if (bytes.length === 1 && bytes[0] < 0x80) {\n                cursor.pushBytes(bytes);\n            }\n            else if (bytes.length <= 55) {\n                cursor.pushByte(0x80 + bytes.length);\n                cursor.pushBytes(bytes);\n            }\n            else {\n                cursor.pushByte(0x80 + 55 + sizeOfBytesLength);\n                if (sizeOfBytesLength === 1)\n                    cursor.pushUint8(bytes.length);\n                else if (sizeOfBytesLength === 2)\n                    cursor.pushUint16(bytes.length);\n                else if (sizeOfBytesLength === 3)\n                    cursor.pushUint24(bytes.length);\n                else\n                    cursor.pushUint32(bytes.length);\n                cursor.pushBytes(bytes);\n            }\n        },\n    };\n}\nfunction getSizeOfLength(length) {\n    if (length < 2 ** 8)\n        return 1;\n    if (length < 2 ** 16)\n        return 2;\n    if (length < 2 ** 24)\n        return 3;\n    if (length < 2 ** 32)\n        return 4;\n    throw new BaseError('Length is too large.');\n}\n//# sourceMappingURL=toRlp.js.map"],"names":["toRlp","bytes","to","encodable","getEncodable","cursor","createCursor","Uint8Array","length","encode","bytesToHex","Array","isArray","list","bodyLength","reduce","acc","x","sizeOfBodyLength","getSizeOfLength","pushByte","pushUint8","pushUint16","pushUint24","pushUint32","getEncodableList","map","bytesOrHex","hexToBytes","sizeOfBytesLength","pushBytes","getEncodableBytes","BaseError"],"mappings":"+KAIO,SAASA,EAAMC,EAAOC,EAAK,OAC9B,MAAMC,EAAYC,EAAaH,GACzBI,EAASC,EAAa,IAAIC,WAAWJ,EAAUK,SAErD,OADAL,EAAUM,OAAOJ,GACN,QAAPH,EACOQ,EAAWL,EAAOJ,OACtBI,EAAOJ,KAClB,CAOA,SAASG,EAAaH,GAClB,OAAIU,MAAMC,QAAQX,GAItB,SAA0BY,GACtB,MAAMC,EAAaD,EAAKE,OAAO,CAACC,EAAKC,IAAMD,EAAMC,EAAET,OAAQ,GACrDU,EAAmBC,EAAgBL,GAMzC,MAAO,CACHN,OALIM,GAAc,GACP,EAAIA,EACR,EAAII,EAAmBJ,EAI9B,MAAAL,CAAOJ,GACCS,GAAc,GACdT,EAAOe,SAAS,IAAON,IAGvBT,EAAOe,SAAS,IAAYF,GACH,IAArBA,EACAb,EAAOgB,UAAUP,GACS,IAArBI,EACLb,EAAOiB,WAAWR,GACQ,IAArBI,EACLb,EAAOkB,WAAWT,GAElBT,EAAOmB,WAAWV,IAE1B,IAAK,MAAML,OAAEA,KAAYI,EACrBJ,EAAOJ,EAEf,EAER,CAjCeoB,CAAiBxB,EAAMyB,IAAKT,GAAMb,EAAaa,KAkC9D,SAA2BU,GACvB,MAAM1B,EAA8B,iBAAf0B,EAA0BC,EAAWD,GAAcA,EAClEE,EAAoBV,EAAgBlB,EAAMO,QAC1CA,EACmB,IAAjBP,EAAMO,QAAgBP,EAAM,GAAK,IAC1B,EACPA,EAAMO,QAAU,GACT,EAAIP,EAAMO,OACd,EAAIqB,EAAoB5B,EAAMO,OAEzC,MAAO,CACHA,SACA,MAAAC,CAAOJ,GACkB,IAAjBJ,EAAMO,QAAgBP,EAAM,GAAK,IACjCI,EAAOyB,UAAU7B,GAEZA,EAAMO,QAAU,IACrBH,EAAOe,SAAS,IAAOnB,EAAMO,QAC7BH,EAAOyB,UAAU7B,KAGjBI,EAAOe,SAAS,IAAYS,GACF,IAAtBA,EACAxB,EAAOgB,UAAUpB,EAAMO,QACI,IAAtBqB,EACLxB,EAAOiB,WAAWrB,EAAMO,QACG,IAAtBqB,EACLxB,EAAOkB,WAAWtB,EAAMO,QAExBH,EAAOmB,WAAWvB,EAAMO,QAC5BH,EAAOyB,UAAU7B,GAEzB,EAER,CAnEW8B,CAAkB9B,EAC7B,CAmEA,SAASkB,EAAgBX,GACrB,GAAIA,EAAS,IACT,OAAO,EACX,GAAIA,EAAS,MACT,OAAO,EACX,GAAIA,EAAS,GAAK,GACd,OAAO,EACX,GAAIA,EAAS,GAAK,GACd,OAAO,EACX,MAAM,IAAIwB,EAAU,uBACxB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseAvatarRecord.js","sources":["../../../../../../../../node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js"],"sourcesContent":["import { getJsonImage, getMetadataAvatarUri, getNftTokenUri, parseAvatarUri, parseNftUri, resolveAvatarUri, } from './utils.js';\n/*\n * @description Parses an ENS avatar record.\n *\n * @example\n * parseAvatarRecord('eip155:1/erc1155:0xb32979486938aa9694bfc898f35dbed459f44424/10063')\n * 'https://ipfs.io/ipfs/QmSP4nq9fnN9dAiCj42ug9Wa79rqmQerZXZch82VqpiH7U/image.gif'\n *\n * @see https://docs.ens.domains/web/avatars\n *\n */\nexport async function parseAvatarRecord(client, { gatewayUrls, record, }) {\n    if (/eip155:/i.test(record))\n        return parseNftAvatarUri(client, { gatewayUrls, record });\n    return parseAvatarUri({ uri: record, gatewayUrls });\n}\nasync function parseNftAvatarUri(client, { gatewayUrls, record, }) {\n    // parse NFT URI into properties\n    const nft = parseNftUri(record);\n    // fetch tokenURI from the NFT contract\n    const nftUri = await getNftTokenUri(client, { nft });\n    // resolve the URI from the fetched tokenURI\n    const { uri: resolvedNftUri, isOnChain, isEncoded, } = resolveAvatarUri({ uri: nftUri, gatewayUrls });\n    // if the resolved URI is on chain, return the data\n    if (isOnChain &&\n        (resolvedNftUri.includes('data:application/json;base64,') ||\n            resolvedNftUri.startsWith('{'))) {\n        const encodedJson = isEncoded\n            ? // if it is encoded, decode it\n                atob(resolvedNftUri.replace('data:application/json;base64,', ''))\n            : // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)\n                resolvedNftUri;\n        const decoded = JSON.parse(encodedJson);\n        return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });\n    }\n    let uriTokenId = nft.tokenID;\n    if (nft.namespace === 'erc1155')\n        uriTokenId = uriTokenId.replace('0x', '').padStart(64, '0');\n    return getMetadataAvatarUri({\n        gatewayUrls,\n        uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId),\n    });\n}\n//# sourceMappingURL=parseAvatarRecord.js.map"],"names":["async","parseAvatarRecord","client","gatewayUrls","record","test","nft","parseNftUri","nftUri","getNftTokenUri","uri","resolvedNftUri","isOnChain","isEncoded","resolveAvatarUri","includes","startsWith","encodedJson","atob","replace","decoded","JSON","parse","parseAvatarUri","getJsonImage","uriTokenId","tokenID","namespace","padStart","getMetadataAvatarUri","parseNftAvatarUri"],"mappings":"mJAWOA,eAAeC,EAAkBC,GAAQC,YAAEA,EAAWC,OAAEA,IAC3D,MAAI,WAAWC,KAAKD,GAIxBJ,eAAiCE,GAAQC,YAAEA,EAAWC,OAAEA,IAEpD,MAAME,EAAMC,EAAYH,GAElBI,QAAeC,EAAeP,EAAQ,CAAEI,SAEtCI,IAAKC,EAAcC,UAAEA,EAASC,UAAEA,GAAeC,EAAiB,CAAEJ,IAAKF,EAAQL,gBAEvF,GAAIS,IACCD,EAAeI,SAAS,kCACrBJ,EAAeK,WAAW,MAAO,CACrC,MAAMC,EAAcJ,EAEZK,KAAKP,EAAeQ,QAAQ,gCAAiC,KAE7DR,EACFS,EAAUC,KAAKC,MAAML,GAC3B,OAAOM,EAAe,CAAEb,IAAKc,EAAaJ,GAAUjB,eACxD,CACA,IAAIsB,EAAanB,EAAIoB,QACC,YAAlBpB,EAAIqB,YACJF,EAAaA,EAAWN,QAAQ,KAAM,IAAIS,SAAS,GAAI,MAC3D,OAAOC,EAAqB,CACxB1B,cACAO,IAAKC,EAAeQ,QAAQ,cAAeM,IAEnD,CA7BeK,CAAkB5B,EAAQ,CAAEC,cAAaC,WAC7CmB,EAAe,CAAEb,IAAKN,EAAQD,eACzC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/ens/avatar/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sources":["../../../../../../../../node_modules/viem/_esm/utils/ens/avatar/utils.js"],"sourcesContent":["import { readContract, } from '../../../actions/public/readContract.js';\nimport { EnsAvatarInvalidMetadataError, EnsAvatarInvalidNftUriError, EnsAvatarUnsupportedNamespaceError, EnsAvatarUriResolutionError, } from '../../../errors/ens.js';\nconst networkRegex = /(?<protocol>https?:\\/\\/[^/]*|ipfs:\\/|ipns:\\/|ar:\\/)?(?<root>\\/)?(?<subpath>ipfs\\/|ipns\\/)?(?<target>[\\w\\-.]+)(?<subtarget>\\/.*)?/;\nconst ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\\/(?<target>[\\w\\-.]+))?(?<subtarget>\\/.*)?$/;\nconst base64Regex = /^data:([a-zA-Z\\-/+]*);base64,([^\"].*)/;\nconst dataURIRegex = /^data:([a-zA-Z\\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;\n/** @internal */\nexport async function isImageUri(uri) {\n    try {\n        const res = await fetch(uri, { method: 'HEAD' });\n        // retrieve content type header to check if content is image\n        if (res.status === 200) {\n            const contentType = res.headers.get('content-type');\n            return contentType?.startsWith('image/');\n        }\n        return false;\n    }\n    catch (error) {\n        // if error is not cors related then fail\n        if (typeof error === 'object' && typeof error.response !== 'undefined') {\n            return false;\n        }\n        // fail in NodeJS, since the error is not cors but any other network issue\n        if (!Object.hasOwn(globalThis, 'Image'))\n            return false;\n        // in case of cors, use image api to validate if given url is an actual image\n        return new Promise((resolve) => {\n            const img = new Image();\n            img.onload = () => {\n                resolve(true);\n            };\n            img.onerror = () => {\n                resolve(false);\n            };\n            img.src = uri;\n        });\n    }\n}\n/** @internal */\nexport function getGateway(custom, defaultGateway) {\n    if (!custom)\n        return defaultGateway;\n    if (custom.endsWith('/'))\n        return custom.slice(0, -1);\n    return custom;\n}\nexport function resolveAvatarUri({ uri, gatewayUrls, }) {\n    const isEncoded = base64Regex.test(uri);\n    if (isEncoded)\n        return { uri, isOnChain: true, isEncoded };\n    const ipfsGateway = getGateway(gatewayUrls?.ipfs, 'https://ipfs.io');\n    const arweaveGateway = getGateway(gatewayUrls?.arweave, 'https://arweave.net');\n    const networkRegexMatch = uri.match(networkRegex);\n    const { protocol, subpath, target, subtarget = '', } = networkRegexMatch?.groups || {};\n    const isIPNS = protocol === 'ipns:/' || subpath === 'ipns/';\n    const isIPFS = protocol === 'ipfs:/' || subpath === 'ipfs/' || ipfsHashRegex.test(uri);\n    if (uri.startsWith('http') && !isIPNS && !isIPFS) {\n        let replacedUri = uri;\n        if (gatewayUrls?.arweave)\n            replacedUri = uri.replace(/https:\\/\\/arweave.net/g, gatewayUrls?.arweave);\n        return { uri: replacedUri, isOnChain: false, isEncoded: false };\n    }\n    if ((isIPNS || isIPFS) && target) {\n        return {\n            uri: `${ipfsGateway}/${isIPNS ? 'ipns' : 'ipfs'}/${target}${subtarget}`,\n            isOnChain: false,\n            isEncoded: false,\n        };\n    }\n    if (protocol === 'ar:/' && target) {\n        return {\n            uri: `${arweaveGateway}/${target}${subtarget || ''}`,\n            isOnChain: false,\n            isEncoded: false,\n        };\n    }\n    let parsedUri = uri.replace(dataURIRegex, '');\n    if (parsedUri.startsWith('<svg')) {\n        // if svg, base64 encode\n        parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;\n    }\n    if (parsedUri.startsWith('data:') || parsedUri.startsWith('{')) {\n        return {\n            uri: parsedUri,\n            isOnChain: true,\n            isEncoded: false,\n        };\n    }\n    throw new EnsAvatarUriResolutionError({ uri });\n}\nexport function getJsonImage(data) {\n    // validation check for json data, must include one of theses properties\n    if (typeof data !== 'object' ||\n        (!('image' in data) && !('image_url' in data) && !('image_data' in data))) {\n        throw new EnsAvatarInvalidMetadataError({ data });\n    }\n    return data.image || data.image_url || data.image_data;\n}\nexport async function getMetadataAvatarUri({ gatewayUrls, uri, }) {\n    try {\n        const res = await fetch(uri).then((res) => res.json());\n        const image = await parseAvatarUri({\n            gatewayUrls,\n            uri: getJsonImage(res),\n        });\n        return image;\n    }\n    catch {\n        throw new EnsAvatarUriResolutionError({ uri });\n    }\n}\nexport async function parseAvatarUri({ gatewayUrls, uri, }) {\n    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });\n    if (isOnChain)\n        return resolvedURI;\n    // check if resolvedURI is an image, if it is return the url\n    const isImage = await isImageUri(resolvedURI);\n    if (isImage)\n        return resolvedURI;\n    throw new EnsAvatarUriResolutionError({ uri });\n}\nexport function parseNftUri(uri_) {\n    let uri = uri_;\n    // parse valid nft spec (CAIP-22/CAIP-29)\n    // @see: https://github.com/ChainAgnostic/CAIPs/tree/master/CAIPs\n    if (uri.startsWith('did:nft:')) {\n        // convert DID to CAIP\n        uri = uri.replace('did:nft:', '').replace(/_/g, '/');\n    }\n    const [reference, asset_namespace, tokenID] = uri.split('/');\n    const [eip_namespace, chainID] = reference.split(':');\n    const [erc_namespace, contractAddress] = asset_namespace.split(':');\n    if (!eip_namespace || eip_namespace.toLowerCase() !== 'eip155')\n        throw new EnsAvatarInvalidNftUriError({ reason: 'Only EIP-155 supported' });\n    if (!chainID)\n        throw new EnsAvatarInvalidNftUriError({ reason: 'Chain ID not found' });\n    if (!contractAddress)\n        throw new EnsAvatarInvalidNftUriError({\n            reason: 'Contract address not found',\n        });\n    if (!tokenID)\n        throw new EnsAvatarInvalidNftUriError({ reason: 'Token ID not found' });\n    if (!erc_namespace)\n        throw new EnsAvatarInvalidNftUriError({ reason: 'ERC namespace not found' });\n    return {\n        chainID: Number.parseInt(chainID, 10),\n        namespace: erc_namespace.toLowerCase(),\n        contractAddress: contractAddress,\n        tokenID,\n    };\n}\nexport async function getNftTokenUri(client, { nft }) {\n    if (nft.namespace === 'erc721') {\n        return readContract(client, {\n            address: nft.contractAddress,\n            abi: [\n                {\n                    name: 'tokenURI',\n                    type: 'function',\n                    stateMutability: 'view',\n                    inputs: [{ name: 'tokenId', type: 'uint256' }],\n                    outputs: [{ name: '', type: 'string' }],\n                },\n            ],\n            functionName: 'tokenURI',\n            args: [BigInt(nft.tokenID)],\n        });\n    }\n    if (nft.namespace === 'erc1155') {\n        return readContract(client, {\n            address: nft.contractAddress,\n            abi: [\n                {\n                    name: 'uri',\n                    type: 'function',\n                    stateMutability: 'view',\n                    inputs: [{ name: '_id', type: 'uint256' }],\n                    outputs: [{ name: '', type: 'string' }],\n                },\n            ],\n            functionName: 'uri',\n            args: [BigInt(nft.tokenID)],\n        });\n    }\n    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });\n}\n//# sourceMappingURL=utils.js.map"],"names":["networkRegex","ipfsHashRegex","base64Regex","dataURIRegex","async","isImageUri","uri","res","fetch","method","status","contentType","headers","get","startsWith","error","response","Object","hasOwn","globalThis","Promise","resolve","img","Image","onload","onerror","src","getGateway","custom","defaultGateway","endsWith","slice","resolveAvatarUri","gatewayUrls","isEncoded","test","isOnChain","ipfsGateway","ipfs","arweaveGateway","arweave","networkRegexMatch","match","protocol","subpath","target","subtarget","groups","isIPNS","isIPFS","replacedUri","replace","parsedUri","btoa","EnsAvatarUriResolutionError","getJsonImage","data","EnsAvatarInvalidMetadataError","image","image_url","image_data","getMetadataAvatarUri","then","json","parseAvatarUri","resolvedURI","parseNftUri","uri_","reference","asset_namespace","tokenID","split","eip_namespace","chainID","erc_namespace","contractAddress","toLowerCase","EnsAvatarInvalidNftUriError","reason","Number","parseInt","namespace","getNftTokenUri","client","nft","readContract","address","abi","name","type","stateMutability","inputs","outputs","functionName","args","BigInt","EnsAvatarUnsupportedNamespaceError"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/ens/encodeLabelhash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"encodeLabelhash.js","sources":["../../../../../../../node_modules/viem/_esm/utils/ens/encodeLabelhash.js"],"sourcesContent":["export function encodeLabelhash(hash) {\n    return `[${hash.slice(2)}]`;\n}\n//# sourceMappingURL=encodeLabelhash.js.map"],"names":["encodeLabelhash","hash","slice"],"mappings":"AAAO,SAASA,EAAgBC,GAC5B,MAAO,IAAIA,EAAKC,MAAM,KAC1B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"encodedLabelToLabelhash.js","sources":["../../../../../../../node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js"],"sourcesContent":["import { isHex } from '../data/isHex.js';\nexport function encodedLabelToLabelhash(label) {\n    if (label.length !== 66)\n        return null;\n    if (label.indexOf('[') !== 0)\n        return null;\n    if (label.indexOf(']') !== 65)\n        return null;\n    const hash = `0x${label.slice(1, 65)}`;\n    if (!isHex(hash))\n        return null;\n    return hash;\n}\n//# sourceMappingURL=encodedLabelToLabelhash.js.map"],"names":["encodedLabelToLabelhash","label","length","indexOf","hash","slice","isHex"],"mappings":"yCACO,SAASA,EAAwBC,GACpC,GAAqB,KAAjBA,EAAMC,OACN,OAAO,KACX,GAA2B,IAAvBD,EAAME,QAAQ,KACd,OAAO,KACX,GAA2B,KAAvBF,EAAME,QAAQ,KACd,OAAO,KACX,MAAMC,EAAO,KAAKH,EAAMI,MAAM,EAAG,MACjC,OAAKC,EAAMF,GAEJA,EADI,IAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/ens/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sources":["../../../../../../../node_modules/viem/_esm/utils/ens/errors.js"],"sourcesContent":["import { BaseError } from '../../errors/base.js';\nimport { ContractFunctionRevertedError } from '../../errors/contract.js';\n/*\n * @description Checks if error is a valid null result UniversalResolver error\n */\nexport function isNullUniversalResolverError(err) {\n    if (!(err instanceof BaseError))\n        return false;\n    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);\n    if (!(cause instanceof ContractFunctionRevertedError))\n        return false;\n    if (cause.data?.errorName === 'HttpError')\n        return true;\n    if (cause.data?.errorName === 'ResolverError')\n        return true;\n    if (cause.data?.errorName === 'ResolverNotContract')\n        return true;\n    if (cause.data?.errorName === 'ResolverNotFound')\n        return true;\n    if (cause.data?.errorName === 'ReverseAddressMismatch')\n        return true;\n    if (cause.data?.errorName === 'UnsupportedResolverProfile')\n        return true;\n    return false;\n}\n//# sourceMappingURL=errors.js.map"],"names":["isNullUniversalResolverError","err","BaseError","cause","walk","e","ContractFunctionRevertedError","data","errorName"],"mappings":"0HAKO,SAASA,EAA6BC,GACzC,KAAMA,aAAeC,GACjB,OAAO,EACX,MAAMC,EAAQF,EAAIG,KAAMC,GAAMA,aAAaC,GAC3C,OAAMH,aAAiBG,IAEO,cAA1BH,EAAMI,MAAMC,YAEc,kBAA1BL,EAAMI,MAAMC,YAEc,wBAA1BL,EAAMI,MAAMC,YAEc,qBAA1BL,EAAMI,MAAMC,YAEc,2BAA1BL,EAAMI,MAAMC,WAEc,+BAA1BL,EAAMI,MAAMC,cAGpB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/ens/labelhash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"labelhash.js","sources":["../../../../../../../node_modules/viem/_esm/utils/ens/labelhash.js"],"sourcesContent":["import { stringToBytes, } from '../encoding/toBytes.js';\nimport { bytesToHex } from '../encoding/toHex.js';\nimport { keccak256 } from '../hash/keccak256.js';\nimport { encodedLabelToLabelhash, } from './encodedLabelToLabelhash.js';\n/**\n * @description Hashes ENS label\n *\n * - Since ENS labels prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS labels](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `labelhash`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize) function for this.\n *\n * @example\n * labelhash('eth')\n * '0x4f5b812789fc606be1b3b16908db13fc7a9adf7ca72641f84d75b47069d3d7f0'\n */\nexport function labelhash(label) {\n    const result = new Uint8Array(32).fill(0);\n    if (!label)\n        return bytesToHex(result);\n    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));\n}\n//# sourceMappingURL=labelhash.js.map"],"names":["labelhash","label","result","Uint8Array","fill","encodedLabelToLabelhash","keccak256","stringToBytes","bytesToHex"],"mappings":"iOAaO,SAASA,EAAUC,GACtB,MAAMC,EAAS,IAAIC,WAAW,IAAIC,KAAK,GACvC,OAAKH,EAEEI,EAAwBJ,IAAUK,EAAUC,EAAcN,IADtDO,EAAWN,EAE1B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/ens/localBatchGatewayRequest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"localBatchGatewayRequest.js","sources":["../../../../../../../node_modules/viem/_esm/utils/ens/localBatchGatewayRequest.js"],"sourcesContent":["import { batchGatewayAbi } from '../../constants/abis.js';\nimport { solidityError } from '../../constants/solidity.js';\nimport { decodeFunctionData } from '../abi/decodeFunctionData.js';\nimport { encodeErrorResult } from '../abi/encodeErrorResult.js';\nimport { encodeFunctionResult } from '../abi/encodeFunctionResult.js';\nexport const localBatchGatewayUrl = 'x-batch-gateway:true';\nexport async function localBatchGatewayRequest(parameters) {\n    const { data, ccipRequest } = parameters;\n    const { args: [queries], } = decodeFunctionData({ abi: batchGatewayAbi, data });\n    const failures = [];\n    const responses = [];\n    await Promise.all(queries.map(async (query, i) => {\n        try {\n            responses[i] = query.urls.includes(localBatchGatewayUrl)\n                ? await localBatchGatewayRequest({ data: query.data, ccipRequest })\n                : await ccipRequest(query);\n            failures[i] = false;\n        }\n        catch (err) {\n            failures[i] = true;\n            responses[i] = encodeError(err);\n        }\n    }));\n    return encodeFunctionResult({\n        abi: batchGatewayAbi,\n        functionName: 'query',\n        result: [failures, responses],\n    });\n}\nfunction encodeError(error) {\n    if (error.name === 'HttpRequestError' && error.status)\n        return encodeErrorResult({\n            abi: batchGatewayAbi,\n            errorName: 'HttpError',\n            args: [error.status, error.shortMessage],\n        });\n    return encodeErrorResult({\n        abi: [solidityError],\n        errorName: 'Error',\n        args: ['shortMessage' in error ? error.shortMessage : error.message],\n    });\n}\n//# sourceMappingURL=localBatchGatewayRequest.js.map"],"names":["localBatchGatewayUrl","async","localBatchGatewayRequest","parameters","data","ccipRequest","args","queries","decodeFunctionData","abi","batchGatewayAbi","failures","responses","Promise","all","map","query","i","urls","includes","err","error","name","status","encodeErrorResult","errorName","shortMessage","solidityError","message","encodeFunctionResult","functionName","result"],"mappings":"8TAKY,MAACA,EAAuB,uBAC7BC,eAAeC,EAAyBC,GAC3C,MAAMC,KAAEA,EAAIC,YAAEA,GAAgBF,GACtBG,MAAOC,IAAcC,EAAmB,CAAEC,IAAKC,EAAiBN,SAClEO,EAAW,GACXC,EAAY,GAalB,aAZMC,QAAQC,IAAIP,EAAQQ,IAAId,MAAOe,EAAOC,KACxC,IACIL,EAAUK,GAAKD,EAAME,KAAKC,SAASnB,SACvBE,EAAyB,CAAEE,KAAMY,EAAMZ,KAAMC,sBAC7CA,EAAYW,GACxBL,EAASM,IAAK,CAClB,CACA,MAAOG,GACHT,EAASM,IAAK,EACdL,EAAUK,GAUC,sBADFI,EATkBD,GAUzBE,MAA+BD,EAAME,OACpCC,EAAkB,CACrBf,IAAKC,EACLe,UAAW,YACXnB,KAAM,CAACe,EAAME,OAAQF,EAAMK,gBAE5BF,EAAkB,CACrBf,IAAK,CAACkB,GACNF,UAAW,QACXnB,KAAM,CAAC,iBAAkBe,EAAQA,EAAMK,aAAeL,EAAMO,UAlB5D,CAQR,IAAqBP,KANVQ,EAAqB,CACxBpB,IAAKC,EACLoB,aAAc,QACdC,OAAQ,CAACpB,EAAUC,IAE3B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/ens/namehash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"namehash.js","sources":["../../../../../../../node_modules/viem/_esm/utils/ens/namehash.js"],"sourcesContent":["import { concat } from '../data/concat.js';\nimport { stringToBytes, toBytes, } from '../encoding/toBytes.js';\nimport { bytesToHex } from '../encoding/toHex.js';\nimport { keccak256 } from '../hash/keccak256.js';\nimport { encodedLabelToLabelhash, } from './encodedLabelToLabelhash.js';\n/**\n * @description Hashes ENS name\n *\n * - Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `namehash`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize) function for this.\n *\n * @example\n * namehash('wevm.eth')\n * '0x08c85f2f4059e930c45a6aeff9dcd3bd95dc3c5c1cddef6a0626b31152248560'\n *\n * @link https://eips.ethereum.org/EIPS/eip-137\n */\nexport function namehash(name) {\n    let result = new Uint8Array(32).fill(0);\n    if (!name)\n        return bytesToHex(result);\n    const labels = name.split('.');\n    // Iterate in reverse order building up hash\n    for (let i = labels.length - 1; i >= 0; i -= 1) {\n        const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);\n        const hashed = hashFromEncodedLabel\n            ? toBytes(hashFromEncodedLabel)\n            : keccak256(stringToBytes(labels[i]), 'bytes');\n        result = keccak256(concat([result, hashed]), 'bytes');\n    }\n    return bytesToHex(result);\n}\n//# sourceMappingURL=namehash.js.map"],"names":["namehash","name","result","Uint8Array","fill","bytesToHex","labels","split","i","length","hashFromEncodedLabel","encodedLabelToLabelhash","hashed","toBytes","keccak256","stringToBytes","concat"],"mappings":"yRAgBO,SAASA,EAASC,GACrB,IAAIC,EAAS,IAAIC,WAAW,IAAIC,KAAK,GACrC,IAAKH,EACD,OAAOI,EAAWH,GACtB,MAAMI,EAASL,EAAKM,MAAM,KAE1B,IAAK,IAAIC,EAAIF,EAAOG,OAAS,EAAGD,GAAK,EAAGA,GAAK,EAAG,CAC5C,MAAME,EAAuBC,EAAwBL,EAAOE,IACtDI,EAASF,EACTG,EAAQH,GACRI,EAAUC,EAAcT,EAAOE,IAAK,SAC1CN,EAASY,EAAUE,EAAO,CAACd,EAAQU,IAAU,QACjD,CACA,OAAOP,EAAWH,EACtB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/ens/packetToBytes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"packetToBytes.js","sources":["../../../../../../../node_modules/viem/_esm/utils/ens/packetToBytes.js"],"sourcesContent":["import { stringToBytes, } from '../encoding/toBytes.js';\nimport { encodeLabelhash, } from './encodeLabelhash.js';\nimport { labelhash } from './labelhash.js';\n/*\n * @description Encodes a DNS packet into a ByteArray containing a UDP payload.\n *\n * @example\n * packetToBytes('awkweb.eth')\n * '0x0661776b7765620365746800'\n *\n * @see https://docs.ens.domains/resolution/names#dns\n *\n */\nexport function packetToBytes(packet) {\n    // strip leading and trailing `.`\n    const value = packet.replace(/^\\.|\\.$/gm, '');\n    if (value.length === 0)\n        return new Uint8Array(1);\n    const bytes = new Uint8Array(stringToBytes(value).byteLength + 2);\n    let offset = 0;\n    const list = value.split('.');\n    for (let i = 0; i < list.length; i++) {\n        let encoded = stringToBytes(list[i]);\n        // if the length is > 255, make the encoded label value a labelhash\n        // this is compatible with the universal resolver\n        if (encoded.byteLength > 255)\n            encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));\n        bytes[offset] = encoded.length;\n        bytes.set(encoded, offset + 1);\n        offset += encoded.length + 1;\n    }\n    if (bytes.byteLength !== offset + 1)\n        return bytes.slice(0, offset + 1);\n    return bytes;\n}\n//# sourceMappingURL=packetToBytes.js.map"],"names":["packetToBytes","packet","value","replace","length","Uint8Array","bytes","stringToBytes","byteLength","offset","list","split","i","encoded","encodeLabelhash","labelhash","set","slice"],"mappings":"yJAaO,SAASA,EAAcC,GAE1B,MAAMC,EAAQD,EAAOE,QAAQ,YAAa,IAC1C,GAAqB,IAAjBD,EAAME,OACN,OAAO,IAAIC,WAAW,GAC1B,MAAMC,EAAQ,IAAID,WAAWE,EAAcL,GAAOM,WAAa,GAC/D,IAAIC,EAAS,EACb,MAAMC,EAAOR,EAAMS,MAAM,KACzB,IAAK,IAAIC,EAAI,EAAGA,EAAIF,EAAKN,OAAQQ,IAAK,CAClC,IAAIC,EAAUN,EAAcG,EAAKE,IAG7BC,EAAQL,WAAa,MACrBK,EAAUN,EAAcO,EAAgBC,EAAUL,EAAKE,OAC3DN,EAAMG,GAAUI,EAAQT,OACxBE,EAAMU,IAAIH,EAASJ,EAAS,GAC5BA,GAAUI,EAAQT,OAAS,CAC/B,CACA,OAAIE,EAAME,aAAeC,EAAS,EACvBH,EAAMW,MAAM,EAAGR,EAAS,GAC5BH,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/errors/getCallError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getCallError.js","sources":["../../../../../../../node_modules/viem/_esm/utils/errors/getCallError.js"],"sourcesContent":["import { CallExecutionError, } from '../../errors/contract.js';\nimport { UnknownNodeError } from '../../errors/node.js';\nimport { getNodeError, } from './getNodeError.js';\nexport function getCallError(err, { docsPath, ...args }) {\n    const cause = (() => {\n        const cause = getNodeError(err, args);\n        if (cause instanceof UnknownNodeError)\n            return err;\n        return cause;\n    })();\n    return new CallExecutionError(cause, {\n        docsPath,\n        ...args,\n    });\n}\n//# sourceMappingURL=getCallError.js.map"],"names":["getCallError","err","docsPath","args","cause","getNodeError","UnknownNodeError","CallExecutionError"],"mappings":"uKAGO,SAASA,EAAaC,GAAKC,SAAEA,KAAaC,IAC7C,MAAMC,EAAQ,MACV,MAAMA,EAAQC,EAAaJ,EAAKE,GAChC,OAAIC,aAAiBE,EACVL,EACJG,CACV,EALa,GAMd,OAAO,IAAIG,EAAmBH,EAAO,CACjCF,cACGC,GAEX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/errors/getContractError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getContractError.js","sources":["../../../../../../../node_modules/viem/_esm/utils/errors/getContractError.js"],"sourcesContent":["import { AbiDecodingZeroDataError } from '../../errors/abi.js';\nimport { BaseError } from '../../errors/base.js';\nimport { ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, RawContractError, } from '../../errors/contract.js';\nimport { RpcRequestError } from '../../errors/request.js';\nimport { InternalRpcError } from '../../errors/rpc.js';\nconst EXECUTION_REVERTED_ERROR_CODE = 3;\nexport function getContractError(err, { abi, address, args, docsPath, functionName, sender, }) {\n    const error = (err instanceof RawContractError\n        ? err\n        : err instanceof BaseError\n            ? err.walk((err) => 'data' in err) || err.walk()\n            : {});\n    const { code, data, details, message, shortMessage } = error;\n    const cause = (() => {\n        if (err instanceof AbiDecodingZeroDataError)\n            return new ContractFunctionZeroDataError({ functionName });\n        if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) &&\n            (data || details || message || shortMessage)) {\n            return new ContractFunctionRevertedError({\n                abi,\n                data: typeof data === 'object' ? data.data : data,\n                functionName,\n                message: error instanceof RpcRequestError\n                    ? details\n                    : (shortMessage ?? message),\n            });\n        }\n        return err;\n    })();\n    return new ContractFunctionExecutionError(cause, {\n        abi,\n        args,\n        contractAddress: address,\n        docsPath,\n        functionName,\n        sender,\n    });\n}\n//# sourceMappingURL=getContractError.js.map"],"names":["EXECUTION_REVERTED_ERROR_CODE","getContractError","err","abi","address","args","docsPath","functionName","sender","error","RawContractError","BaseError","walk","code","data","details","message","shortMessage","cause","AbiDecodingZeroDataError","ContractFunctionZeroDataError","InternalRpcError","includes","ContractFunctionRevertedError","RpcRequestError","ContractFunctionExecutionError","contractAddress"],"mappings":"uYAKA,MAAMA,EAAgC,EAC/B,SAASC,EAAiBC,GAAKC,IAAEA,EAAGC,QAAEA,EAAOC,KAAEA,EAAIC,SAAEA,EAAQC,aAAEA,EAAYC,OAAEA,IAChF,MAAMC,EAASP,aAAeQ,EACxBR,EACAA,aAAeS,EACXT,EAAIU,KAAMV,GAAQ,SAAUA,IAAQA,EAAIU,OACxC,IACJC,KAAEA,EAAIC,KAAEA,EAAIC,QAAEA,EAAOC,QAAEA,EAAOC,aAAEA,GAAiBR,EACjDS,EACEhB,aAAeiB,EACR,IAAIC,EAA8B,CAAEb,iBAC3C,CAACP,EAA+BqB,EAAiBR,MAAMS,SAAST,KAC/DC,GAAQC,GAAWC,GAAWC,GACxB,IAAIM,EAA8B,CACrCpB,MACAW,KAAsB,iBAATA,EAAoBA,EAAKA,KAAOA,EAC7CP,eACAS,QAASP,aAAiBe,EACpBT,EACCE,GAAgBD,IAGxBd,EAEX,OAAO,IAAIuB,EAA+BP,EAAO,CAC7Cf,MACAE,OACAqB,gBAAiBtB,EACjBE,WACAC,eACAC,UAER","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/errors/getEstimateGasError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEstimateGasError.js","sources":["../../../../../../../node_modules/viem/_esm/utils/errors/getEstimateGasError.js"],"sourcesContent":["import { EstimateGasExecutionError, } from '../../errors/estimateGas.js';\nimport { UnknownNodeError } from '../../errors/node.js';\nimport { getNodeError, } from './getNodeError.js';\nexport function getEstimateGasError(err, { docsPath, ...args }) {\n    const cause = (() => {\n        const cause = getNodeError(err, args);\n        if (cause instanceof UnknownNodeError)\n            return err;\n        return cause;\n    })();\n    return new EstimateGasExecutionError(cause, {\n        docsPath,\n        ...args,\n    });\n}\n//# sourceMappingURL=getEstimateGasError.js.map"],"names":["getEstimateGasError","err","docsPath","args","cause","getNodeError","UnknownNodeError","EstimateGasExecutionError"],"mappings":"iLAGO,SAASA,EAAoBC,GAAKC,SAAEA,KAAaC,IACpD,MAAMC,EAAQ,MACV,MAAMA,EAAQC,EAAaJ,EAAKE,GAChC,OAAIC,aAAiBE,EACVL,EACJG,CACV,EALa,GAMd,OAAO,IAAIG,EAA0BH,EAAO,CACxCF,cACGC,GAEX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/errors/getNodeError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getNodeError.js","sources":["../../../../../../../node_modules/viem/_esm/utils/errors/getNodeError.js"],"sourcesContent":["import { BaseError } from '../../errors/base.js';\nimport { ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, NonceMaxValueError, NonceTooHighError, NonceTooLowError, TipAboveFeeCapError, TransactionTypeNotSupportedError, UnknownNodeError, } from '../../errors/node.js';\nimport { RpcRequestError } from '../../errors/request.js';\nimport { InvalidInputRpcError, TransactionRejectedRpcError, } from '../../errors/rpc.js';\nexport function containsNodeError(err) {\n    return (err instanceof TransactionRejectedRpcError ||\n        err instanceof InvalidInputRpcError ||\n        (err instanceof RpcRequestError && err.code === ExecutionRevertedError.code));\n}\nexport function getNodeError(err, args) {\n    const message = (err.details || '').toLowerCase();\n    const executionRevertedError = err instanceof BaseError\n        ? err.walk((e) => e?.code ===\n            ExecutionRevertedError.code)\n        : err;\n    if (executionRevertedError instanceof BaseError)\n        return new ExecutionRevertedError({\n            cause: err,\n            message: executionRevertedError.details,\n        });\n    if (ExecutionRevertedError.nodeMessage.test(message))\n        return new ExecutionRevertedError({\n            cause: err,\n            message: err.details,\n        });\n    if (FeeCapTooHighError.nodeMessage.test(message))\n        return new FeeCapTooHighError({\n            cause: err,\n            maxFeePerGas: args?.maxFeePerGas,\n        });\n    if (FeeCapTooLowError.nodeMessage.test(message))\n        return new FeeCapTooLowError({\n            cause: err,\n            maxFeePerGas: args?.maxFeePerGas,\n        });\n    if (NonceTooHighError.nodeMessage.test(message))\n        return new NonceTooHighError({ cause: err, nonce: args?.nonce });\n    if (NonceTooLowError.nodeMessage.test(message))\n        return new NonceTooLowError({ cause: err, nonce: args?.nonce });\n    if (NonceMaxValueError.nodeMessage.test(message))\n        return new NonceMaxValueError({ cause: err, nonce: args?.nonce });\n    if (InsufficientFundsError.nodeMessage.test(message))\n        return new InsufficientFundsError({ cause: err });\n    if (IntrinsicGasTooHighError.nodeMessage.test(message))\n        return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });\n    if (IntrinsicGasTooLowError.nodeMessage.test(message))\n        return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });\n    if (TransactionTypeNotSupportedError.nodeMessage.test(message))\n        return new TransactionTypeNotSupportedError({ cause: err });\n    if (TipAboveFeeCapError.nodeMessage.test(message))\n        return new TipAboveFeeCapError({\n            cause: err,\n            maxFeePerGas: args?.maxFeePerGas,\n            maxPriorityFeePerGas: args?.maxPriorityFeePerGas,\n        });\n    return new UnknownNodeError({\n        cause: err,\n    });\n}\n//# sourceMappingURL=getNodeError.js.map"],"names":["getNodeError","err","args","message","details","toLowerCase","executionRevertedError","BaseError","walk","e","code","ExecutionRevertedError","cause","nodeMessage","test","FeeCapTooHighError","maxFeePerGas","FeeCapTooLowError","NonceTooHighError","nonce","NonceTooLowError","NonceMaxValueError","InsufficientFundsError","IntrinsicGasTooHighError","gas","IntrinsicGasTooLowError","TransactionTypeNotSupportedError","TipAboveFeeCapError","maxPriorityFeePerGas","UnknownNodeError"],"mappings":"+YASO,SAASA,EAAaC,EAAKC,GAC9B,MAAMC,GAAWF,EAAIG,SAAW,IAAIC,cAC9BC,EAAyBL,aAAeM,EACxCN,EAAIO,KAAMC,GAAMA,GAAGC,OACjBC,EAAuBD,MACzBT,EACN,OAAIK,aAAkCC,EAC3B,IAAII,EAAuB,CAC9BC,MAAOX,EACPE,QAASG,EAAuBF,UAEpCO,EAAuBE,YAAYC,KAAKX,GACjC,IAAIQ,EAAuB,CAC9BC,MAAOX,EACPE,QAASF,EAAIG,UAEjBW,EAAmBF,YAAYC,KAAKX,GAC7B,IAAIY,EAAmB,CAC1BH,MAAOX,EACPe,aAAcd,GAAMc,eAExBC,EAAkBJ,YAAYC,KAAKX,GAC5B,IAAIc,EAAkB,CACzBL,MAAOX,EACPe,aAAcd,GAAMc,eAExBE,EAAkBL,YAAYC,KAAKX,GAC5B,IAAIe,EAAkB,CAAEN,MAAOX,EAAKkB,MAAOjB,GAAMiB,QACxDC,EAAiBP,YAAYC,KAAKX,GAC3B,IAAIiB,EAAiB,CAAER,MAAOX,EAAKkB,MAAOjB,GAAMiB,QACvDE,EAAmBR,YAAYC,KAAKX,GAC7B,IAAIkB,EAAmB,CAAET,MAAOX,EAAKkB,MAAOjB,GAAMiB,QACzDG,EAAuBT,YAAYC,KAAKX,GACjC,IAAImB,EAAuB,CAAEV,MAAOX,IAC3CsB,EAAyBV,YAAYC,KAAKX,GACnC,IAAIoB,EAAyB,CAAEX,MAAOX,EAAKuB,IAAKtB,GAAMsB,MAC7DC,EAAwBZ,YAAYC,KAAKX,GAClC,IAAIsB,EAAwB,CAAEb,MAAOX,EAAKuB,IAAKtB,GAAMsB,MAC5DE,EAAiCb,YAAYC,KAAKX,GAC3C,IAAIuB,EAAiC,CAAEd,MAAOX,IACrD0B,EAAoBd,YAAYC,KAAKX,GAC9B,IAAIwB,EAAoB,CAC3Bf,MAAOX,EACPe,aAAcd,GAAMc,aACpBY,qBAAsB1B,GAAM0B,uBAE7B,IAAIC,EAAiB,CACxBjB,MAAOX,GAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createFilterRequestScope.js","sources":["../../../../../../../node_modules/viem/_esm/utils/filters/createFilterRequestScope.js"],"sourcesContent":["/**\n * Scopes `request` to the filter ID. If the client is a fallback, it will\n * listen for responses and scope the child transport `request` function\n * to the successful filter ID.\n */\nexport function createFilterRequestScope(client, { method }) {\n    const requestMap = {};\n    if (client.transport.type === 'fallback')\n        client.transport.onResponse?.(({ method: method_, response: id, status, transport, }) => {\n            if (status === 'success' && method === method_)\n                requestMap[id] = transport.request;\n        });\n    return ((id) => requestMap[id] || client.request);\n}\n//# sourceMappingURL=createFilterRequestScope.js.map"],"names":["createFilterRequestScope","client","method","requestMap","transport","type","onResponse","method_","response","id","status","request"],"mappings":"AAKO,SAASA,EAAyBC,GAAQC,OAAEA,IAC/C,MAAMC,EAAa,CAAA,EAMnB,MAL8B,aAA1BF,EAAOG,UAAUC,MACjBJ,EAAOG,UAAUE,aAAa,EAAGJ,OAAQK,EAASC,SAAUC,EAAIC,SAAQN,gBACrD,YAAXM,GAAwBR,IAAWK,IACnCJ,EAAWM,GAAML,EAAUO,WAE9BF,GAAON,EAAWM,IAAOR,EAAOU,OAC7C","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/formatters/block.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"block.js","sources":["../../../../../../../node_modules/viem/_esm/utils/formatters/block.js"],"sourcesContent":["import { defineFormatter } from './formatter.js';\nimport { formatTransaction } from './transaction.js';\nexport function formatBlock(block) {\n    const transactions = (block.transactions ?? []).map((transaction) => {\n        if (typeof transaction === 'string')\n            return transaction;\n        return formatTransaction(transaction);\n    });\n    return {\n        ...block,\n        baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,\n        blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : undefined,\n        difficulty: block.difficulty ? BigInt(block.difficulty) : undefined,\n        excessBlobGas: block.excessBlobGas\n            ? BigInt(block.excessBlobGas)\n            : undefined,\n        gasLimit: block.gasLimit ? BigInt(block.gasLimit) : undefined,\n        gasUsed: block.gasUsed ? BigInt(block.gasUsed) : undefined,\n        hash: block.hash ? block.hash : null,\n        logsBloom: block.logsBloom ? block.logsBloom : null,\n        nonce: block.nonce ? block.nonce : null,\n        number: block.number ? BigInt(block.number) : null,\n        size: block.size ? BigInt(block.size) : undefined,\n        timestamp: block.timestamp ? BigInt(block.timestamp) : undefined,\n        transactions,\n        totalDifficulty: block.totalDifficulty\n            ? BigInt(block.totalDifficulty)\n            : null,\n    };\n}\nexport const defineBlock = /*#__PURE__*/ defineFormatter('block', formatBlock);\n//# sourceMappingURL=block.js.map"],"names":["formatBlock","block","transactions","map","transaction","formatTransaction","baseFeePerGas","BigInt","blobGasUsed","undefined","difficulty","excessBlobGas","gasLimit","gasUsed","hash","logsBloom","nonce","number","size","timestamp","totalDifficulty"],"mappings":"qDAEO,SAASA,EAAYC,GACxB,MAAMC,GAAgBD,EAAMC,cAAgB,IAAIC,IAAKC,GACtB,iBAAhBA,EACAA,EACJC,EAAkBD,IAE7B,MAAO,IACAH,EACHK,cAAeL,EAAMK,cAAgBC,OAAON,EAAMK,eAAiB,KACnEE,YAAaP,EAAMO,YAAcD,OAAON,EAAMO,kBAAeC,EAC7DC,WAAYT,EAAMS,WAAaH,OAAON,EAAMS,iBAAcD,EAC1DE,cAAeV,EAAMU,cACfJ,OAAON,EAAMU,oBACbF,EACNG,SAAUX,EAAMW,SAAWL,OAAON,EAAMW,eAAYH,EACpDI,QAASZ,EAAMY,QAAUN,OAAON,EAAMY,cAAWJ,EACjDK,KAAMb,EAAMa,KAAOb,EAAMa,KAAO,KAChCC,UAAWd,EAAMc,UAAYd,EAAMc,UAAY,KAC/CC,MAAOf,EAAMe,MAAQf,EAAMe,MAAQ,KACnCC,OAAQhB,EAAMgB,OAASV,OAAON,EAAMgB,QAAU,KAC9CC,KAAMjB,EAAMiB,KAAOX,OAAON,EAAMiB,WAAQT,EACxCU,UAAWlB,EAAMkB,UAAYZ,OAAON,EAAMkB,gBAAaV,EACvDP,eACAkB,gBAAiBnB,EAAMmB,gBACjBb,OAAON,EAAMmB,iBACb,KAEd","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/formatters/extract.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract.js","sources":["../../../../../../../node_modules/viem/_esm/utils/formatters/extract.js"],"sourcesContent":["/**\n * @description Picks out the keys from `value` that exist in the formatter..\n */\nexport function extract(value_, { format }) {\n    if (!format)\n        return {};\n    const value = {};\n    function extract_(formatted) {\n        const keys = Object.keys(formatted);\n        for (const key of keys) {\n            if (key in value_)\n                value[key] = value_[key];\n            if (formatted[key] &&\n                typeof formatted[key] === 'object' &&\n                !Array.isArray(formatted[key]))\n                extract_(formatted[key]);\n        }\n    }\n    const formatted = format(value_ || {});\n    extract_(formatted);\n    return value;\n}\n//# sourceMappingURL=extract.js.map"],"names":["extract","value_","format","value","extract_","formatted","keys","Object","key","Array","isArray"],"mappings":"AAGO,SAASA,EAAQC,GAAQC,OAAEA,IAC9B,IAAKA,EACD,MAAO,CAAA,EACX,MAAMC,EAAQ,CAAA,EAcd,OAbA,SAASC,EAASC,GACd,MAAMC,EAAOC,OAAOD,KAAKD,GACzB,IAAK,MAAMG,KAAOF,EACVE,KAAOP,IACPE,EAAMK,GAAOP,EAAOO,IACpBH,EAAUG,IACgB,iBAAnBH,EAAUG,KAChBC,MAAMC,QAAQL,EAAUG,KACzBJ,EAASC,EAAUG,GAE/B,CAEAJ,CADkBF,EAAOD,GAAU,KAE5BE,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/formatters/feeHistory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"feeHistory.js","sources":["../../../../../../../node_modules/viem/_esm/utils/formatters/feeHistory.js"],"sourcesContent":["export function formatFeeHistory(feeHistory) {\n    return {\n        baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),\n        gasUsedRatio: feeHistory.gasUsedRatio,\n        oldestBlock: BigInt(feeHistory.oldestBlock),\n        reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value))),\n    };\n}\n//# sourceMappingURL=feeHistory.js.map"],"names":["formatFeeHistory","feeHistory","baseFeePerGas","map","value","BigInt","gasUsedRatio","oldestBlock","reward"],"mappings":"AAAO,SAASA,EAAiBC,GAC7B,MAAO,CACHC,cAAeD,EAAWC,cAAcC,IAAKC,GAAUC,OAAOD,IAC9DE,aAAcL,EAAWK,aACzBC,YAAaF,OAAOJ,EAAWM,aAC/BC,OAAQP,EAAWO,QAAQL,IAAKK,GAAWA,EAAOL,IAAKC,GAAUC,OAAOD,KAEhF","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/formatters/log.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.js","sources":["../../../../../../../node_modules/viem/_esm/utils/formatters/log.js"],"sourcesContent":["export function formatLog(log, { args, eventName, } = {}) {\n    return {\n        ...log,\n        blockHash: log.blockHash ? log.blockHash : null,\n        blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,\n        logIndex: log.logIndex ? Number(log.logIndex) : null,\n        transactionHash: log.transactionHash ? log.transactionHash : null,\n        transactionIndex: log.transactionIndex\n            ? Number(log.transactionIndex)\n            : null,\n        ...(eventName ? { args, eventName } : {}),\n    };\n}\n//# sourceMappingURL=log.js.map"],"names":["formatLog","log","args","eventName","blockHash","blockNumber","BigInt","logIndex","Number","transactionHash","transactionIndex"],"mappings":"AAAO,SAASA,EAAUC,GAAKC,KAAEA,EAAIC,UAAEA,GAAe,CAAA,GAClD,MAAO,IACAF,EACHG,UAAWH,EAAIG,UAAYH,EAAIG,UAAY,KAC3CC,YAAaJ,EAAII,YAAcC,OAAOL,EAAII,aAAe,KACzDE,SAAUN,EAAIM,SAAWC,OAAOP,EAAIM,UAAY,KAChDE,gBAAiBR,EAAIQ,gBAAkBR,EAAIQ,gBAAkB,KAC7DC,iBAAkBT,EAAIS,iBAChBF,OAAOP,EAAIS,kBACX,QACFP,EAAY,CAAED,OAAMC,aAAc,CAAA,EAE9C","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/formatters/proof.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"proof.js","sources":["../../../../../../../node_modules/viem/_esm/utils/formatters/proof.js"],"sourcesContent":["import { hexToNumber } from '../index.js';\nfunction formatStorageProof(storageProof) {\n    return storageProof.map((proof) => ({\n        ...proof,\n        value: BigInt(proof.value),\n    }));\n}\nexport function formatProof(proof) {\n    return {\n        ...proof,\n        balance: proof.balance ? BigInt(proof.balance) : undefined,\n        nonce: proof.nonce ? hexToNumber(proof.nonce) : undefined,\n        storageProof: proof.storageProof\n            ? formatStorageProof(proof.storageProof)\n            : undefined,\n    };\n}\n//# sourceMappingURL=proof.js.map"],"names":["formatProof","proof","balance","BigInt","undefined","nonce","hexToNumber","storageProof","map","value"],"mappings":"qDAOO,SAASA,EAAYC,GACxB,MAAO,IACAA,EACHC,QAASD,EAAMC,QAAUC,OAAOF,EAAMC,cAAWE,EACjDC,MAAOJ,EAAMI,MAAQC,EAAYL,EAAMI,YAASD,EAChDG,aAAcN,EAAMM,cAXAA,EAYKN,EAAMM,aAX5BA,EAAaC,IAAKP,IAAK,IACvBA,EACHQ,MAAON,OAAOF,EAAMQ,gBAUdL,GAbd,IAA4BG,CAe5B","x_google_ignoreList":[0]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"transaction.js","sources":["../../../../../../../node_modules/viem/_esm/utils/formatters/transaction.js"],"sourcesContent":["import { hexToNumber } from '../encoding/fromHex.js';\nimport { defineFormatter } from './formatter.js';\nexport const transactionType = {\n    '0x0': 'legacy',\n    '0x1': 'eip2930',\n    '0x2': 'eip1559',\n    '0x3': 'eip4844',\n    '0x4': 'eip7702',\n};\nexport function formatTransaction(transaction) {\n    const transaction_ = {\n        ...transaction,\n        blockHash: transaction.blockHash ? transaction.blockHash : null,\n        blockNumber: transaction.blockNumber\n            ? BigInt(transaction.blockNumber)\n            : null,\n        chainId: transaction.chainId ? hexToNumber(transaction.chainId) : undefined,\n        gas: transaction.gas ? BigInt(transaction.gas) : undefined,\n        gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : undefined,\n        maxFeePerBlobGas: transaction.maxFeePerBlobGas\n            ? BigInt(transaction.maxFeePerBlobGas)\n            : undefined,\n        maxFeePerGas: transaction.maxFeePerGas\n            ? BigInt(transaction.maxFeePerGas)\n            : undefined,\n        maxPriorityFeePerGas: transaction.maxPriorityFeePerGas\n            ? BigInt(transaction.maxPriorityFeePerGas)\n            : undefined,\n        nonce: transaction.nonce ? hexToNumber(transaction.nonce) : undefined,\n        to: transaction.to ? transaction.to : null,\n        transactionIndex: transaction.transactionIndex\n            ? Number(transaction.transactionIndex)\n            : null,\n        type: transaction.type\n            ? transactionType[transaction.type]\n            : undefined,\n        typeHex: transaction.type ? transaction.type : undefined,\n        value: transaction.value ? BigInt(transaction.value) : undefined,\n        v: transaction.v ? BigInt(transaction.v) : undefined,\n    };\n    if (transaction.authorizationList)\n        transaction_.authorizationList = formatAuthorizationList(transaction.authorizationList);\n    transaction_.yParity = (() => {\n        // If `yParity` is provided, we will use it.\n        if (transaction.yParity)\n            return Number(transaction.yParity);\n        // If no `yParity` provided, try derive from `v`.\n        if (typeof transaction_.v === 'bigint') {\n            if (transaction_.v === 0n || transaction_.v === 27n)\n                return 0;\n            if (transaction_.v === 1n || transaction_.v === 28n)\n                return 1;\n            if (transaction_.v >= 35n)\n                return transaction_.v % 2n === 0n ? 1 : 0;\n        }\n        return undefined;\n    })();\n    if (transaction_.type === 'legacy') {\n        delete transaction_.accessList;\n        delete transaction_.maxFeePerBlobGas;\n        delete transaction_.maxFeePerGas;\n        delete transaction_.maxPriorityFeePerGas;\n        delete transaction_.yParity;\n    }\n    if (transaction_.type === 'eip2930') {\n        delete transaction_.maxFeePerBlobGas;\n        delete transaction_.maxFeePerGas;\n        delete transaction_.maxPriorityFeePerGas;\n    }\n    if (transaction_.type === 'eip1559') {\n        delete transaction_.maxFeePerBlobGas;\n    }\n    return transaction_;\n}\nexport const defineTransaction = /*#__PURE__*/ defineFormatter('transaction', formatTransaction);\n//////////////////////////////////////////////////////////////////////////////\nfunction formatAuthorizationList(authorizationList) {\n    return authorizationList.map((authorization) => ({\n        address: authorization.address,\n        chainId: Number(authorization.chainId),\n        nonce: Number(authorization.nonce),\n        r: authorization.r,\n        s: authorization.s,\n        yParity: Number(authorization.yParity),\n    }));\n}\n//# sourceMappingURL=transaction.js.map"],"names":["transactionType","formatTransaction","transaction","transaction_","blockHash","blockNumber","BigInt","chainId","hexToNumber","undefined","gas","gasPrice","maxFeePerBlobGas","maxFeePerGas","maxPriorityFeePerGas","nonce","to","transactionIndex","Number","type","typeHex","value","v","authorizationList","map","authorization","address","r","s","yParity","accessList"],"mappings":"qDAEY,MAACA,EAAkB,CAC3B,MAAO,SACP,MAAO,UACP,MAAO,UACP,MAAO,UACP,MAAO,WAEJ,SAASC,EAAkBC,GAC9B,MAAMC,EAAe,IACdD,EACHE,UAAWF,EAAYE,UAAYF,EAAYE,UAAY,KAC3DC,YAAaH,EAAYG,YACnBC,OAAOJ,EAAYG,aACnB,KACNE,QAASL,EAAYK,QAAUC,EAAYN,EAAYK,cAAWE,EAClEC,IAAKR,EAAYQ,IAAMJ,OAAOJ,EAAYQ,UAAOD,EACjDE,SAAUT,EAAYS,SAAWL,OAAOJ,EAAYS,eAAYF,EAChEG,iBAAkBV,EAAYU,iBACxBN,OAAOJ,EAAYU,uBACnBH,EACNI,aAAcX,EAAYW,aACpBP,OAAOJ,EAAYW,mBACnBJ,EACNK,qBAAsBZ,EAAYY,qBAC5BR,OAAOJ,EAAYY,2BACnBL,EACNM,MAAOb,EAAYa,MAAQP,EAAYN,EAAYa,YAASN,EAC5DO,GAAId,EAAYc,GAAKd,EAAYc,GAAK,KACtCC,iBAAkBf,EAAYe,iBACxBC,OAAOhB,EAAYe,kBACnB,KACNE,KAAMjB,EAAYiB,KACZnB,EAAgBE,EAAYiB,WAC5BV,EACNW,QAASlB,EAAYiB,KAAOjB,EAAYiB,UAAOV,EAC/CY,MAAOnB,EAAYmB,MAAQf,OAAOJ,EAAYmB,YAASZ,EACvDa,EAAGpB,EAAYoB,EAAIhB,OAAOJ,EAAYoB,QAAKb,GAkC/C,OAhCIP,EAAYqB,oBACZpB,EAAaoB,kBAA4CrB,EAAYqB,kBAoChDC,IAAKC,IAAa,CACvCC,QAASD,EAAcC,QACvBnB,QAASW,OAAOO,EAAclB,SAC9BQ,MAAOG,OAAOO,EAAcV,OAC5BY,EAAGF,EAAcE,EACjBC,EAAGH,EAAcG,EACjBC,QAASX,OAAOO,EAAcI,aAzClC1B,EAAa0B,QAAU,MAEnB,GAAI3B,EAAY2B,QACZ,OAAOX,OAAOhB,EAAY2B,SAE9B,GAA8B,iBAAnB1B,EAAamB,EAAgB,CACpC,GAAuB,KAAnBnB,EAAamB,GAA+B,MAAnBnB,EAAamB,EACtC,OAAO,EACX,GAAuB,KAAnBnB,EAAamB,GAA+B,MAAnBnB,EAAamB,EACtC,OAAO,EACX,GAAInB,EAAamB,GAAK,IAClB,OAAOnB,EAAamB,EAAI,IAAO,GAAK,EAAI,CAChD,CAEH,EAdsB,GAeG,WAAtBnB,EAAagB,cACNhB,EAAa2B,kBACb3B,EAAaS,wBACbT,EAAaU,oBACbV,EAAaW,4BACbX,EAAa0B,SAEE,YAAtB1B,EAAagB,cACNhB,EAAaS,wBACbT,EAAaU,oBACbV,EAAaW,sBAEE,YAAtBX,EAAagB,aACNhB,EAAaS,iBAEjBT,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/formatters/transactionReceipt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transactionReceipt.js","sources":["../../../../../../../node_modules/viem/_esm/utils/formatters/transactionReceipt.js"],"sourcesContent":["import { hexToNumber } from '../encoding/fromHex.js';\nimport { defineFormatter } from './formatter.js';\nimport { formatLog } from './log.js';\nimport { transactionType } from './transaction.js';\nexport const receiptStatuses = {\n    '0x0': 'reverted',\n    '0x1': 'success',\n};\nexport function formatTransactionReceipt(transactionReceipt) {\n    const receipt = {\n        ...transactionReceipt,\n        blockNumber: transactionReceipt.blockNumber\n            ? BigInt(transactionReceipt.blockNumber)\n            : null,\n        contractAddress: transactionReceipt.contractAddress\n            ? transactionReceipt.contractAddress\n            : null,\n        cumulativeGasUsed: transactionReceipt.cumulativeGasUsed\n            ? BigInt(transactionReceipt.cumulativeGasUsed)\n            : null,\n        effectiveGasPrice: transactionReceipt.effectiveGasPrice\n            ? BigInt(transactionReceipt.effectiveGasPrice)\n            : null,\n        gasUsed: transactionReceipt.gasUsed\n            ? BigInt(transactionReceipt.gasUsed)\n            : null,\n        logs: transactionReceipt.logs\n            ? transactionReceipt.logs.map((log) => formatLog(log))\n            : null,\n        to: transactionReceipt.to ? transactionReceipt.to : null,\n        transactionIndex: transactionReceipt.transactionIndex\n            ? hexToNumber(transactionReceipt.transactionIndex)\n            : null,\n        status: transactionReceipt.status\n            ? receiptStatuses[transactionReceipt.status]\n            : null,\n        type: transactionReceipt.type\n            ? transactionType[transactionReceipt.type] || transactionReceipt.type\n            : null,\n    };\n    if (transactionReceipt.blobGasPrice)\n        receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);\n    if (transactionReceipt.blobGasUsed)\n        receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);\n    return receipt;\n}\nexport const defineTransactionReceipt = /*#__PURE__*/ defineFormatter('transactionReceipt', formatTransactionReceipt);\n//# sourceMappingURL=transactionReceipt.js.map"],"names":["receiptStatuses","formatTransactionReceipt","transactionReceipt","receipt","blockNumber","BigInt","contractAddress","cumulativeGasUsed","effectiveGasPrice","gasUsed","logs","map","log","formatLog","to","transactionIndex","hexToNumber","status","type","transactionType","blobGasPrice","blobGasUsed"],"mappings":"6IAIY,MAACA,EAAkB,CAC3B,MAAO,WACP,MAAO,WAEJ,SAASC,EAAyBC,GACrC,MAAMC,EAAU,IACTD,EACHE,YAAaF,EAAmBE,YAC1BC,OAAOH,EAAmBE,aAC1B,KACNE,gBAAiBJ,EAAmBI,gBAC9BJ,EAAmBI,gBACnB,KACNC,kBAAmBL,EAAmBK,kBAChCF,OAAOH,EAAmBK,mBAC1B,KACNC,kBAAmBN,EAAmBM,kBAChCH,OAAOH,EAAmBM,mBAC1B,KACNC,QAASP,EAAmBO,QACtBJ,OAAOH,EAAmBO,SAC1B,KACNC,KAAMR,EAAmBQ,KACnBR,EAAmBQ,KAAKC,IAAKC,GAAQC,EAAUD,IAC/C,KACNE,GAAIZ,EAAmBY,GAAKZ,EAAmBY,GAAK,KACpDC,iBAAkBb,EAAmBa,iBAC/BC,EAAYd,EAAmBa,kBAC/B,KACNE,OAAQf,EAAmBe,OACrBjB,EAAgBE,EAAmBe,QACnC,KACNC,KAAMhB,EAAmBgB,KACnBC,EAAgBjB,EAAmBgB,OAAShB,EAAmBgB,KAC/D,MAMV,OAJIhB,EAAmBkB,eACnBjB,EAAQiB,aAAef,OAAOH,EAAmBkB,eACjDlB,EAAmBmB,cACnBlB,EAAQkB,YAAchB,OAAOH,EAAmBmB,cAC7ClB,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/utils/formatters/transactionRequest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transactionRequest.js","sources":["../../../../../../../node_modules/viem/_esm/utils/formatters/transactionRequest.js"],"sourcesContent":["import { bytesToHex, numberToHex } from '../encoding/toHex.js';\nimport { defineFormatter } from './formatter.js';\nexport const rpcTransactionType = {\n    legacy: '0x0',\n    eip2930: '0x1',\n    eip1559: '0x2',\n    eip4844: '0x3',\n    eip7702: '0x4',\n};\nexport function formatTransactionRequest(request) {\n    const rpcRequest = {};\n    if (typeof request.authorizationList !== 'undefined')\n        rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);\n    if (typeof request.accessList !== 'undefined')\n        rpcRequest.accessList = request.accessList;\n    if (typeof request.blobVersionedHashes !== 'undefined')\n        rpcRequest.blobVersionedHashes = request.blobVersionedHashes;\n    if (typeof request.blobs !== 'undefined') {\n        if (typeof request.blobs[0] !== 'string')\n            rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));\n        else\n            rpcRequest.blobs = request.blobs;\n    }\n    if (typeof request.data !== 'undefined')\n        rpcRequest.data = request.data;\n    if (typeof request.from !== 'undefined')\n        rpcRequest.from = request.from;\n    if (typeof request.gas !== 'undefined')\n        rpcRequest.gas = numberToHex(request.gas);\n    if (typeof request.gasPrice !== 'undefined')\n        rpcRequest.gasPrice = numberToHex(request.gasPrice);\n    if (typeof request.maxFeePerBlobGas !== 'undefined')\n        rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);\n    if (typeof request.maxFeePerGas !== 'undefined')\n        rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);\n    if (typeof request.maxPriorityFeePerGas !== 'undefined')\n        rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);\n    if (typeof request.nonce !== 'undefined')\n        rpcRequest.nonce = numberToHex(request.nonce);\n    if (typeof request.to !== 'undefined')\n        rpcRequest.to = request.to;\n    if (typeof request.type !== 'undefined')\n        rpcRequest.type = rpcTransactionType[request.type];\n    if (typeof request.value !== 'undefined')\n        rpcRequest.value = numberToHex(request.value);\n    return rpcRequest;\n}\nexport const defineTransactionRequest = /*#__PURE__*/ defineFormatter('transactionRequest', formatTransactionRequest);\n//////////////////////////////////////////////////////////////////////////////\nfunction formatAuthorizationList(authorizationList) {\n    return authorizationList.map((authorization) => ({\n        address: authorization.address,\n        r: authorization.r\n            ? numberToHex(BigInt(authorization.r))\n            : authorization.r,\n        s: authorization.s\n            ? numberToHex(BigInt(authorization.s))\n            : authorization.s,\n        chainId: numberToHex(authorization.chainId),\n        nonce: numberToHex(authorization.nonce),\n        ...(typeof authorization.yParity !== 'undefined'\n            ? { yParity: numberToHex(authorization.yParity) }\n            : {}),\n        ...(typeof authorization.v !== 'undefined' &&\n            typeof authorization.yParity === 'undefined'\n            ? { v: numberToHex(authorization.v) }\n            : {}),\n    }));\n}\n//# sourceMappingURL=transactionRequest.js.map"],"names":["rpcTransactionType","legacy","eip2930","eip1559","eip4844","eip7702","formatTransactionRequest","request","rpcRequest","authorizationList","map","authorization","address","r","numberToHex","BigInt","s","chainId","nonce","yParity","v","accessList","blobVersionedHashes","blobs","x","bytesToHex","data","from","gas","gasPrice","maxFeePerBlobGas","maxFeePerGas","maxPriorityFeePerGas","to","type","value"],"mappings":"mEAEY,MAACA,EAAqB,CAC9BC,OAAQ,MACRC,QAAS,MACTC,QAAS,MACTC,QAAS,MACTC,QAAS,OAEN,SAASC,EAAyBC,GACrC,MAAMC,EAAa,CAAA,EAmCnB,YAlCyC,IAA9BD,EAAQE,oBACfD,EAAWC,kBAA4CF,EAAQE,kBAsC1CC,IAAKC,IAAa,CACvCC,QAASD,EAAcC,QACvBC,EAAGF,EAAcE,EACXC,EAAYC,OAAOJ,EAAcE,IACjCF,EAAcE,EACpBG,EAAGL,EAAcK,EACXF,EAAYC,OAAOJ,EAAcK,IACjCL,EAAcK,EACpBC,QAASH,EAAYH,EAAcM,SACnCC,MAAOJ,EAAYH,EAAcO,eACI,IAA1BP,EAAcQ,QACnB,CAAEA,QAASL,EAAYH,EAAcQ,UACrC,WACyB,IAApBR,EAAcS,QACY,IAA1BT,EAAcQ,QACnB,CAAEC,EAAGN,EAAYH,EAAcS,IAC/B,YArDwB,IAAvBb,EAAQc,aACfb,EAAWa,WAAad,EAAQc,iBACO,IAAhCd,EAAQe,sBACfd,EAAWc,oBAAsBf,EAAQe,0BAChB,IAAlBf,EAAQgB,QACiB,iBAArBhB,EAAQgB,MAAM,GACrBf,EAAWe,MAAQhB,EAAQgB,MAAMb,IAAKc,GAAMC,EAAWD,IAEvDhB,EAAWe,MAAQhB,EAAQgB,YAEP,IAAjBhB,EAAQmB,OACflB,EAAWkB,KAAOnB,EAAQmB,WACF,IAAjBnB,EAAQoB,OACfnB,EAAWmB,KAAOpB,EAAQoB,WACH,IAAhBpB,EAAQqB,MACfpB,EAAWoB,IAAMd,EAAYP,EAAQqB,WACT,IAArBrB,EAAQsB,WACfrB,EAAWqB,SAAWf,EAAYP,EAAQsB,gBACN,IAA7BtB,EAAQuB,mBACftB,EAAWsB,iBAAmBhB,EAAYP,EAAQuB,wBAClB,IAAzBvB,EAAQwB,eACfvB,EAAWuB,aAAejB,EAAYP,EAAQwB,oBACN,IAAjCxB,EAAQyB,uBACfxB,EAAWwB,qBAAuBlB,EAAYP,EAAQyB,4BAC7B,IAAlBzB,EAAQW,QACfV,EAAWU,MAAQJ,EAAYP,EAAQW,aACjB,IAAfX,EAAQ0B,KACfzB,EAAWyB,GAAK1B,EAAQ0B,SACA,IAAjB1B,EAAQ2B,OACf1B,EAAW0B,KAAOlC,EAAmBO,EAAQ2B,YACpB,IAAlB3B,EAAQ4B,QACf3B,EAAW2B,MAAQrB,EAAYP,EAAQ4B,QACpC3B,CACX","x_google_ignoreList":[0]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"getAction.js","sources":["../../../../../../node_modules/viem/_esm/utils/getAction.js"],"sourcesContent":["/**\n * Retrieves and returns an action from the client (if exists), and falls\n * back to the tree-shakable action.\n *\n * Useful for extracting overridden actions from a client (ie. if a consumer\n * wants to override the `sendTransaction` implementation).\n */\nexport function getAction(client, actionFn, \n// Some minifiers drop `Function.prototype.name`, or replace it with short letters,\n// meaning that `actionFn.name` will not always work. For that case, the consumer\n// needs to pass the name explicitly.\nname) {\n    const action_implicit = client[actionFn.name];\n    if (typeof action_implicit === 'function')\n        return action_implicit;\n    const action_explicit = client[name];\n    if (typeof action_explicit === 'function')\n        return action_explicit;\n    return (params) => actionFn(client, params);\n}\n//# sourceMappingURL=getAction.js.map"],"names":["getAction","client","actionFn","name","action_implicit","action_explicit","params"],"mappings":"AAOO,SAASA,EAAUC,EAAQC,EAIlCC,GACI,MAAMC,EAAkBH,EAAOC,EAASC,MACxC,GAA+B,mBAApBC,EACP,OAAOA,EACX,MAAMC,EAAkBJ,EAAOE,GAC/B,MAA+B,mBAApBE,EACAA,EACHC,GAAWJ,EAASD,EAAQK,EACxC","x_google_ignoreList":[0]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"hashSignature.js","sources":["../../../../../../../node_modules/viem/_esm/utils/hash/hashSignature.js"],"sourcesContent":["import { toBytes } from '../encoding/toBytes.js';\nimport { keccak256 } from './keccak256.js';\nconst hash = (value) => keccak256(toBytes(value));\nexport function hashSignature(sig) {\n    return hash(sig);\n}\n//# sourceMappingURL=hashSignature.js.map"],"names":["hashSignature","sig","keccak256","toBytes"],"mappings":"4FAGO,SAASA,EAAcC,GAC1B,OAFoBC,EAAUC,EAElBF,GAChB","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import{keccak_256 as o}from"../../../../@noble/hashes/esm/sha3.js";import{isHex as t}from"../data/isHex.js";import{toBytes as s}from"../encoding/toBytes.js";import{toHex as e}from"../encoding/toHex.js";function r(r,i){const m=i||"hex",n=o(t(r,{strict:!1})?s(r):r);return"bytes"===m?n:e(n)}export{r as keccak256};
-//# sourceMappingURL=keccak256.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"keccak256.js","sources":["../../../../../../../node_modules/viem/_esm/utils/hash/keccak256.js"],"sourcesContent":["import { keccak_256 } from '@noble/hashes/sha3';\nimport { isHex } from '../data/isHex.js';\nimport { toBytes } from '../encoding/toBytes.js';\nimport { toHex } from '../encoding/toHex.js';\nexport function keccak256(value, to_) {\n    const to = to_ || 'hex';\n    const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);\n    if (to === 'bytes')\n        return bytes;\n    return toHex(bytes);\n}\n//# sourceMappingURL=keccak256.js.map"],"names":["keccak256","value","to_","to","bytes","keccak_256","isHex","strict","toBytes","toHex"],"mappings":"0MAIO,SAASA,EAAUC,EAAOC,GAC7B,MAAMC,EAAKD,GAAO,MACZE,EAAQC,EAAWC,EAAML,EAAO,CAAEM,QAAQ,IAAWC,EAAQP,GAASA,GAC5E,MAAW,UAAPE,EACOC,EACJK,EAAML,EACjB","x_google_ignoreList":[0]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"normalizeSignature.js","sources":["../../../../../../../node_modules/viem/_esm/utils/hash/normalizeSignature.js"],"sourcesContent":["import { BaseError } from '../../errors/base.js';\nexport function normalizeSignature(signature) {\n    let active = true;\n    let current = '';\n    let level = 0;\n    let result = '';\n    let valid = false;\n    for (let i = 0; i < signature.length; i++) {\n        const char = signature[i];\n        // If the character is a separator, we want to reactivate.\n        if (['(', ')', ','].includes(char))\n            active = true;\n        // If the character is a \"level\" token, we want to increment/decrement.\n        if (char === '(')\n            level++;\n        if (char === ')')\n            level--;\n        // If we aren't active, we don't want to mutate the result.\n        if (!active)\n            continue;\n        // If level === 0, we are at the definition level.\n        if (level === 0) {\n            if (char === ' ' && ['event', 'function', ''].includes(result))\n                result = '';\n            else {\n                result += char;\n                // If we are at the end of the definition, we must be finished.\n                if (char === ')') {\n                    valid = true;\n                    break;\n                }\n            }\n            continue;\n        }\n        // Ignore spaces\n        if (char === ' ') {\n            // If the previous character is a separator, and the current section isn't empty, we want to deactivate.\n            if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {\n                current = '';\n                active = false;\n            }\n            continue;\n        }\n        result += char;\n        current += char;\n    }\n    if (!valid)\n        throw new BaseError('Unable to normalize signature.');\n    return result;\n}\n//# sourceMappingURL=normalizeSignature.js.map"],"names":["normalizeSignature","signature","active","current","level","result","valid","i","length","char","includes","BaseError"],"mappings":"iDACO,SAASA,EAAmBC,GAC/B,IAAIC,GAAS,EACTC,EAAU,GACVC,EAAQ,EACRC,EAAS,GACTC,GAAQ,EACZ,IAAK,IAAIC,EAAI,EAAGA,EAAIN,EAAUO,OAAQD,IAAK,CACvC,MAAME,EAAOR,EAAUM,GAUvB,GARI,CAAC,IAAK,IAAK,KAAKG,SAASD,KACzBP,GAAS,GAEA,MAATO,GACAL,IACS,MAATK,GACAL,IAECF,EAGL,GAAc,IAAVE,EAcS,MAATK,GAQJJ,GAAUI,EACVN,GAAWM,GAPkB,MAArBR,EAAUM,EAAI,IAA0B,MAAZJ,GAA+B,OAAZA,IAC/CA,EAAU,GACVD,GAAS,QAjBb,GAAa,MAATO,GAAgB,CAAC,QAAS,WAAY,IAAIC,SAASL,GACnDA,EAAS,QAIT,GAFAA,GAAUI,EAEG,MAATA,EAAc,CACdH,GAAQ,EACR,KACJ,CAeZ,CACA,IAAKA,EACD,MAAM,IAAIK,EAAU,kCACxB,OAAON,CACX","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import{sha256 as s}from"../../../../@noble/hashes/esm/sha256.js";import{isHex as o}from"../data/isHex.js";import{toBytes as t}from"../encoding/toBytes.js";function r(r,e){return s(o(r,{strict:!1})?t(r):r)}export{r as sha256};
-//# sourceMappingURL=sha256.js.map

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

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

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

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

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

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