superstack-wallet-sdk 0.4.5 → 0.4.8

package/dist/esm/node_modules/viem/_esm/actions/public/estimateGas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"estimateGas.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/estimateGas.js"],"sourcesContent":["import { parseAccount, } from '../../accounts/utils/parseAccount.js';\nimport { BaseError } from '../../errors/base.js';\nimport { recoverAuthorizationAddress, } from '../../utils/authorization/recoverAuthorizationAddress.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { getEstimateGasError, } from '../../utils/errors/getEstimateGasError.js';\nimport { extract } from '../../utils/formatters/extract.js';\nimport { formatTransactionRequest, } from '../../utils/formatters/transactionRequest.js';\nimport { serializeStateOverride } from '../../utils/stateOverride.js';\nimport { assertRequest, } from '../../utils/transaction/assertRequest.js';\nimport { prepareTransactionRequest, } from '../wallet/prepareTransactionRequest.js';\n/**\n * Estimates the gas necessary to complete a transaction without submitting it to the network.\n *\n * - Docs: https://viem.sh/docs/actions/public/estimateGas\n * - JSON-RPC Methods: [`eth_estimateGas`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_estimategas)\n *\n * @param client - Client to use\n * @param parameters - {@link EstimateGasParameters}\n * @returns The gas estimate (in gas units). {@link EstimateGasReturnType}\n *\n * @example\n * import { createPublicClient, http, parseEther } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { estimateGas } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const gasEstimate = await estimateGas(client, {\n *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',\n *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',\n *   value: parseEther('1'),\n * })\n */\nexport async function estimateGas(client, args) {\n    const { account: account_ = client.account } = args;\n    const account = account_ ? parseAccount(account_) : undefined;\n    try {\n        const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = (await prepareTransactionRequest(client, {\n            ...args,\n            parameters: \n            // Some RPC Providers do not compute versioned hashes from blobs. We will need\n            // to compute them.\n            account?.type === 'local' ? undefined : ['blobVersionedHashes'],\n        }));\n        const blockNumberHex = typeof blockNumber === 'bigint' ? numberToHex(blockNumber) : undefined;\n        const block = blockNumberHex || blockTag;\n        const rpcStateOverride = serializeStateOverride(stateOverride);\n        const to = await (async () => {\n            // If `to` exists on the parameters, use that.\n            if (rest.to)\n                return rest.to;\n            // If no `to` exists, and we are sending a EIP-7702 transaction, use the\n            // address of the first authorization in the list.\n            if (authorizationList && authorizationList.length > 0)\n                return await recoverAuthorizationAddress({\n                    authorization: authorizationList[0],\n                }).catch(() => {\n                    throw new BaseError('`to` is required. Could not infer from `authorizationList`');\n                });\n            // Otherwise, we are sending a deployment transaction.\n            return undefined;\n        })();\n        assertRequest(args);\n        const chainFormat = client.chain?.formatters?.transactionRequest?.format;\n        const format = chainFormat || formatTransactionRequest;\n        const request = format({\n            // Pick out extra data that might exist on the chain's transaction request type.\n            ...extract(rest, { format: chainFormat }),\n            from: account?.address,\n            accessList,\n            authorizationList,\n            blobs,\n            blobVersionedHashes,\n            data,\n            gas,\n            gasPrice,\n            maxFeePerBlobGas,\n            maxFeePerGas,\n            maxPriorityFeePerGas,\n            nonce,\n            to,\n            value,\n        });\n        return BigInt(await client.request({\n            method: 'eth_estimateGas',\n            params: rpcStateOverride\n                ? [\n                    request,\n                    block ?? client.experimental_blockTag ?? 'latest',\n                    rpcStateOverride,\n                ]\n                : block\n                    ? [request, block]\n                    : [request],\n        }));\n    }\n    catch (err) {\n        throw getEstimateGasError(err, {\n            ...args,\n            account,\n            chain: client.chain,\n        });\n    }\n}\n//# sourceMappingURL=estimateGas.js.map"],"names":["async","estimateGas","client","args","account","account_","parseAccount","undefined","accessList","authorizationList","blobs","blobVersionedHashes","blockNumber","blockTag","data","gas","gasPrice","maxFeePerBlobGas","maxFeePerGas","maxPriorityFeePerGas","nonce","value","stateOverride","rest","prepareTransactionRequest","parameters","type","block","numberToHex","rpcStateOverride","serializeStateOverride","to","length","recoverAuthorizationAddress","authorization","catch","BaseError","assertRequest","chainFormat","chain","formatters","transactionRequest","format","request","formatTransactionRequest","extract","from","address","BigInt","method","params","experimental_blockTag","err","getEstimateGasError"],"mappings":"8tBAmCOA,eAAeC,EAAYC,EAAQC,GACtC,MAAQC,QAASC,EAAWH,EAAOE,SAAYD,EACzCC,EAAUC,EAAWC,EAAaD,QAAYE,EACpD,IACI,MAAMC,WAAEA,EAAUC,kBAAEA,EAAiBC,MAAEA,EAAKC,oBAAEA,EAAmBC,YAAEA,EAAWC,SAAEA,EAAQC,KAAEA,EAAIC,IAAEA,EAAGC,SAAEA,EAAQC,iBAAEA,EAAgBC,aAAEA,EAAYC,qBAAEA,EAAoBC,MAAEA,EAAKC,MAAEA,EAAKC,cAAEA,KAAkBC,SAAgBC,EAA0BtB,EAAQ,IAChPC,EACHsB,WAGkB,UAAlBrB,GAASsB,UAAmBnB,EAAY,CAAC,yBAGvCoB,GADwC,iBAAhBf,EAA2BgB,EAAYhB,QAAeL,IACpDM,EAC1BgB,EAAmBC,EAAuBR,GAC1CS,OAAW,UAETR,EAAKQ,GACER,EAAKQ,GAGZtB,GAAqBA,EAAkBuB,OAAS,QACnCC,EAA4B,CACrCC,cAAezB,EAAkB,KAClC0B,MAAM,KACL,MAAM,IAAIC,EAAU,qEAJ5B,EANa,GAejBC,EAAclC,GACd,MAAMmC,EAAcpC,EAAOqC,OAAOC,YAAYC,oBAAoBC,OAE5DC,GADSL,GAAeM,GACP,IAEhBC,EAAQtB,EAAM,CAAEmB,OAAQJ,IAC3BQ,KAAM1C,GAAS2C,QACfvC,aACAC,oBACAC,QACAC,sBACAG,OACAC,MACAC,WACAC,mBACAC,eACAC,uBACAC,QACAW,KACAV,UAEJ,OAAO2B,aAAa9C,EAAOyC,QAAQ,CAC/BM,OAAQ,kBACRC,OAAQrB,EACF,CACEc,EACAhB,GAASzB,EAAOiD,uBAAyB,SACzCtB,GAEFF,EACI,CAACgB,EAAShB,GACV,CAACgB,KAEnB,CACA,MAAOS,GACH,MAAMC,EAAoBD,EAAK,IACxBjD,EACHC,UACAmC,MAAOrC,EAAOqC,OAEtB,CACJ","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"estimateMaxPriorityFeePerGas.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js"],"sourcesContent":["import { Eip1559FeesNotSupportedError, } from '../../errors/fee.js';\nimport { hexToBigInt, } from '../../utils/encoding/fromHex.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { getBlock } from './getBlock.js';\nimport { getGasPrice } from './getGasPrice.js';\n/**\n * Returns an estimate for the max priority fee per gas (in wei) for a\n * transaction to be likely included in the next block.\n * Defaults to [`chain.fees.defaultPriorityFee`](/docs/clients/chains#fees-defaultpriorityfee) if set.\n *\n * - Docs: https://viem.sh/docs/actions/public/estimateMaxPriorityFeePerGas\n *\n * @param client - Client to use\n * @returns An estimate (in wei) for the max priority fee per gas. {@link EstimateMaxPriorityFeePerGasReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { estimateMaxPriorityFeePerGas } from 'viem/actions'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const maxPriorityFeePerGas = await estimateMaxPriorityFeePerGas(client)\n * // 10000000n\n */\nexport async function estimateMaxPriorityFeePerGas(client, args) {\n    return internal_estimateMaxPriorityFeePerGas(client, args);\n}\nexport async function internal_estimateMaxPriorityFeePerGas(client, args) {\n    const { block: block_, chain = client.chain, request } = args || {};\n    try {\n        const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;\n        if (typeof maxPriorityFeePerGas === 'function') {\n            const block = block_ || (await getAction(client, getBlock, 'getBlock')({}));\n            const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({\n                block,\n                client,\n                request,\n            });\n            if (maxPriorityFeePerGas_ === null)\n                throw new Error();\n            return maxPriorityFeePerGas_;\n        }\n        if (typeof maxPriorityFeePerGas !== 'undefined')\n            return maxPriorityFeePerGas;\n        const maxPriorityFeePerGasHex = await client.request({\n            method: 'eth_maxPriorityFeePerGas',\n        });\n        return hexToBigInt(maxPriorityFeePerGasHex);\n    }\n    catch {\n        // If the RPC Provider does not support `eth_maxPriorityFeePerGas`\n        // fall back to calculating it manually via `gasPrice - baseFeePerGas`.\n        // See: https://github.com/ethereum/pm/issues/328#:~:text=eth_maxPriorityFeePerGas%20after%20London%20will%20effectively%20return%20eth_gasPrice%20%2D%20baseFee\n        const [block, gasPrice] = await Promise.all([\n            block_\n                ? Promise.resolve(block_)\n                : getAction(client, getBlock, 'getBlock')({}),\n            getAction(client, getGasPrice, 'getGasPrice')({}),\n        ]);\n        if (typeof block.baseFeePerGas !== 'bigint')\n            throw new Eip1559FeesNotSupportedError();\n        const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;\n        if (maxPriorityFeePerGas < 0n)\n            return 0n;\n        return maxPriorityFeePerGas;\n    }\n}\n//# sourceMappingURL=estimateMaxPriorityFeePerGas.js.map"],"names":["async","estimateMaxPriorityFeePerGas","client","args","internal_estimateMaxPriorityFeePerGas","block","block_","chain","request","maxPriorityFeePerGas","fees","defaultPriorityFee","getAction","getBlock","maxPriorityFeePerGas_","Error","maxPriorityFeePerGasHex","method","hexToBigInt","gasPrice","Promise","all","resolve","getGasPrice","baseFeePerGas","Eip1559FeesNotSupportedError"],"mappings":"8QA2BOA,eAAeC,EAA6BC,EAAQC,GACvD,OAAOC,EAAsCF,EAAQC,EACzD,CACOH,eAAeI,EAAsCF,EAAQC,GAChE,MAAQE,MAAOC,EAAMC,MAAEA,EAAQL,EAAOK,MAAKC,QAAEA,GAAYL,GAAQ,CAAA,EACjE,IACI,MAAMM,EAAuBF,GAAOG,MAAMD,sBAAwBF,GAAOG,MAAMC,mBAC/E,GAAoC,mBAAzBF,EAAqC,CAC5C,MAAMJ,EAAQC,SAAiBM,EAAUV,EAAQW,EAAU,WAA5BD,CAAwC,CAAA,GACjEE,QAA8BL,EAAqB,CACrDJ,QACAH,SACAM,YAEJ,GAA8B,OAA1BM,EACA,MAAM,IAAIC,MACd,OAAOD,CACX,CACA,QAAoC,IAAzBL,EACP,OAAOA,EACX,MAAMO,QAAgCd,EAAOM,QAAQ,CACjDS,OAAQ,6BAEZ,OAAOC,EAAYF,EACvB,CACA,MAII,MAAOX,EAAOc,SAAkBC,QAAQC,IAAI,CACxCf,EACMc,QAAQE,QAAQhB,GAChBM,EAAUV,EAAQW,EAAU,WAA5BD,CAAwC,CAAA,GAC9CA,EAAUV,EAAQqB,EAAa,cAA/BX,CAA8C,CAAA,KAElD,GAAmC,iBAAxBP,EAAMmB,cACb,MAAM,IAAIC,EACd,MAAMhB,EAAuBU,EAAWd,EAAMmB,cAC9C,OAAIf,EAAuB,GAChB,GACJA,CACX,CACJ","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getBalance.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getBalance.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getBalance.js"],"sourcesContent":["import { numberToHex, } from '../../utils/encoding/toHex.js';\n/**\n * Returns the balance of an address in wei.\n *\n * - Docs: https://viem.sh/docs/actions/public/getBalance\n * - JSON-RPC Methods: [`eth_getBalance`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getbalance)\n *\n * You can convert the balance to ether units with [`formatEther`](https://viem.sh/docs/utilities/formatEther).\n *\n * ```ts\n * const balance = await getBalance(client, {\n *   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',\n *   blockTag: 'safe'\n * })\n * const balanceAsEther = formatEther(balance)\n * // \"6.942\"\n * ```\n *\n * @param client - Client to use\n * @param parameters - {@link GetBalanceParameters}\n * @returns The balance of the address in wei. {@link GetBalanceReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getBalance } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const balance = await getBalance(client, {\n *   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',\n * })\n * // 10000000000000000000000n (wei)\n */\nexport async function getBalance(client, { address, blockNumber, blockTag = client.experimental_blockTag ?? 'latest', }) {\n    const blockNumberHex = typeof blockNumber === 'bigint' ? numberToHex(blockNumber) : undefined;\n    const balance = await client.request({\n        method: 'eth_getBalance',\n        params: [address, blockNumberHex || blockTag],\n    });\n    return BigInt(balance);\n}\n//# sourceMappingURL=getBalance.js.map"],"names":["async","getBalance","client","address","blockNumber","blockTag","experimental_blockTag","blockNumberHex","numberToHex","undefined","balance","request","method","params","BigInt"],"mappings":"4DAoCOA,eAAeC,EAAWC,GAAQC,QAAEA,EAAOC,YAAEA,EAAWC,SAAEA,EAAWH,EAAOI,uBAAyB,WACxG,MAAMC,EAAwC,iBAAhBH,EAA2BI,EAAYJ,QAAeK,EAC9EC,QAAgBR,EAAOS,QAAQ,CACjCC,OAAQ,iBACRC,OAAQ,CAACV,EAASI,GAAkBF,KAExC,OAAOS,OAAOJ,EAClB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getBlobBaseFee.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getBlobBaseFee.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getBlobBaseFee.js"],"sourcesContent":["/**\n * Returns the base fee per blob gas in wei.\n *\n * - Docs: https://viem.sh/docs/actions/public/getBlobBaseFee\n * - JSON-RPC Methods: [`eth_blobBaseFee`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_blobBaseFee)\n *\n * @param client - Client to use\n * @returns The blob base fee (in wei). {@link GetBlobBaseFeeReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getBlobBaseFee } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const blobBaseFee = await getBlobBaseFee(client)\n */\nexport async function getBlobBaseFee(client) {\n    const baseFee = await client.request({\n        method: 'eth_blobBaseFee',\n    });\n    return BigInt(baseFee);\n}\n//# sourceMappingURL=getBlobBaseFee.js.map"],"names":["async","getBlobBaseFee","client","baseFee","request","method","BigInt"],"mappings":"AAoBOA,eAAeC,EAAeC,GACjC,MAAMC,QAAgBD,EAAOE,QAAQ,CACjCC,OAAQ,oBAEZ,OAAOC,OAAOH,EAClB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getBlock.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getBlock.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getBlock.js"],"sourcesContent":["import { BlockNotFoundError, } from '../../errors/block.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { formatBlock, } from '../../utils/formatters/block.js';\n/**\n * Returns information about a block at a block number, hash, or tag.\n *\n * - Docs: https://viem.sh/docs/actions/public/getBlock\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_fetching-blocks\n * - JSON-RPC Methods:\n *   - Calls [`eth_getBlockByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblockbynumber) for `blockNumber` & `blockTag`.\n *   - Calls [`eth_getBlockByHash`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblockbyhash) for `blockHash`.\n *\n * @param client - Client to use\n * @param parameters - {@link GetBlockParameters}\n * @returns Information about the block. {@link GetBlockReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getBlock } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const block = await getBlock(client)\n */\nexport async function getBlock(client, { blockHash, blockNumber, blockTag = client.experimental_blockTag ?? 'latest', includeTransactions: includeTransactions_, } = {}) {\n    const includeTransactions = includeTransactions_ ?? false;\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    let block = null;\n    if (blockHash) {\n        block = await client.request({\n            method: 'eth_getBlockByHash',\n            params: [blockHash, includeTransactions],\n        }, { dedupe: true });\n    }\n    else {\n        block = await client.request({\n            method: 'eth_getBlockByNumber',\n            params: [blockNumberHex || blockTag, includeTransactions],\n        }, { dedupe: Boolean(blockNumberHex) });\n    }\n    if (!block)\n        throw new BlockNotFoundError({ blockHash, blockNumber });\n    const format = client.chain?.formatters?.block?.format || formatBlock;\n    return format(block);\n}\n//# sourceMappingURL=getBlock.js.map"],"names":["async","getBlock","client","blockHash","blockNumber","blockTag","experimental_blockTag","includeTransactions","includeTransactions_","blockNumberHex","undefined","numberToHex","block","request","method","params","dedupe","Boolean","BlockNotFoundError","chain","formatters","format","formatBlock"],"mappings":"qLA2BOA,eAAeC,EAASC,GAAQC,UAAEA,EAASC,YAAEA,EAAWC,SAAEA,EAAWH,EAAOI,uBAAyB,SAAUC,oBAAqBC,GAA0B,CAAA,GACjK,MAAMD,EAAsBC,IAAwB,EAC9CC,OAAiCC,IAAhBN,EAA4BO,EAAYP,QAAeM,EAC9E,IAAIE,EAAQ,KAaZ,GAXIA,EADAT,QACcD,EAAOW,QAAQ,CACzBC,OAAQ,qBACRC,OAAQ,CAACZ,EAAWI,IACrB,CAAES,QAAQ,UAGCd,EAAOW,QAAQ,CACzBC,OAAQ,uBACRC,OAAQ,CAACN,GAAkBJ,EAAUE,IACtC,CAAES,OAAQC,QAAQR,MAEpBG,EACD,MAAM,IAAIM,EAAmB,CAAEf,YAAWC,gBAE9C,OADeF,EAAOiB,OAAOC,YAAYR,OAAOS,QAAUC,GAC5CV,EAClB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getBlockNumber.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getBlockNumber.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getBlockNumber.js"],"sourcesContent":["import { getCache, withCache, } from '../../utils/promise/withCache.js';\nconst cacheKey = (id) => `blockNumber.${id}`;\n/** @internal */\nexport function getBlockNumberCache(id) {\n    return getCache(cacheKey(id));\n}\n/**\n * Returns the number of the most recent block seen.\n *\n * - Docs: https://viem.sh/docs/actions/public/getBlockNumber\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_fetching-blocks\n * - JSON-RPC Methods: [`eth_blockNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_blocknumber)\n *\n * @param client - Client to use\n * @param parameters - {@link GetBlockNumberParameters}\n * @returns The number of the block. {@link GetBlockNumberReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getBlockNumber } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const blockNumber = await getBlockNumber(client)\n * // 69420n\n */\nexport async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {\n    const blockNumberHex = await withCache(() => client.request({\n        method: 'eth_blockNumber',\n    }), { cacheKey: cacheKey(client.uid), cacheTime });\n    return BigInt(blockNumberHex);\n}\n//# sourceMappingURL=getBlockNumber.js.map"],"names":["async","getBlockNumber","client","cacheTime","blockNumberHex","withCache","request","method","cacheKey","id","uid","BigInt"],"mappings":"6DA6BOA,eAAeC,EAAeC,GAAQC,UAAEA,EAAYD,EAAOC,WAAc,IAC5E,MAAMC,QAAuBC,EAAU,IAAMH,EAAOI,QAAQ,CACxDC,OAAQ,oBACR,CAAEC,UA/BQC,EA+BWP,EAAOQ,IA/BX,eAAeD,KA+BEN,cA/BzB,IAACM,EAgCd,OAAOE,OAAOP,EAClB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getBlockTransactionCount.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getBlockTransactionCount.js"],"sourcesContent":["import { hexToNumber, } from '../../utils/encoding/fromHex.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\n/**\n * Returns the number of Transactions at a block number, hash, or tag.\n *\n * - Docs: https://viem.sh/docs/actions/public/getBlockTransactionCount\n * - JSON-RPC Methods:\n *   - Calls [`eth_getBlockTransactionCountByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblocktransactioncountbynumber) for `blockNumber` & `blockTag`.\n *   - Calls [`eth_getBlockTransactionCountByHash`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblocktransactioncountbyhash) for `blockHash`.\n *\n * @param client - Client to use\n * @param parameters - {@link GetBlockTransactionCountParameters}\n * @returns The block transaction count. {@link GetBlockTransactionCountReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getBlockTransactionCount } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const count = await getBlockTransactionCount(client)\n */\nexport async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = 'latest', } = {}) {\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    let count;\n    if (blockHash) {\n        count = await client.request({\n            method: 'eth_getBlockTransactionCountByHash',\n            params: [blockHash],\n        }, { dedupe: true });\n    }\n    else {\n        count = await client.request({\n            method: 'eth_getBlockTransactionCountByNumber',\n            params: [blockNumberHex || blockTag],\n        }, { dedupe: Boolean(blockNumberHex) });\n    }\n    return hexToNumber(count);\n}\n//# sourceMappingURL=getBlockTransactionCount.js.map"],"names":["async","getBlockTransactionCount","client","blockHash","blockNumber","blockTag","blockNumberHex","undefined","numberToHex","count","request","method","params","dedupe","Boolean","hexToNumber"],"mappings":"0HAyBOA,eAAeC,EAAyBC,GAAQC,UAAEA,EAASC,YAAEA,EAAWC,SAAEA,EAAW,UAAc,IACtG,MAAMC,OAAiCC,IAAhBH,EAA4BI,EAAYJ,QAAeG,EAC9E,IAAIE,EAaJ,OAXIA,EADAN,QACcD,EAAOQ,QAAQ,CACzBC,OAAQ,qCACRC,OAAQ,CAACT,IACV,CAAEU,QAAQ,UAGCX,EAAOQ,QAAQ,CACzBC,OAAQ,uCACRC,OAAQ,CAACN,GAAkBD,IAC5B,CAAEQ,OAAQC,QAAQR,KAElBS,EAAYN,EACvB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getChainId.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getChainId.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getChainId.js"],"sourcesContent":["import { hexToNumber, } from '../../utils/encoding/fromHex.js';\n/**\n * Returns the chain ID associated with the current network.\n *\n * - Docs: https://viem.sh/docs/actions/public/getChainId\n * - JSON-RPC Methods: [`eth_chainId`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_chainid)\n *\n * @param client - Client to use\n * @returns The current chain ID. {@link GetChainIdReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getChainId } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const chainId = await getChainId(client)\n * // 1\n */\nexport async function getChainId(client) {\n    const chainIdHex = await client.request({\n        method: 'eth_chainId',\n    }, { dedupe: true });\n    return hexToNumber(chainIdHex);\n}\n//# sourceMappingURL=getChainId.js.map"],"names":["async","getChainId","client","chainIdHex","request","method","dedupe","hexToNumber"],"mappings":"8DAsBOA,eAAeC,EAAWC,GAC7B,MAAMC,QAAmBD,EAAOE,QAAQ,CACpCC,OAAQ,eACT,CAAEC,QAAQ,IACb,OAAOC,EAAYJ,EACvB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getCode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getCode.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getCode.js"],"sourcesContent":["import { numberToHex, } from '../../utils/encoding/toHex.js';\n/**\n * Retrieves the bytecode at an address.\n *\n * - Docs: https://viem.sh/docs/contract/getCode\n * - JSON-RPC Methods: [`eth_getCode`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getcode)\n *\n * @param client - Client to use\n * @param parameters - {@link GetCodeParameters}\n * @returns The contract's bytecode. {@link GetCodeReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getCode } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const code = await getCode(client, {\n *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n * })\n */\nexport async function getCode(client, { address, blockNumber, blockTag = 'latest' }) {\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    const hex = await client.request({\n        method: 'eth_getCode',\n        params: [address, blockNumberHex || blockTag],\n    }, { dedupe: Boolean(blockNumberHex) });\n    if (hex === '0x')\n        return undefined;\n    return hex;\n}\n//# sourceMappingURL=getCode.js.map"],"names":["async","getCode","client","address","blockNumber","blockTag","blockNumberHex","undefined","numberToHex","hex","request","method","params","dedupe","Boolean"],"mappings":"4DAwBOA,eAAeC,EAAQC,GAAQC,QAAEA,EAAOC,YAAEA,EAAWC,SAAEA,EAAW,WACrE,MAAMC,OAAiCC,IAAhBH,EAA4BI,EAAYJ,QAAeG,EACxEE,QAAYP,EAAOQ,QAAQ,CAC7BC,OAAQ,cACRC,OAAQ,CAACT,EAASG,GAAkBD,IACrC,CAAEQ,OAAQC,QAAQR,KACrB,GAAY,OAARG,EAEJ,OAAOA,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getContractEvents.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getContractEvents.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getContractEvents.js"],"sourcesContent":["import { getAbiItem, } from '../../utils/abi/getAbiItem.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { getLogs, } from './getLogs.js';\n/**\n * Returns a list of event logs emitted by a contract.\n *\n * - Docs: https://viem.sh/docs/contract/getContractEvents#getcontractevents\n * - JSON-RPC Methods: [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs)\n *\n * @param client - Client to use\n * @param parameters - {@link GetContractEventsParameters}\n * @returns A list of event logs. {@link GetContractEventsReturnType}\n *\n * @example\n * import { createClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getContractEvents } from 'viem/public'\n * import { wagmiAbi } from './abi'\n *\n * const client = createClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const logs = await getContractEvents(client, {\n *  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *  abi: wagmiAbi,\n *  eventName: 'Transfer'\n * })\n */\nexport async function getContractEvents(client, parameters) {\n    const { abi, address, args, blockHash, eventName, fromBlock, toBlock, strict, } = parameters;\n    const event = eventName\n        ? getAbiItem({ abi, name: eventName })\n        : undefined;\n    const events = !event\n        ? abi.filter((x) => x.type === 'event')\n        : undefined;\n    return getAction(client, getLogs, 'getLogs')({\n        address,\n        args,\n        blockHash,\n        event,\n        events,\n        fromBlock,\n        toBlock,\n        strict,\n    });\n}\n//# sourceMappingURL=getContractEvents.js.map"],"names":["async","getContractEvents","client","parameters","abi","address","args","blockHash","eventName","fromBlock","toBlock","strict","event","getAbiItem","name","undefined","events","filter","x","type","getAction","getLogs"],"mappings":"uJA6BOA,eAAeC,EAAkBC,EAAQC,GAC5C,MAAMC,IAAEA,EAAGC,QAAEA,EAAOC,KAAEA,EAAIC,UAAEA,EAASC,UAAEA,EAASC,UAAEA,EAASC,QAAEA,EAAOC,OAAEA,GAAYR,EAC5ES,EAAQJ,EACRK,EAAW,CAAET,MAAKU,KAAMN,SACxBO,EACAC,EAAUJ,OAEVG,EADAX,EAAIa,OAAQC,GAAiB,UAAXA,EAAEC,MAE1B,OAAOC,EAAUlB,EAAQmB,EAAS,UAA3BD,CAAsC,CACzCf,UACAC,OACAC,YACAK,QACAI,SACAP,YACAC,UACAC,UAER","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getEip712Domain.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEip712Domain.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getEip712Domain.js"],"sourcesContent":["import { Eip712DomainNotFoundError, } from '../../errors/eip712.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { readContract, } from './readContract.js';\n/**\n * Reads the EIP-712 domain from a contract, based on the ERC-5267 specification.\n *\n * @param client - A {@link Client} instance.\n * @param parameters - The parameters of the action. {@link GetEip712DomainParameters}\n * @returns The EIP-712 domain, fields, and extensions. {@link GetEip712DomainReturnType}\n *\n * @example\n * ```ts\n * import { createPublicClient, http, getEip712Domain } from 'viem'\n * import { mainnet } from 'viem/chains'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n *\n * const domain = await getEip712Domain(client, {\n *   address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',\n * })\n * // {\n * //   domain: {\n * //     name: 'ExampleContract',\n * //     version: '1',\n * //     chainId: 1,\n * //     verifyingContract: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',\n * //   },\n * //   fields: '0x0f',\n * //   extensions: [],\n * // }\n * ```\n */\nexport async function getEip712Domain(client, parameters) {\n    const { address, factory, factoryData } = parameters;\n    try {\n        const [fields, name, version, chainId, verifyingContract, salt, extensions,] = await getAction(client, readContract, 'readContract')({\n            abi,\n            address,\n            functionName: 'eip712Domain',\n            factory,\n            factoryData,\n        });\n        return {\n            domain: {\n                name,\n                version,\n                chainId: Number(chainId),\n                verifyingContract,\n                salt,\n            },\n            extensions,\n            fields,\n        };\n    }\n    catch (e) {\n        const error = e;\n        if (error.name === 'ContractFunctionExecutionError' &&\n            error.cause.name === 'ContractFunctionZeroDataError') {\n            throw new Eip712DomainNotFoundError({ address });\n        }\n        throw error;\n    }\n}\nconst abi = [\n    {\n        inputs: [],\n        name: 'eip712Domain',\n        outputs: [\n            { name: 'fields', type: 'bytes1' },\n            { name: 'name', type: 'string' },\n            { name: 'version', type: 'string' },\n            { name: 'chainId', type: 'uint256' },\n            { name: 'verifyingContract', type: 'address' },\n            { name: 'salt', type: 'bytes32' },\n            { name: 'extensions', type: 'uint256[]' },\n        ],\n        stateMutability: 'view',\n        type: 'function',\n    },\n];\n//# sourceMappingURL=getEip712Domain.js.map"],"names":["async","getEip712Domain","client","parameters","address","factory","factoryData","fields","name","version","chainId","verifyingContract","salt","extensions","getAction","readContract","abi","functionName","domain","Number","e","error","cause","Eip712DomainNotFoundError","inputs","outputs","type","stateMutability"],"mappings":"yKAmCOA,eAAeC,EAAgBC,EAAQC,GAC1C,MAAMC,QAAEA,EAAOC,QAAEA,EAAOC,YAAEA,GAAgBH,EAC1C,IACI,MAAOI,EAAQC,EAAMC,EAASC,EAASC,EAAmBC,EAAMC,SAAqBC,EAAUZ,EAAQa,EAAc,eAAhCD,CAAgD,CACjIE,MACAZ,UACAa,aAAc,eACdZ,UACAC,gBAEJ,MAAO,CACHY,OAAQ,CACJV,OACAC,UACAC,QAASS,OAAOT,GAChBC,oBACAC,QAEJC,aACAN,SAER,CACA,MAAOa,GACH,MAAMC,EAAQD,EACd,GAAmB,mCAAfC,EAAMb,MACe,kCAArBa,EAAMC,MAAMd,KACZ,MAAM,IAAIe,EAA0B,CAAEnB,YAE1C,MAAMiB,CACV,CACJ,CACA,MAAML,EAAM,CACR,CACIQ,OAAQ,GACRhB,KAAM,eACNiB,QAAS,CACL,CAAEjB,KAAM,SAAUkB,KAAM,UACxB,CAAElB,KAAM,OAAQkB,KAAM,UACtB,CAAElB,KAAM,UAAWkB,KAAM,UACzB,CAAElB,KAAM,UAAWkB,KAAM,WACzB,CAAElB,KAAM,oBAAqBkB,KAAM,WACnC,CAAElB,KAAM,OAAQkB,KAAM,WACtB,CAAElB,KAAM,aAAckB,KAAM,cAEhCC,gBAAiB,OACjBD,KAAM","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getFeeHistory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getFeeHistory.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getFeeHistory.js"],"sourcesContent":["import { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { formatFeeHistory, } from '../../utils/formatters/feeHistory.js';\n/**\n * Returns a collection of historical gas information.\n *\n * - Docs: https://viem.sh/docs/actions/public/getFeeHistory\n * - JSON-RPC Methods: [`eth_feeHistory`](https://docs.alchemy.com/reference/eth-feehistory)\n *\n * @param client - Client to use\n * @param parameters - {@link GetFeeHistoryParameters}\n * @returns The gas estimate (in wei). {@link GetFeeHistoryReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getFeeHistory } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const feeHistory = await getFeeHistory(client, {\n *   blockCount: 4,\n *   rewardPercentiles: [25, 75],\n * })\n */\nexport async function getFeeHistory(client, { blockCount, blockNumber, blockTag = 'latest', rewardPercentiles, }) {\n    const blockNumberHex = typeof blockNumber === 'bigint' ? numberToHex(blockNumber) : undefined;\n    const feeHistory = await client.request({\n        method: 'eth_feeHistory',\n        params: [\n            numberToHex(blockCount),\n            blockNumberHex || blockTag,\n            rewardPercentiles,\n        ],\n    }, { dedupe: Boolean(blockNumberHex) });\n    return formatFeeHistory(feeHistory);\n}\n//# sourceMappingURL=getFeeHistory.js.map"],"names":["async","getFeeHistory","client","blockCount","blockNumber","blockTag","rewardPercentiles","blockNumberHex","numberToHex","undefined","feeHistory","request","method","params","dedupe","Boolean","formatFeeHistory"],"mappings":"oIA0BOA,eAAeC,EAAcC,GAAQC,WAAEA,EAAUC,YAAEA,EAAWC,SAAEA,EAAW,SAAQC,kBAAEA,IACxF,MAAMC,EAAwC,iBAAhBH,EAA2BI,EAAYJ,QAAeK,EAC9EC,QAAmBR,EAAOS,QAAQ,CACpCC,OAAQ,iBACRC,OAAQ,CACJL,EAAYL,GACZI,GAAkBF,EAClBC,IAEL,CAAEQ,OAAQC,QAAQR,KACrB,OAAOS,EAAiBN,EAC5B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getFilterChanges.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getFilterChanges.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getFilterChanges.js"],"sourcesContent":["import { parseEventLogs } from '../../utils/abi/parseEventLogs.js';\nimport { formatLog, } from '../../utils/formatters/log.js';\n/**\n * Returns a list of logs or hashes based on a [Filter](/docs/glossary/terms#filter) since the last time it was called.\n *\n * - Docs: https://viem.sh/docs/actions/public/getFilterChanges\n * - JSON-RPC Methods: [`eth_getFilterChanges`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterchanges)\n *\n * A Filter can be created from the following actions:\n *\n * - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)\n * - [`createContractEventFilter`](https://viem.sh/docs/contract/createContractEventFilter)\n * - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)\n * - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)\n *\n * Depending on the type of filter, the return value will be different:\n *\n * - If the filter was created with `createContractEventFilter` or `createEventFilter`, it returns a list of logs.\n * - If the filter was created with `createPendingTransactionFilter`, it returns a list of transaction hashes.\n * - If the filter was created with `createBlockFilter`, it returns a list of block hashes.\n *\n * @param client - Client to use\n * @param parameters - {@link GetFilterChangesParameters}\n * @returns Logs or hashes. {@link GetFilterChangesReturnType}\n *\n * @example\n * // Blocks\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createBlockFilter, getFilterChanges } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createBlockFilter(client)\n * const hashes = await getFilterChanges(client, { filter })\n *\n * @example\n * // Contract Events\n * import { createPublicClient, http, parseAbi } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createContractEventFilter, getFilterChanges } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createContractEventFilter(client, {\n *   address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',\n *   abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),\n *   eventName: 'Transfer',\n * })\n * const logs = await getFilterChanges(client, { filter })\n *\n * @example\n * // Raw Events\n * import { createPublicClient, http, parseAbiItem } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createEventFilter, getFilterChanges } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createEventFilter(client, {\n *   address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',\n *   event: parseAbiItem('event Transfer(address indexed, address indexed, uint256)'),\n * })\n * const logs = await getFilterChanges(client, { filter })\n *\n * @example\n * // Transactions\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createPendingTransactionFilter, getFilterChanges } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createPendingTransactionFilter(client)\n * const hashes = await getFilterChanges(client, { filter })\n */\nexport async function getFilterChanges(_client, { filter, }) {\n    const strict = 'strict' in filter && filter.strict;\n    const logs = await filter.request({\n        method: 'eth_getFilterChanges',\n        params: [filter.id],\n    });\n    if (typeof logs[0] === 'string')\n        return logs;\n    const formattedLogs = logs.map((log) => formatLog(log));\n    if (!('abi' in filter) || !filter.abi)\n        return formattedLogs;\n    return parseEventLogs({\n        abi: filter.abi,\n        logs: formattedLogs,\n        strict,\n    });\n}\n//# sourceMappingURL=getFilterChanges.js.map"],"names":["async","getFilterChanges","_client","filter","strict","logs","request","method","params","id","formattedLogs","map","log","formatLog","abi","parseEventLogs"],"mappings":"6HAoFOA,eAAeC,EAAiBC,GAASC,OAAEA,IAC9C,MAAMC,EAAS,WAAYD,GAAUA,EAAOC,OACtCC,QAAaF,EAAOG,QAAQ,CAC9BC,OAAQ,uBACRC,OAAQ,CAACL,EAAOM,MAEpB,GAAuB,iBAAZJ,EAAK,GACZ,OAAOA,EACX,MAAMK,EAAgBL,EAAKM,IAAKC,GAAQC,EAAUD,IAClD,MAAM,QAAST,GAAYA,EAAOW,IAE3BC,EAAe,CAClBD,IAAKX,EAAOW,IACZT,KAAMK,EACNN,WAJOM,CAMf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getFilterLogs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getFilterLogs.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getFilterLogs.js"],"sourcesContent":["import { parseEventLogs } from '../../utils/abi/parseEventLogs.js';\nimport { formatLog, } from '../../utils/formatters/log.js';\n/**\n * Returns a list of event logs since the filter was created.\n *\n * - Docs: https://viem.sh/docs/actions/public/getFilterLogs\n * - JSON-RPC Methods: [`eth_getFilterLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterlogs)\n *\n * `getFilterLogs` is only compatible with **event filters**.\n *\n * @param client - Client to use\n * @param parameters - {@link GetFilterLogsParameters}\n * @returns A list of event logs. {@link GetFilterLogsReturnType}\n *\n * @example\n * import { createPublicClient, http, parseAbiItem } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createEventFilter, getFilterLogs } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createEventFilter(client, {\n *   address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',\n *   event: parseAbiItem('event Transfer(address indexed, address indexed, uint256)'),\n * })\n * const logs = await getFilterLogs(client, { filter })\n */\nexport async function getFilterLogs(_client, { filter, }) {\n    const strict = filter.strict ?? false;\n    const logs = await filter.request({\n        method: 'eth_getFilterLogs',\n        params: [filter.id],\n    });\n    const formattedLogs = logs.map((log) => formatLog(log));\n    if (!filter.abi)\n        return formattedLogs;\n    return parseEventLogs({\n        abi: filter.abi,\n        logs: formattedLogs,\n        strict,\n    });\n}\n//# sourceMappingURL=getFilterLogs.js.map"],"names":["async","getFilterLogs","_client","filter","strict","formattedLogs","request","method","params","id","map","log","formatLog","abi","parseEventLogs","logs"],"mappings":"6HA6BOA,eAAeC,EAAcC,GAASC,OAAEA,IAC3C,MAAMC,EAASD,EAAOC,SAAU,EAK1BC,SAJaF,EAAOG,QAAQ,CAC9BC,OAAQ,oBACRC,OAAQ,CAACL,EAAOM,OAEOC,IAAKC,GAAQC,EAAUD,IAClD,OAAKR,EAAOU,IAELC,EAAe,CAClBD,IAAKV,EAAOU,IACZE,KAAMV,EACND,WAJOC,CAMf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getGasPrice.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getGasPrice.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getGasPrice.js"],"sourcesContent":["/**\n * Returns the current price of gas (in wei).\n *\n * - Docs: https://viem.sh/docs/actions/public/getGasPrice\n * - JSON-RPC Methods: [`eth_gasPrice`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gasprice)\n *\n * @param client - Client to use\n * @returns The gas price (in wei). {@link GetGasPriceReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getGasPrice } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const gasPrice = await getGasPrice(client)\n */\nexport async function getGasPrice(client) {\n    const gasPrice = await client.request({\n        method: 'eth_gasPrice',\n    });\n    return BigInt(gasPrice);\n}\n//# sourceMappingURL=getGasPrice.js.map"],"names":["async","getGasPrice","client","gasPrice","request","method","BigInt"],"mappings":"AAoBOA,eAAeC,EAAYC,GAC9B,MAAMC,QAAiBD,EAAOE,QAAQ,CAClCC,OAAQ,iBAEZ,OAAOC,OAAOH,EAClB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getLogs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getLogs.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getLogs.js"],"sourcesContent":["import { encodeEventTopics, } from '../../utils/abi/encodeEventTopics.js';\nimport { parseEventLogs } from '../../utils/abi/parseEventLogs.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { formatLog, } from '../../utils/formatters/log.js';\n/**\n * Returns a list of event logs matching the provided parameters.\n *\n * - Docs: https://viem.sh/docs/actions/public/getLogs\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/logs_event-logs\n * - JSON-RPC Methods: [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs)\n *\n * @param client - Client to use\n * @param parameters - {@link GetLogsParameters}\n * @returns A list of event logs. {@link GetLogsReturnType}\n *\n * @example\n * import { createPublicClient, http, parseAbiItem } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getLogs } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const logs = await getLogs(client)\n */\nexport async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_, } = {}) {\n    const strict = strict_ ?? false;\n    const events = events_ ?? (event ? [event] : undefined);\n    let topics = [];\n    if (events) {\n        const encoded = events.flatMap((event) => encodeEventTopics({\n            abi: [event],\n            eventName: event.name,\n            args: events_ ? undefined : args,\n        }));\n        // TODO: Clean up type casting\n        topics = [encoded];\n        if (event)\n            topics = topics[0];\n    }\n    let logs;\n    if (blockHash) {\n        logs = await client.request({\n            method: 'eth_getLogs',\n            params: [{ address, topics, blockHash }],\n        });\n    }\n    else {\n        logs = await client.request({\n            method: 'eth_getLogs',\n            params: [\n                {\n                    address,\n                    topics,\n                    fromBlock: typeof fromBlock === 'bigint' ? numberToHex(fromBlock) : fromBlock,\n                    toBlock: typeof toBlock === 'bigint' ? numberToHex(toBlock) : toBlock,\n                },\n            ],\n        });\n    }\n    const formattedLogs = logs.map((log) => formatLog(log));\n    if (!events)\n        return formattedLogs;\n    return parseEventLogs({\n        abi: events,\n        args: args,\n        logs: formattedLogs,\n        strict,\n    });\n}\n//# sourceMappingURL=getLogs.js.map"],"names":["async","getLogs","client","address","blockHash","fromBlock","toBlock","event","events","events_","args","strict","strict_","undefined","logs","topics","encoded","flatMap","encodeEventTopics","abi","eventName","name","request","method","params","numberToHex","formattedLogs","map","log","formatLog","parseEventLogs"],"mappings":"kQA0BOA,eAAeC,EAAQC,GAAQC,QAAEA,EAAOC,UAAEA,EAASC,UAAEA,EAASC,QAAEA,EAAOC,MAAEA,EAAOC,OAAQC,EAAOC,KAAEA,EAAMC,OAAQC,GAAa,CAAA,GAC/H,MAAMD,EAASC,IAAW,EACpBJ,EAASC,IAAYF,EAAQ,CAACA,QAASM,GAC7C,IAYIC,EAZAC,EAAS,GACb,GAAIP,EAAQ,CACR,MAAMQ,EAAUR,EAAOS,QAASV,GAAUW,EAAkB,CACxDC,IAAK,CAACZ,GACNa,UAAWb,EAAMc,KACjBX,KAAMD,OAAUI,EAAYH,KAGhCK,EAAS,CAACC,GACNT,IACAQ,EAASA,EAAO,GACxB,CAGID,EADAV,QACaF,EAAOoB,QAAQ,CACxBC,OAAQ,cACRC,OAAQ,CAAC,CAAErB,UAASY,SAAQX,sBAInBF,EAAOoB,QAAQ,CACxBC,OAAQ,cACRC,OAAQ,CACJ,CACIrB,UACAY,SACAV,UAAgC,iBAAdA,EAAyBoB,EAAYpB,GAAaA,EACpEC,QAA4B,iBAAZA,EAAuBmB,EAAYnB,GAAWA,MAK9E,MAAMoB,EAAgBZ,EAAKa,IAAKC,GAAQC,EAAUD,IAClD,OAAKpB,EAEEsB,EAAe,CAClBX,IAAKX,EACLE,KAAMA,EACNI,KAAMY,EACNf,WALOe,CAOf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getProof.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getProof.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getProof.js"],"sourcesContent":["import { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { formatProof, } from '../../utils/formatters/proof.js';\n/**\n * Returns the account and storage values of the specified account including the Merkle-proof.\n *\n * - Docs: https://viem.sh/docs/actions/public/getProof\n * - JSON-RPC Methods:\n *   - Calls [`eth_getProof`](https://eips.ethereum.org/EIPS/eip-1186)\n *\n * @param client - Client to use\n * @param parameters - {@link GetProofParameters}\n * @returns Proof data. {@link GetProofReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getProof } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const block = await getProof(client, {\n *  address: '0x...',\n *  storageKeys: ['0x...'],\n * })\n */\nexport async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys, }) {\n    const blockTag = blockTag_ ?? 'latest';\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    const proof = await client.request({\n        method: 'eth_getProof',\n        params: [address, storageKeys, blockNumberHex || blockTag],\n    });\n    return formatProof(proof);\n}\n//# sourceMappingURL=getProof.js.map"],"names":["async","getProof","client","address","blockNumber","blockTag","blockTag_","storageKeys","blockNumberHex","undefined","numberToHex","proof","request","method","params","formatProof"],"mappings":"0HA2BOA,eAAeC,EAASC,GAAQC,QAAEA,EAAOC,YAAEA,EAAaC,SAAUC,EAASC,YAAEA,IAChF,MAAMF,EAAWC,GAAa,SACxBE,OAAiCC,IAAhBL,EAA4BM,EAAYN,QAAeK,EACxEE,QAAcT,EAAOU,QAAQ,CAC/BC,OAAQ,eACRC,OAAQ,CAACX,EAASI,EAAaC,GAAkBH,KAErD,OAAOU,EAAYJ,EACvB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getStorageAt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getStorageAt.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getStorageAt.js"],"sourcesContent":["import { numberToHex, } from '../../utils/encoding/toHex.js';\n/**\n * Returns the value from a storage slot at a given address.\n *\n * - Docs: https://viem.sh/docs/contract/getStorageAt\n * - JSON-RPC Methods: [`eth_getStorageAt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getstorageat)\n *\n * @param client - Client to use\n * @param parameters - {@link GetStorageAtParameters}\n * @returns The value of the storage slot. {@link GetStorageAtReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getStorageAt } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const code = await getStorageAt(client, {\n *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *   slot: toHex(0),\n * })\n */\nexport async function getStorageAt(client, { address, blockNumber, blockTag = 'latest', slot }) {\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    const data = await client.request({\n        method: 'eth_getStorageAt',\n        params: [address, slot, blockNumberHex || blockTag],\n    });\n    return data;\n}\n//# sourceMappingURL=getStorageAt.js.map"],"names":["async","getStorageAt","client","address","blockNumber","blockTag","slot","blockNumberHex","undefined","numberToHex","request","method","params"],"mappings":"4DAyBOA,eAAeC,EAAaC,GAAQC,QAAEA,EAAOC,YAAEA,EAAWC,SAAEA,EAAW,SAAQC,KAAEA,IACpF,MAAMC,OAAiCC,IAAhBJ,EAA4BK,EAAYL,QAAeI,EAK9E,aAJmBN,EAAOQ,QAAQ,CAC9BC,OAAQ,mBACRC,OAAQ,CAACT,EAASG,EAAMC,GAAkBF,IAGlD","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getTransaction.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getTransaction.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getTransaction.js"],"sourcesContent":["import { TransactionNotFoundError, } from '../../errors/transaction.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { formatTransaction, } from '../../utils/formatters/transaction.js';\n/**\n * Returns information about a [Transaction](https://viem.sh/docs/glossary/terms#transaction) given a hash or block identifier.\n *\n * - Docs: https://viem.sh/docs/actions/public/getTransaction\n * - Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_fetching-transactions\n * - JSON-RPC Methods: [`eth_getTransactionByHash`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionByHash)\n *\n * @param client - Client to use\n * @param parameters - {@link GetTransactionParameters}\n * @returns The transaction information. {@link GetTransactionReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getTransaction } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const transaction = await getTransaction(client, {\n *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',\n * })\n */\nexport async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash, index, }) {\n    const blockTag = blockTag_ || 'latest';\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    let transaction = null;\n    if (hash) {\n        transaction = await client.request({\n            method: 'eth_getTransactionByHash',\n            params: [hash],\n        }, { dedupe: true });\n    }\n    else if (blockHash) {\n        transaction = await client.request({\n            method: 'eth_getTransactionByBlockHashAndIndex',\n            params: [blockHash, numberToHex(index)],\n        }, { dedupe: true });\n    }\n    else if (blockNumberHex || blockTag) {\n        transaction = await client.request({\n            method: 'eth_getTransactionByBlockNumberAndIndex',\n            params: [blockNumberHex || blockTag, numberToHex(index)],\n        }, { dedupe: Boolean(blockNumberHex) });\n    }\n    if (!transaction)\n        throw new TransactionNotFoundError({\n            blockHash,\n            blockNumber,\n            blockTag,\n            hash,\n            index,\n        });\n    const format = client.chain?.formatters?.transaction?.format || formatTransaction;\n    return format(transaction);\n}\n//# sourceMappingURL=getTransaction.js.map"],"names":["async","getTransaction","client","blockHash","blockNumber","blockTag","blockTag_","hash","index","blockNumberHex","undefined","numberToHex","transaction","request","method","params","dedupe","Boolean","TransactionNotFoundError","chain","formatters","format","formatTransaction"],"mappings":"6MA2BOA,eAAeC,EAAeC,GAAQC,UAAEA,EAASC,YAAEA,EAAaC,SAAUC,EAASC,KAAEA,EAAIC,MAAEA,IAC9F,MAAMH,EAAWC,GAAa,SACxBG,OAAiCC,IAAhBN,EAA4BO,EAAYP,QAAeM,EAC9E,IAAIE,EAAc,KAmBlB,GAjBIA,EADAL,QACoBL,EAAOW,QAAQ,CAC/BC,OAAQ,2BACRC,OAAQ,CAACR,IACV,CAAES,QAAQ,IAERb,QACeD,EAAOW,QAAQ,CAC/BC,OAAQ,wCACRC,OAAQ,CAACZ,EAAWQ,EAAYH,KACjC,CAAEQ,QAAQ,UAGOd,EAAOW,QAAQ,CAC/BC,OAAQ,0CACRC,OAAQ,CAACN,GAAkBJ,EAAUM,EAAYH,KAClD,CAAEQ,OAAQC,QAAQR,MAEpBG,EACD,MAAM,IAAIM,EAAyB,CAC/Bf,YACAC,cACAC,WACAE,OACAC,UAGR,OADeN,EAAOiB,OAAOC,YAAYR,aAAaS,QAAUC,GAClDV,EAClB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getTransactionConfirmations.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getTransactionConfirmations.js"],"sourcesContent":["import { getAction } from '../../utils/getAction.js';\nimport { getBlockNumber, } from './getBlockNumber.js';\nimport { getTransaction, } from './getTransaction.js';\n/**\n * Returns the number of blocks passed (confirmations) since the transaction was processed on a block.\n *\n * - Docs: https://viem.sh/docs/actions/public/getTransactionConfirmations\n * - Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_fetching-transactions\n * - JSON-RPC Methods: [`eth_getTransactionConfirmations`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionConfirmations)\n *\n * @param client - Client to use\n * @param parameters - {@link GetTransactionConfirmationsParameters}\n * @returns The number of blocks passed since the transaction was processed. If confirmations is 0, then the Transaction has not been confirmed & processed yet. {@link GetTransactionConfirmationsReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getTransactionConfirmations } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const confirmations = await getTransactionConfirmations(client, {\n *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',\n * })\n */\nexport async function getTransactionConfirmations(client, { hash, transactionReceipt }) {\n    const [blockNumber, transaction] = await Promise.all([\n        getAction(client, getBlockNumber, 'getBlockNumber')({}),\n        hash\n            ? getAction(client, getTransaction, 'getTransaction')({ hash })\n            : undefined,\n    ]);\n    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;\n    if (!transactionBlockNumber)\n        return 0n;\n    return blockNumber - transactionBlockNumber + 1n;\n}\n//# sourceMappingURL=getTransactionConfirmations.js.map"],"names":["async","getTransactionConfirmations","client","hash","transactionReceipt","blockNumber","transaction","Promise","all","getAction","getBlockNumber","getTransaction","undefined","transactionBlockNumber"],"mappings":"+JA2BOA,eAAeC,EAA4BC,GAAQC,KAAEA,EAAIC,mBAAEA,IAC9D,MAAOC,EAAaC,SAAqBC,QAAQC,IAAI,CACjDC,EAAUP,EAAQQ,EAAgB,iBAAlCD,CAAoD,CAAA,GACpDN,EACMM,EAAUP,EAAQS,EAAgB,iBAAlCF,CAAoD,CAAEN,cACtDS,IAEJC,EAAyBT,GAAoBC,aAAeC,GAAaD,YAC/E,OAAKQ,EAEER,EAAcQ,EAAyB,GADnC,EAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getTransactionCount.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getTransactionCount.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getTransactionCount.js"],"sourcesContent":["import { hexToNumber, } from '../../utils/encoding/fromHex.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\n/**\n * Returns the number of [Transactions](https://viem.sh/docs/glossary/terms#transaction) an Account has sent.\n *\n * - Docs: https://viem.sh/docs/actions/public/getTransactionCount\n * - JSON-RPC Methods: [`eth_getTransactionCount`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactioncount)\n *\n * @param client - Client to use\n * @param parameters - {@link GetTransactionCountParameters}\n * @returns The number of transactions an account has sent. {@link GetTransactionCountReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getTransactionCount } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const transactionCount = await getTransactionCount(client, {\n *   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',\n * })\n */\nexport async function getTransactionCount(client, { address, blockTag = 'latest', blockNumber }) {\n    const count = await client.request({\n        method: 'eth_getTransactionCount',\n        params: [\n            address,\n            typeof blockNumber === 'bigint' ? numberToHex(blockNumber) : blockTag,\n        ],\n    }, {\n        dedupe: Boolean(blockNumber),\n    });\n    return hexToNumber(count);\n}\n//# sourceMappingURL=getTransactionCount.js.map"],"names":["async","getTransactionCount","client","address","blockTag","blockNumber","count","request","method","params","numberToHex","dedupe","Boolean","hexToNumber"],"mappings":"0HAyBOA,eAAeC,EAAoBC,GAAQC,QAAEA,EAAOC,SAAEA,EAAW,SAAQC,YAAEA,IAC9E,MAAMC,QAAcJ,EAAOK,QAAQ,CAC/BC,OAAQ,0BACRC,OAAQ,CACJN,EACuB,iBAAhBE,EAA2BK,EAAYL,GAAeD,IAElE,CACCO,OAAQC,QAAQP,KAEpB,OAAOQ,EAAYP,EACvB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/getTransactionReceipt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getTransactionReceipt.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/getTransactionReceipt.js"],"sourcesContent":["import { TransactionReceiptNotFoundError, } from '../../errors/transaction.js';\nimport { formatTransactionReceipt, } from '../../utils/formatters/transactionReceipt.js';\n/**\n * Returns the [Transaction Receipt](https://viem.sh/docs/glossary/terms#transaction-receipt) given a [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash.\n *\n * - Docs: https://viem.sh/docs/actions/public/getTransactionReceipt\n * - Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_fetching-transactions\n * - JSON-RPC Methods: [`eth_getTransactionReceipt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt)\n *\n * @param client - Client to use\n * @param parameters - {@link GetTransactionReceiptParameters}\n * @returns The transaction receipt. {@link GetTransactionReceiptReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getTransactionReceipt } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const transactionReceipt = await getTransactionReceipt(client, {\n *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',\n * })\n */\nexport async function getTransactionReceipt(client, { hash }) {\n    const receipt = await client.request({\n        method: 'eth_getTransactionReceipt',\n        params: [hash],\n    }, { dedupe: true });\n    if (!receipt)\n        throw new TransactionReceiptNotFoundError({ hash });\n    const format = client.chain?.formatters?.transactionReceipt?.format ||\n        formatTransactionReceipt;\n    return format(receipt);\n}\n//# sourceMappingURL=getTransactionReceipt.js.map"],"names":["async","getTransactionReceipt","client","hash","receipt","request","method","params","dedupe","TransactionReceiptNotFoundError","chain","formatters","transactionReceipt","format","formatTransactionReceipt"],"mappings":"sKA0BOA,eAAeC,EAAsBC,GAAQC,KAAEA,IAClD,MAAMC,QAAgBF,EAAOG,QAAQ,CACjCC,OAAQ,4BACRC,OAAQ,CAACJ,IACV,CAAEK,QAAQ,IACb,IAAKJ,EACD,MAAM,IAAIK,EAAgC,CAAEN,SAGhD,OAFeD,EAAOQ,OAAOC,YAAYC,oBAAoBC,QACzDC,GACUV,EAClB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/multicall.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"multicall.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/multicall.js"],"sourcesContent":["import { multicall3Abi } from '../../constants/abis.js';\nimport { multicall3Bytecode } from '../../constants/contracts.js';\nimport { AbiDecodingZeroDataError } from '../../errors/abi.js';\nimport { BaseError } from '../../errors/base.js';\nimport { RawContractError } from '../../errors/contract.js';\nimport { decodeFunctionResult, } from '../../utils/abi/decodeFunctionResult.js';\nimport { encodeFunctionData, } from '../../utils/abi/encodeFunctionData.js';\nimport { getChainContractAddress, } from '../../utils/chain/getChainContractAddress.js';\nimport { getContractError, } from '../../utils/errors/getContractError.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { readContract } from './readContract.js';\n/**\n * Similar to [`readContract`](https://viem.sh/docs/contract/readContract), but batches up multiple functions on a contract in a single RPC call via the [`multicall3` contract](https://github.com/mds1/multicall).\n *\n * - Docs: https://viem.sh/docs/contract/multicall\n *\n * @param client - Client to use\n * @param parameters - {@link MulticallParameters}\n * @returns An array of results with accompanying status. {@link MulticallReturnType}\n *\n * @example\n * import { createPublicClient, http, parseAbi } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { multicall } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const abi = parseAbi([\n *   'function balanceOf(address) view returns (uint256)',\n *   'function totalSupply() view returns (uint256)',\n * ])\n * const results = await multicall(client, {\n *   contracts: [\n *     {\n *       address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *       abi,\n *       functionName: 'balanceOf',\n *       args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],\n *     },\n *     {\n *       address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *       abi,\n *       functionName: 'totalSupply',\n *     },\n *   ],\n * })\n * // [{ result: 424122n, status: 'success' }, { result: 1000000n, status: 'success' }]\n */\nexport async function multicall(client, parameters) {\n    const { account, authorizationList, allowFailure = true, blockNumber, blockOverrides, blockTag, stateOverride, } = parameters;\n    const contracts = parameters.contracts;\n    const { batchSize = parameters.batchSize ?? 1024, deployless = parameters.deployless ?? false, } = typeof client.batch?.multicall === 'object' ? client.batch.multicall : {};\n    const multicallAddress = (() => {\n        if (parameters.multicallAddress)\n            return parameters.multicallAddress;\n        if (deployless)\n            return null;\n        if (client.chain) {\n            return getChainContractAddress({\n                blockNumber,\n                chain: client.chain,\n                contract: 'multicall3',\n            });\n        }\n        throw new Error('client chain not configured. multicallAddress is required.');\n    })();\n    const chunkedCalls = [[]];\n    let currentChunk = 0;\n    let currentChunkSize = 0;\n    for (let i = 0; i < contracts.length; i++) {\n        const { abi, address, args, functionName } = contracts[i];\n        try {\n            const callData = encodeFunctionData({ abi, args, functionName });\n            currentChunkSize += (callData.length - 2) / 2;\n            // Check to see if we need to create a new chunk.\n            if (\n            // Check if batching is enabled.\n            batchSize > 0 &&\n                // Check if the current size of the batch exceeds the size limit.\n                currentChunkSize > batchSize &&\n                // Check if the current chunk is not already empty.\n                chunkedCalls[currentChunk].length > 0) {\n                currentChunk++;\n                currentChunkSize = (callData.length - 2) / 2;\n                chunkedCalls[currentChunk] = [];\n            }\n            chunkedCalls[currentChunk] = [\n                ...chunkedCalls[currentChunk],\n                {\n                    allowFailure: true,\n                    callData,\n                    target: address,\n                },\n            ];\n        }\n        catch (err) {\n            const error = getContractError(err, {\n                abi,\n                address,\n                args,\n                docsPath: '/docs/contract/multicall',\n                functionName,\n                sender: account,\n            });\n            if (!allowFailure)\n                throw error;\n            chunkedCalls[currentChunk] = [\n                ...chunkedCalls[currentChunk],\n                {\n                    allowFailure: true,\n                    callData: '0x',\n                    target: address,\n                },\n            ];\n        }\n    }\n    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, 'readContract')({\n        ...(multicallAddress === null\n            ? { code: multicall3Bytecode }\n            : { address: multicallAddress }),\n        abi: multicall3Abi,\n        account,\n        args: [calls],\n        authorizationList,\n        blockNumber,\n        blockOverrides,\n        blockTag,\n        functionName: 'aggregate3',\n        stateOverride,\n    })));\n    const results = [];\n    for (let i = 0; i < aggregate3Results.length; i++) {\n        const result = aggregate3Results[i];\n        // If an error occurred in a `readContract` invocation (ie. network error),\n        // then append the failure reason to each contract result.\n        if (result.status === 'rejected') {\n            if (!allowFailure)\n                throw result.reason;\n            for (let j = 0; j < chunkedCalls[i].length; j++) {\n                results.push({\n                    status: 'failure',\n                    error: result.reason,\n                    result: undefined,\n                });\n            }\n            continue;\n        }\n        // If the `readContract` call was successful, then decode the results.\n        const aggregate3Result = result.value;\n        for (let j = 0; j < aggregate3Result.length; j++) {\n            // Extract the response from `readContract`\n            const { returnData, success } = aggregate3Result[j];\n            // Extract the request call data from the original call.\n            const { callData } = chunkedCalls[i][j];\n            // Extract the contract config for this call from the `contracts` argument\n            // for decoding.\n            const { abi, address, functionName, args } = contracts[results.length];\n            try {\n                if (callData === '0x')\n                    throw new AbiDecodingZeroDataError();\n                if (!success)\n                    throw new RawContractError({ data: returnData });\n                const result = decodeFunctionResult({\n                    abi,\n                    args,\n                    data: returnData,\n                    functionName,\n                });\n                results.push(allowFailure ? { result, status: 'success' } : result);\n            }\n            catch (err) {\n                const error = getContractError(err, {\n                    abi,\n                    address,\n                    args,\n                    docsPath: '/docs/contract/multicall',\n                    functionName,\n                });\n                if (!allowFailure)\n                    throw error;\n                results.push({ error, result: undefined, status: 'failure' });\n            }\n        }\n    }\n    if (results.length !== contracts.length)\n        throw new BaseError('multicall results mismatch');\n    return results;\n}\n//# sourceMappingURL=multicall.js.map"],"names":["async","multicall","client","parameters","account","authorizationList","allowFailure","blockNumber","blockOverrides","blockTag","stateOverride","contracts","batchSize","deployless","batch","multicallAddress","chain","getChainContractAddress","contract","Error","chunkedCalls","currentChunk","currentChunkSize","i","length","abi","address","args","functionName","callData","encodeFunctionData","target","err","error","getContractError","docsPath","sender","aggregate3Results","Promise","allSettled","map","calls","getAction","readContract","code","multicall3Bytecode","multicall3Abi","results","result","status","reason","j","push","undefined","aggregate3Result","value","returnData","success","AbiDecodingZeroDataError","RawContractError","data","decodeFunctionResult","BaseError"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/readContract.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"readContract.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/readContract.js"],"sourcesContent":["import { decodeFunctionResult, } from '../../utils/abi/decodeFunctionResult.js';\nimport { encodeFunctionData, } from '../../utils/abi/encodeFunctionData.js';\nimport { getContractError, } from '../../utils/errors/getContractError.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { call } from './call.js';\n/**\n * Calls a read-only function on a contract, and returns the response.\n *\n * - Docs: https://viem.sh/docs/contract/readContract\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts_reading-contracts\n *\n * A \"read-only\" function (constant function) on a Solidity contract is denoted by a `view` or `pure` keyword. They can only read the state of the contract, and cannot make any changes to it. Since read-only methods do not change the state of the contract, they do not require any gas to be executed, and can be called by any user without the need to pay for gas.\n *\n * Internally, uses a [Public Client](https://viem.sh/docs/clients/public) to call the [`call` action](https://viem.sh/docs/actions/public/call) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).\n *\n * @param client - Client to use\n * @param parameters - {@link ReadContractParameters}\n * @returns The response from the contract. Type is inferred. {@link ReadContractReturnType}\n *\n * @example\n * import { createPublicClient, http, parseAbi } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { readContract } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const result = await readContract(client, {\n *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *   abi: parseAbi(['function balanceOf(address) view returns (uint256)']),\n *   functionName: 'balanceOf',\n *   args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],\n * })\n * // 424122n\n */\nexport async function readContract(client, parameters) {\n    const { abi, address, args, functionName, ...rest } = parameters;\n    const calldata = encodeFunctionData({\n        abi,\n        args,\n        functionName,\n    });\n    try {\n        const { data } = await getAction(client, call, 'call')({\n            ...rest,\n            data: calldata,\n            to: address,\n        });\n        return decodeFunctionResult({\n            abi,\n            args,\n            functionName,\n            data: data || '0x',\n        });\n    }\n    catch (error) {\n        throw getContractError(error, {\n            abi,\n            address,\n            args,\n            docsPath: '/docs/contract/readContract',\n            functionName,\n        });\n    }\n}\n//# sourceMappingURL=readContract.js.map"],"names":["async","readContract","client","parameters","abi","address","args","functionName","rest","calldata","encodeFunctionData","data","getAction","call","to","decodeFunctionResult","error","getContractError","docsPath"],"mappings":"0TAoCOA,eAAeC,EAAaC,EAAQC,GACvC,MAAMC,IAAEA,EAAGC,QAAEA,EAAOC,KAAEA,EAAIC,aAAEA,KAAiBC,GAASL,EAChDM,EAAWC,EAAmB,CAChCN,MACAE,OACAC,iBAEJ,IACI,MAAMI,KAAEA,SAAeC,EAAUV,EAAQW,EAAM,OAAxBD,CAAgC,IAChDJ,EACHG,KAAMF,EACNK,GAAIT,IAER,OAAOU,EAAqB,CACxBX,MACAE,OACAC,eACAI,KAAMA,GAAQ,MAEtB,CACA,MAAOK,GACH,MAAMC,EAAiBD,EAAO,CAC1BZ,MACAC,UACAC,OACAY,SAAU,8BACVX,gBAER,CACJ","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/simulateBlocks.js

@@ -1,2 +0,0 @@
-import{toRpc as r}from"../../../../ox/_esm/core/BlockOverrides.js";import{parseAccount as t}from"../../accounts/utils/parseAccount.js";import{AbiDecodingZeroDataError as s}from"../../errors/abi.js";import{RawContractError as o}from"../../errors/contract.js";import{UnknownNodeError as a}from"../../errors/node.js";import{decodeFunctionResult as e}from"../../utils/abi/decodeFunctionResult.js";import{encodeFunctionData as i}from"../../utils/abi/encodeFunctionData.js";import{concat as c}from"../../utils/data/concat.js";import{numberToHex as n}from"../../utils/encoding/toHex.js";import{getContractError as l}from"../../utils/errors/getContractError.js";import{getNodeError as u}from"../../utils/errors/getNodeError.js";import{formatBlock as m}from"../../utils/formatters/block.js";import{formatLog as f}from"../../utils/formatters/log.js";import{formatTransactionRequest as d}from"../../utils/formatters/transactionRequest.js";import{serializeStateOverride as p}from"../../utils/stateOverride.js";import{assertRequest as b}from"../../utils/transaction/assertRequest.js";async function j(j,v){const{blockNumber:g,blockTag:k=j.experimental_blockTag??"latest",blocks:x,returnFullTransactions:O,traceTransfers:h,validation:w}=v;try{const a=[];for(const s of x){const o=s.blockOverrides?r(s.blockOverrides):void 0,e=s.calls.map(r=>{const s=r,o=s.account?t(s.account):void 0,a=s.abi?i(s):s.data,e={...s,data:s.dataSuffix?c([a||"0x",s.dataSuffix]):a,from:s.from??o?.address};return b(e),d(e)}),n=s.stateOverrides?p(s.stateOverrides):void 0;a.push({blockOverrides:o,calls:e,stateOverrides:n})}const u=("bigint"==typeof g?n(g):void 0)||k;return(await j.request({method:"eth_simulateV1",params:[{blockStateCalls:a,returnFullTransactions:O,traceTransfers:h,validation:w},u]})).map((r,t)=>({...m(r),calls:r.calls.map((r,a)=>{const{abi:i,args:c,functionName:n,to:u}=x[t].calls[a],m=r.error?.data??r.returnData,d=BigInt(r.gasUsed),p=r.logs?.map(r=>f(r)),b="0x1"===r.status?"success":"failure",j=i&&"success"===b&&"0x"!==m?e({abi:i,data:m,functionName:n}):null,v=(()=>{if("success"===b)return;let t;return"0x"===r.error?.data?t=new s:r.error&&(t=new o(r.error)),t?l(t,{abi:i??[],address:u??"0x",args:c,functionName:n??"<unknown>"}):void 0})();return{data:m,gasUsed:d,logs:p,status:b,..."success"===b?{result:j}:{error:v}}})}))}catch(r){const t=r,s=u(t,{});if(s instanceof a)throw t;throw s}}export{j as simulateBlocks};
-//# sourceMappingURL=simulateBlocks.js.map

package/dist/esm/node_modules/viem/_esm/actions/public/simulateBlocks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulateBlocks.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/simulateBlocks.js"],"sourcesContent":["import * as BlockOverrides from 'ox/BlockOverrides';\nimport { parseAccount, } from '../../accounts/utils/parseAccount.js';\nimport { AbiDecodingZeroDataError } from '../../errors/abi.js';\nimport { RawContractError } from '../../errors/contract.js';\nimport { UnknownNodeError } from '../../errors/node.js';\nimport { decodeFunctionResult, } from '../../utils/abi/decodeFunctionResult.js';\nimport { encodeFunctionData, } from '../../utils/abi/encodeFunctionData.js';\nimport { concat } from '../../utils/data/concat.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { getContractError } from '../../utils/errors/getContractError.js';\nimport { getNodeError, } from '../../utils/errors/getNodeError.js';\nimport { formatBlock, } from '../../utils/formatters/block.js';\nimport { formatLog } from '../../utils/formatters/log.js';\nimport { formatTransactionRequest, } from '../../utils/formatters/transactionRequest.js';\nimport { serializeStateOverride, } from '../../utils/stateOverride.js';\nimport { assertRequest, } from '../../utils/transaction/assertRequest.js';\n/**\n * Simulates a set of calls on block(s) with optional block and state overrides.\n *\n * @example\n * ```ts\n * import { createClient, http, parseEther } from 'viem'\n * import { simulate } from 'viem/actions'\n * import { mainnet } from 'viem/chains'\n *\n * const client = createClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n *\n * const result = await simulate(client, {\n *   blocks: [{\n *     blockOverrides: {\n *       number: 69420n,\n *     },\n *     calls: [{\n *       {\n *         account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',\n *         data: '0xdeadbeef',\n *         to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',\n *       },\n *       {\n *         account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',\n *         to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',\n *         value: parseEther('1'),\n *       },\n *     }],\n *     stateOverrides: [{\n *       address: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',\n *       balance: parseEther('10'),\n *     }],\n *   }]\n * })\n * ```\n *\n * @param client - Client to use.\n * @param parameters - {@link SimulateBlocksParameters}\n * @returns Simulated blocks. {@link SimulateBlocksReturnType}\n */\nexport async function simulateBlocks(client, parameters) {\n    const { blockNumber, blockTag = client.experimental_blockTag ?? 'latest', blocks, returnFullTransactions, traceTransfers, validation, } = parameters;\n    try {\n        const blockStateCalls = [];\n        for (const block of blocks) {\n            const blockOverrides = block.blockOverrides\n                ? BlockOverrides.toRpc(block.blockOverrides)\n                : undefined;\n            const calls = block.calls.map((call_) => {\n                const call = call_;\n                const account = call.account ? parseAccount(call.account) : undefined;\n                const data = call.abi ? encodeFunctionData(call) : call.data;\n                const request = {\n                    ...call,\n                    data: call.dataSuffix\n                        ? concat([data || '0x', call.dataSuffix])\n                        : data,\n                    from: call.from ?? account?.address,\n                };\n                assertRequest(request);\n                return formatTransactionRequest(request);\n            });\n            const stateOverrides = block.stateOverrides\n                ? serializeStateOverride(block.stateOverrides)\n                : undefined;\n            blockStateCalls.push({\n                blockOverrides,\n                calls,\n                stateOverrides,\n            });\n        }\n        const blockNumberHex = typeof blockNumber === 'bigint' ? numberToHex(blockNumber) : undefined;\n        const block = blockNumberHex || blockTag;\n        const result = await client.request({\n            method: 'eth_simulateV1',\n            params: [\n                { blockStateCalls, returnFullTransactions, traceTransfers, validation },\n                block,\n            ],\n        });\n        return result.map((block, i) => ({\n            ...formatBlock(block),\n            calls: block.calls.map((call, j) => {\n                const { abi, args, functionName, to } = blocks[i].calls[j];\n                const data = call.error?.data ?? call.returnData;\n                const gasUsed = BigInt(call.gasUsed);\n                const logs = call.logs?.map((log) => formatLog(log));\n                const status = call.status === '0x1' ? 'success' : 'failure';\n                const result = abi && status === 'success' && data !== '0x'\n                    ? decodeFunctionResult({\n                        abi,\n                        data,\n                        functionName,\n                    })\n                    : null;\n                const error = (() => {\n                    if (status === 'success')\n                        return undefined;\n                    let error;\n                    if (call.error?.data === '0x')\n                        error = new AbiDecodingZeroDataError();\n                    else if (call.error)\n                        error = new RawContractError(call.error);\n                    if (!error)\n                        return undefined;\n                    return getContractError(error, {\n                        abi: (abi ?? []),\n                        address: to ?? '0x',\n                        args,\n                        functionName: functionName ?? '<unknown>',\n                    });\n                })();\n                return {\n                    data,\n                    gasUsed,\n                    logs,\n                    status,\n                    ...(status === 'success'\n                        ? {\n                            result,\n                        }\n                        : {\n                            error,\n                        }),\n                };\n            }),\n        }));\n    }\n    catch (e) {\n        const cause = e;\n        const error = getNodeError(cause, {});\n        if (error instanceof UnknownNodeError)\n            throw cause;\n        throw error;\n    }\n}\n//# sourceMappingURL=simulateBlocks.js.map"],"names":["async","simulateBlocks","client","parameters","blockNumber","blockTag","experimental_blockTag","blocks","returnFullTransactions","traceTransfers","validation","blockStateCalls","block","blockOverrides","BlockOverrides.toRpc","undefined","calls","map","call_","call","account","parseAccount","data","abi","encodeFunctionData","request","dataSuffix","concat","from","address","assertRequest","formatTransactionRequest","stateOverrides","serializeStateOverride","push","numberToHex","method","params","i","formatBlock","j","args","functionName","to","error","returnData","gasUsed","BigInt","logs","log","formatLog","status","result","decodeFunctionResult","AbiDecodingZeroDataError","RawContractError","getContractError","e","cause","getNodeError","UnknownNodeError"],"mappings":"+iCA2DOA,eAAeC,EAAeC,EAAQC,GACzC,MAAMC,YAAEA,EAAWC,SAAEA,EAAWH,EAAOI,uBAAyB,SAAQC,OAAEA,EAAMC,uBAAEA,EAAsBC,eAAEA,EAAcC,WAAEA,GAAgBP,EAC1I,IACI,MAAMQ,EAAkB,GACxB,IAAK,MAAMC,KAASL,EAAQ,CACxB,MAAMM,EAAiBD,EAAMC,eACvBC,EAAqBF,EAAMC,qBAC3BE,EACAC,EAAQJ,EAAMI,MAAMC,IAAKC,IAC3B,MAAMC,EAAOD,EACPE,EAAUD,EAAKC,QAAUC,EAAaF,EAAKC,cAAWL,EACtDO,EAAOH,EAAKI,IAAMC,EAAmBL,GAAQA,EAAKG,KAClDG,EAAU,IACTN,EACHG,KAAMH,EAAKO,WACLC,EAAO,CAACL,GAAQ,KAAMH,EAAKO,aAC3BJ,EACNM,KAAMT,EAAKS,MAAQR,GAASS,SAGhC,OADAC,EAAcL,GACPM,EAAyBN,KAE9BO,EAAiBpB,EAAMoB,eACvBC,EAAuBrB,EAAMoB,qBAC7BjB,EACNJ,EAAgBuB,KAAK,CACjBrB,iBACAG,QACAgB,kBAER,CACA,MACMpB,GADwC,iBAAhBR,EAA2B+B,EAAY/B,QAAeW,IACpDV,EAQhC,aAPqBH,EAAOuB,QAAQ,CAChCW,OAAQ,iBACRC,OAAQ,CACJ,CAAE1B,kBAAiBH,yBAAwBC,iBAAgBC,cAC3DE,MAGMK,IAAI,CAACL,EAAO0B,KAAC,IACpBC,EAAY3B,GACfI,MAAOJ,EAAMI,MAAMC,IAAI,CAACE,EAAMqB,KAC1B,MAAMjB,IAAEA,EAAGkB,KAAEA,EAAIC,aAAEA,EAAYC,GAAEA,GAAOpC,EAAO+B,GAAGtB,MAAMwB,GAClDlB,EAAOH,EAAKyB,OAAOtB,MAAQH,EAAK0B,WAChCC,EAAUC,OAAO5B,EAAK2B,SACtBE,EAAO7B,EAAK6B,MAAM/B,IAAKgC,GAAQC,EAAUD,IACzCE,EAAyB,QAAhBhC,EAAKgC,OAAmB,UAAY,UAC7CC,EAAS7B,GAAkB,YAAX4B,GAAiC,OAAT7B,EACxC+B,EAAqB,CACnB9B,MACAD,OACAoB,iBAEF,KACAE,EAAQ,MACV,GAAe,YAAXO,EACA,OACJ,IAAIP,EAKJ,MAJyB,OAArBzB,EAAKyB,OAAOtB,KACZsB,EAAQ,IAAIU,EACPnC,EAAKyB,QACVA,EAAQ,IAAIW,EAAiBpC,EAAKyB,QACjCA,EAEEY,EAAiBZ,EAAO,CAC3BrB,IAAMA,GAAO,GACbM,QAASc,GAAM,KACfF,OACAC,aAAcA,GAAgB,mBANlC,CAQH,EAhBa,GAiBd,MAAO,CACHpB,OACAwB,UACAE,OACAG,YACe,YAAXA,EACE,CACEC,UAEF,CACER,cAKxB,CACA,MAAOa,GACH,MAAMC,EAAQD,EACRb,EAAQe,EAAaD,EAAO,IAClC,GAAId,aAAiBgB,EACjB,MAAMF,EACV,MAAMd,CACV,CACJ","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/simulateCalls.js

@@ -1,2 +0,0 @@
-import{encode as s,from as f}from"../../../../ox/_esm/core/AbiConstructor.js";import{encodeData as a,from as e}from"../../../../ox/_esm/core/AbiFunction.js";import{parseAccount as t}from"../../accounts/utils/parseAccount.js";import{zeroAddress as r,ethAddress as c}from"../../constants/address.js";import{deploylessCallViaBytecodeBytecode as n}from"../../constants/contracts.js";import{BaseError as o}from"../../errors/base.js";import{encodeFunctionData as d}from"../../utils/abi/encodeFunctionData.js";import{createAccessList as i}from"./createAccessList.js";import{simulateBlocks as l}from"./simulateBlocks.js";import{hexToBigInt as b}from"../../utils/encoding/fromHex.js";async function u(u,m){const{blockNumber:p,blockTag:g,calls:v,stateOverrides:y,traceAssetChanges:O,traceTransfers:k,validation:j}=m,h=m.account?t(m.account):void 0;if(O&&!h)throw new o("`account` is required when `traceAssetChanges` is true");const N=h?s(f("constructor(bytes, bytes)"),{bytecode:n,args:["0x6080604052348015600e575f80fd5b5061016d8061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063f8b2cb4f1461002d575b5f80fd5b610047600480360381019061004291906100db565b61005d565b604051610054919061011e565b60405180910390f35b5f8173ffffffffffffffffffffffffffffffffffffffff16319050919050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100aa82610081565b9050919050565b6100ba816100a0565b81146100c4575f80fd5b50565b5f813590506100d5816100b1565b92915050565b5f602082840312156100f0576100ef61007d565b5b5f6100fd848285016100c7565b91505092915050565b5f819050919050565b61011881610106565b82525050565b5f6020820190506101315f83018461010f565b9291505056fea26469706673582212203b9fe929fe995c7cf9887f0bdba8a36dd78e8b73f149b17d2d9ad7cd09d2dc6264736f6c634300081a0033",a(e("function getBalance(address)"),[h.address])]}):void 0,w=O?await Promise.all(m.calls.map(async s=>{if(!s.data&&!s.abi)return;const{accessList:f}=await i(u,{account:h.address,...s,data:s.abi?d(s):s.data});return f.map(({address:s,storageKeys:f})=>f.length>0?s:null)})).then(s=>s.flat().filter(Boolean)):[],A=await l(u,{blockNumber:p,blockTag:g,blocks:[...O?[{calls:[{data:N}],stateOverrides:y},{calls:w.map((s,f)=>({abi:[e("function balanceOf(address) returns (uint256)")],functionName:"balanceOf",args:[h.address],to:s,from:r,nonce:f})),stateOverrides:[{address:r,nonce:0}]}]:[],{calls:[...v,{}].map(s=>({...s,from:h?.address})),stateOverrides:y},...O?[{calls:[{data:N}]},{calls:w.map((s,f)=>({abi:[e("function balanceOf(address) returns (uint256)")],functionName:"balanceOf",args:[h.address],to:s,from:r,nonce:f})),stateOverrides:[{address:r,nonce:0}]},{calls:w.map((s,f)=>({to:s,abi:[e("function decimals() returns (uint256)")],functionName:"decimals",from:r,nonce:f})),stateOverrides:[{address:r,nonce:0}]},{calls:w.map((s,f)=>({to:s,abi:[e("function tokenURI(uint256) returns (string)")],functionName:"tokenURI",args:[0n],from:r,nonce:f})),stateOverrides:[{address:r,nonce:0}]},{calls:w.map((s,f)=>({to:s,abi:[e("function symbol() returns (string)")],functionName:"symbol",from:r,nonce:f})),stateOverrides:[{address:r,nonce:0}]}]:[]],traceTransfers:k,validation:j}),x=O?A[2]:A[0],[T,C,,B,F,H,I,L]=O?A:[],{calls:R,...U}=x,_=R.slice(0,-1)??[],q=[...T?.calls??[],...C?.calls??[]].map(s=>"success"===s.status?b(s.data):null),D=[...B?.calls??[],...F?.calls??[]].map(s=>"success"===s.status?b(s.data):null),E=(H?.calls??[]).map(s=>"success"===s.status?s.result:null),K=(L?.calls??[]).map(s=>"success"===s.status?s.result:null),P=(I?.calls??[]).map(s=>"success"===s.status?s.result:null),z=[];for(const[s,f]of D.entries()){const a=q[s];if("bigint"!=typeof f)continue;if("bigint"!=typeof a)continue;const e=E[s-1],t=K[s-1],r=P[s-1],n=(()=>0===s?{address:c,decimals:18,symbol:"ETH"}:{address:w[s-1],decimals:r||e?Number(e??1):void 0,symbol:t??void 0})();z.some(s=>s.token.address===n.address)||z.push({token:n,value:{pre:a,post:f,diff:f-a}})}return{assetChanges:z,block:U,results:_}}export{u as simulateCalls};
-//# sourceMappingURL=simulateCalls.js.map

package/dist/esm/node_modules/viem/_esm/actions/public/simulateCalls.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulateCalls.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/simulateCalls.js"],"sourcesContent":["import * as AbiConstructor from 'ox/AbiConstructor';\nimport * as AbiFunction from 'ox/AbiFunction';\nimport { parseAccount } from '../../accounts/utils/parseAccount.js';\nimport { ethAddress, zeroAddress } from '../../constants/address.js';\nimport { deploylessCallViaBytecodeBytecode } from '../../constants/contracts.js';\nimport { BaseError } from '../../errors/base.js';\nimport { encodeFunctionData, } from '../../utils/abi/encodeFunctionData.js';\nimport { hexToBigInt } from '../../utils/index.js';\nimport { createAccessList, } from './createAccessList.js';\nimport { simulateBlocks, } from './simulateBlocks.js';\nconst getBalanceCode = '0x6080604052348015600e575f80fd5b5061016d8061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063f8b2cb4f1461002d575b5f80fd5b610047600480360381019061004291906100db565b61005d565b604051610054919061011e565b60405180910390f35b5f8173ffffffffffffffffffffffffffffffffffffffff16319050919050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100aa82610081565b9050919050565b6100ba816100a0565b81146100c4575f80fd5b50565b5f813590506100d5816100b1565b92915050565b5f602082840312156100f0576100ef61007d565b5b5f6100fd848285016100c7565b91505092915050565b5f819050919050565b61011881610106565b82525050565b5f6020820190506101315f83018461010f565b9291505056fea26469706673582212203b9fe929fe995c7cf9887f0bdba8a36dd78e8b73f149b17d2d9ad7cd09d2dc6264736f6c634300081a0033';\n/**\n * Simulates execution of a batch of calls.\n *\n * @param client - Client to use\n * @param parameters - {@link SimulateCallsParameters}\n * @returns Results. {@link SimulateCallsReturnType}\n *\n * @example\n * ```ts\n * import { createPublicClient, http, parseEther } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { simulateCalls } from 'viem/actions'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n *\n * const result = await simulateCalls(client, {\n *   account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',\n *   calls: [{\n *     {\n *       data: '0xdeadbeef',\n *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',\n *     },\n *     {\n *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',\n *       value: parseEther('1'),\n *     },\n *   ]\n * })\n * ```\n */\nexport async function simulateCalls(client, parameters) {\n    const { blockNumber, blockTag, calls, stateOverrides, traceAssetChanges, traceTransfers, validation, } = parameters;\n    const account = parameters.account\n        ? parseAccount(parameters.account)\n        : undefined;\n    if (traceAssetChanges && !account)\n        throw new BaseError('`account` is required when `traceAssetChanges` is true');\n    // Derive bytecode to extract ETH balance via a contract call.\n    const getBalanceData = account\n        ? AbiConstructor.encode(AbiConstructor.from('constructor(bytes, bytes)'), {\n            bytecode: deploylessCallViaBytecodeBytecode,\n            args: [\n                getBalanceCode,\n                AbiFunction.encodeData(AbiFunction.from('function getBalance(address)'), [account.address]),\n            ],\n        })\n        : undefined;\n    // Fetch ERC20/721 addresses that were \"touched\" from the calls.\n    const assetAddresses = traceAssetChanges\n        ? await Promise.all(parameters.calls.map(async (call) => {\n            if (!call.data && !call.abi)\n                return;\n            const { accessList } = await createAccessList(client, {\n                account: account.address,\n                ...call,\n                data: call.abi ? encodeFunctionData(call) : call.data,\n            });\n            return accessList.map(({ address, storageKeys }) => storageKeys.length > 0 ? address : null);\n        })).then((x) => x.flat().filter(Boolean))\n        : [];\n    const blocks = await simulateBlocks(client, {\n        blockNumber,\n        blockTag: blockTag,\n        blocks: [\n            ...(traceAssetChanges\n                ? [\n                    // ETH pre balances\n                    {\n                        calls: [{ data: getBalanceData }],\n                        stateOverrides,\n                    },\n                    // Asset pre balances\n                    {\n                        calls: assetAddresses.map((address, i) => ({\n                            abi: [\n                                AbiFunction.from('function balanceOf(address) returns (uint256)'),\n                            ],\n                            functionName: 'balanceOf',\n                            args: [account.address],\n                            to: address,\n                            from: zeroAddress,\n                            nonce: i,\n                        })),\n                        stateOverrides: [\n                            {\n                                address: zeroAddress,\n                                nonce: 0,\n                            },\n                        ],\n                    },\n                ]\n                : []),\n            {\n                calls: [...calls, {}].map((call) => ({\n                    ...call,\n                    from: account?.address,\n                })),\n                stateOverrides,\n            },\n            ...(traceAssetChanges\n                ? [\n                    // ETH post balances\n                    {\n                        calls: [{ data: getBalanceData }],\n                    },\n                    // Asset post balances\n                    {\n                        calls: assetAddresses.map((address, i) => ({\n                            abi: [\n                                AbiFunction.from('function balanceOf(address) returns (uint256)'),\n                            ],\n                            functionName: 'balanceOf',\n                            args: [account.address],\n                            to: address,\n                            from: zeroAddress,\n                            nonce: i,\n                        })),\n                        stateOverrides: [\n                            {\n                                address: zeroAddress,\n                                nonce: 0,\n                            },\n                        ],\n                    },\n                    // Decimals\n                    {\n                        calls: assetAddresses.map((address, i) => ({\n                            to: address,\n                            abi: [\n                                AbiFunction.from('function decimals() returns (uint256)'),\n                            ],\n                            functionName: 'decimals',\n                            from: zeroAddress,\n                            nonce: i,\n                        })),\n                        stateOverrides: [\n                            {\n                                address: zeroAddress,\n                                nonce: 0,\n                            },\n                        ],\n                    },\n                    // Token URI\n                    {\n                        calls: assetAddresses.map((address, i) => ({\n                            to: address,\n                            abi: [\n                                AbiFunction.from('function tokenURI(uint256) returns (string)'),\n                            ],\n                            functionName: 'tokenURI',\n                            args: [0n],\n                            from: zeroAddress,\n                            nonce: i,\n                        })),\n                        stateOverrides: [\n                            {\n                                address: zeroAddress,\n                                nonce: 0,\n                            },\n                        ],\n                    },\n                    // Symbols\n                    {\n                        calls: assetAddresses.map((address, i) => ({\n                            to: address,\n                            abi: [AbiFunction.from('function symbol() returns (string)')],\n                            functionName: 'symbol',\n                            from: zeroAddress,\n                            nonce: i,\n                        })),\n                        stateOverrides: [\n                            {\n                                address: zeroAddress,\n                                nonce: 0,\n                            },\n                        ],\n                    },\n                ]\n                : []),\n        ],\n        traceTransfers,\n        validation,\n    });\n    const block_results = traceAssetChanges ? blocks[2] : blocks[0];\n    const [block_ethPre, block_assetsPre, , block_ethPost, block_assetsPost, block_decimals, block_tokenURI, block_symbols,] = traceAssetChanges ? blocks : [];\n    // Extract call results from the simulation.\n    const { calls: block_calls, ...block } = block_results;\n    const results = block_calls.slice(0, -1) ?? [];\n    // Extract pre-execution ETH and asset balances.\n    const ethPre = block_ethPre?.calls ?? [];\n    const assetsPre = block_assetsPre?.calls ?? [];\n    const balancesPre = [...ethPre, ...assetsPre].map((call) => call.status === 'success' ? hexToBigInt(call.data) : null);\n    // Extract post-execution ETH and asset balances.\n    const ethPost = block_ethPost?.calls ?? [];\n    const assetsPost = block_assetsPost?.calls ?? [];\n    const balancesPost = [...ethPost, ...assetsPost].map((call) => call.status === 'success' ? hexToBigInt(call.data) : null);\n    // Extract asset symbols & decimals.\n    const decimals = (block_decimals?.calls ?? []).map((x) => x.status === 'success' ? x.result : null);\n    const symbols = (block_symbols?.calls ?? []).map((x) => x.status === 'success' ? x.result : null);\n    const tokenURI = (block_tokenURI?.calls ?? []).map((x) => x.status === 'success' ? x.result : null);\n    const changes = [];\n    for (const [i, balancePost] of balancesPost.entries()) {\n        const balancePre = balancesPre[i];\n        if (typeof balancePost !== 'bigint')\n            continue;\n        if (typeof balancePre !== 'bigint')\n            continue;\n        const decimals_ = decimals[i - 1];\n        const symbol_ = symbols[i - 1];\n        const tokenURI_ = tokenURI[i - 1];\n        const token = (() => {\n            if (i === 0)\n                return {\n                    address: ethAddress,\n                    decimals: 18,\n                    symbol: 'ETH',\n                };\n            return {\n                address: assetAddresses[i - 1],\n                decimals: tokenURI_ || decimals_ ? Number(decimals_ ?? 1) : undefined,\n                symbol: symbol_ ?? undefined,\n            };\n        })();\n        if (changes.some((change) => change.token.address === token.address))\n            continue;\n        changes.push({\n            token,\n            value: {\n                pre: balancePre,\n                post: balancePost,\n                diff: balancePost - balancePre,\n            },\n        });\n    }\n    return {\n        assetChanges: changes,\n        block,\n        results,\n    };\n}\n//# sourceMappingURL=simulateCalls.js.map"],"names":["async","simulateCalls","client","parameters","blockNumber","blockTag","calls","stateOverrides","traceAssetChanges","traceTransfers","validation","account","parseAccount","undefined","BaseError","getBalanceData","AbiConstructor.encode","AbiConstructor.from","bytecode","deploylessCallViaBytecodeBytecode","args","AbiFunction.encodeData","AbiFunction.from","address","assetAddresses","Promise","all","map","call","data","abi","accessList","createAccessList","encodeFunctionData","storageKeys","length","then","x","flat","filter","Boolean","blocks","simulateBlocks","i","functionName","to","from","zeroAddress","nonce","block_results","block_ethPre","block_assetsPre","block_ethPost","block_assetsPost","block_decimals","block_tokenURI","block_symbols","block_calls","block","results","slice","balancesPre","status","hexToBigInt","balancesPost","decimals","result","symbols","tokenURI","changes","balancePost","entries","balancePre","decimals_","symbol_","tokenURI_","token","ethAddress","symbol","Number","some","change","push","value","pre","post","diff","assetChanges"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/simulateContract.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulateContract.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/simulateContract.js"],"sourcesContent":["import { parseAccount, } from '../../accounts/utils/parseAccount.js';\nimport { decodeFunctionResult, } from '../../utils/abi/decodeFunctionResult.js';\nimport { encodeFunctionData, } from '../../utils/abi/encodeFunctionData.js';\nimport { getContractError, } from '../../utils/errors/getContractError.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { call } from './call.js';\n/**\n * Simulates/validates a contract interaction. This is useful for retrieving **return data** and **revert reasons** of contract write functions.\n *\n * - Docs: https://viem.sh/docs/contract/simulateContract\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts_writing-to-contracts\n *\n * This function does not require gas to execute and _**does not**_ change the state of the blockchain. It is almost identical to [`readContract`](https://viem.sh/docs/contract/readContract), but also supports contract write functions.\n *\n * Internally, uses a [Public Client](https://viem.sh/docs/clients/public) to call the [`call` action](https://viem.sh/docs/actions/public/call) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).\n *\n * @param client - Client to use\n * @param parameters - {@link SimulateContractParameters}\n * @returns The simulation result and write request. {@link SimulateContractReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { simulateContract } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const result = await simulateContract(client, {\n *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *   abi: parseAbi(['function mint(uint32) view returns (uint32)']),\n *   functionName: 'mint',\n *   args: ['69420'],\n *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',\n * })\n */\nexport async function simulateContract(client, parameters) {\n    const { abi, address, args, dataSuffix, functionName, ...callRequest } = parameters;\n    const account = callRequest.account\n        ? parseAccount(callRequest.account)\n        : client.account;\n    const calldata = encodeFunctionData({ abi, args, functionName });\n    try {\n        const { data } = await getAction(client, call, 'call')({\n            batch: false,\n            data: `${calldata}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,\n            to: address,\n            ...callRequest,\n            account,\n        });\n        const result = decodeFunctionResult({\n            abi,\n            args,\n            functionName,\n            data: data || '0x',\n        });\n        const minimizedAbi = abi.filter((abiItem) => 'name' in abiItem && abiItem.name === parameters.functionName);\n        return {\n            result,\n            request: {\n                abi: minimizedAbi,\n                address,\n                args,\n                dataSuffix,\n                functionName,\n                ...callRequest,\n                account,\n            },\n        };\n    }\n    catch (error) {\n        throw getContractError(error, {\n            abi,\n            address,\n            args,\n            docsPath: '/docs/contract/simulateContract',\n            functionName,\n            sender: account?.address,\n        });\n    }\n}\n//# sourceMappingURL=simulateContract.js.map"],"names":["async","simulateContract","client","parameters","abi","address","args","dataSuffix","functionName","callRequest","account","parseAccount","calldata","encodeFunctionData","data","getAction","call","batch","replace","to","result","decodeFunctionResult","request","filter","abiItem","name","error","getContractError","docsPath","sender"],"mappings":"8XAqCOA,eAAeC,EAAiBC,EAAQC,GAC3C,MAAMC,IAAEA,EAAGC,QAAEA,EAAOC,KAAEA,EAAIC,WAAEA,EAAUC,aAAEA,KAAiBC,GAAgBN,EACnEO,EAAUD,EAAYC,QACtBC,EAAaF,EAAYC,SACzBR,EAAOQ,QACPE,EAAWC,EAAmB,CAAET,MAAKE,OAAME,iBACjD,IACI,MAAMM,KAAEA,SAAeC,EAAUb,EAAQc,EAAM,OAAxBD,CAAgC,CACnDE,OAAO,EACPH,KAAM,GAAGF,IAAWL,EAAaA,EAAWW,QAAQ,KAAM,IAAM,KAChEC,GAAId,KACDI,EACHC,YAEEU,EAASC,EAAqB,CAChCjB,MACAE,OACAE,eACAM,KAAMA,GAAQ,OAGlB,MAAO,CACHM,SACAE,QAAS,CACLlB,IAJaA,EAAImB,OAAQC,GAAY,SAAUA,GAAWA,EAAQC,OAAStB,EAAWK,cAKtFH,UACAC,OACAC,aACAC,kBACGC,EACHC,WAGZ,CACA,MAAOgB,GACH,MAAMC,EAAiBD,EAAO,CAC1BtB,MACAC,UACAC,OACAsB,SAAU,kCACVpB,eACAqB,OAAQnB,GAASL,SAEzB,CACJ","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/uninstallFilter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"uninstallFilter.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/uninstallFilter.js"],"sourcesContent":["/**\n * Destroys a [`Filter`](https://viem.sh/docs/glossary/types#filter).\n *\n * - Docs: https://viem.sh/docs/actions/public/uninstallFilter\n * - JSON-RPC Methods: [`eth_uninstallFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_uninstallFilter)\n *\n * Destroys a Filter that was created from one of the following Actions:\n * - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)\n * - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)\n * - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)\n *\n * @param client - Client to use\n * @param parameters - {@link UninstallFilterParameters}\n * @returns A boolean indicating if the Filter was successfully uninstalled. {@link UninstallFilterReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createPendingTransactionFilter, uninstallFilter } from 'viem/public'\n *\n * const filter = await createPendingTransactionFilter(client)\n * const uninstalled = await uninstallFilter(client, { filter })\n * // true\n */\nexport async function uninstallFilter(_client, { filter }) {\n    return filter.request({\n        method: 'eth_uninstallFilter',\n        params: [filter.id],\n    });\n}\n//# sourceMappingURL=uninstallFilter.js.map"],"names":["async","uninstallFilter","_client","filter","request","method","params","id"],"mappings":"AAwBOA,eAAeC,EAAgBC,GAASC,OAAEA,IAC7C,OAAOA,EAAOC,QAAQ,CAClBC,OAAQ,sBACRC,OAAQ,CAACH,EAAOI,KAExB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/verifyHash.js

@@ -1,2 +0,0 @@
-import{multicall3Abi as r,erc1271Abi as a,erc6492SignatureValidatorAbi as t}from"../../constants/abis.js";import{multicall3Bytecode as s,erc6492SignatureValidatorByteCode as i}from"../../constants/contracts.js";import{CallExecutionError as e,ContractFunctionExecutionError as o}from"../../errors/contract.js";import{encodeDeployData as n}from"../../utils/abi/encodeDeployData.js";import{encodeFunctionData as c}from"../../utils/abi/encodeFunctionData.js";import{getAddress as d}from"../../utils/address/getAddress.js";import{isAddressEqual as u}from"../../utils/address/isAddressEqual.js";import{verifyAuthorization as l}from"../../utils/authorization/verifyAuthorization.js";import{concatHex as m}from"../../utils/data/concat.js";import{isHex as f}from"../../utils/data/isHex.js";import{hexToBool as g}from"../../utils/encoding/fromHex.js";import{bytesToHex as h,numberToHex as b}from"../../utils/encoding/toHex.js";import{getAction as w}from"../../utils/getAction.js";import{recoverAddress as p}from"../../utils/signature/recoverAddress.js";import{serializeSignature as j}from"../../utils/signature/serializeSignature.js";import{call as y}from"./call.js";import{getCode as A}from"./getCode.js";import{readContract as k}from"./readContract.js";import{validate as N,unwrap as x}from"../../../../ox/_esm/erc8010/SignatureErc8010.js";import{validate as z,wrap as D}from"../../../../ox/_esm/erc6492/SignatureErc6492.js";async function S(r,a){const{address:s,hash:o,erc6492VerifierAddress:l=a.universalSignatureVerifierAddress??r.chain?.contracts?.erc6492Verifier?.address,multicallAddress:m=a.multicallAddress??r.chain?.contracts?.multicall3?.address}=a,b=(()=>{const r=a.signature;return f(r)?r:"object"==typeof r&&"r"in r&&"s"in r?j(r):h(r)})();try{return N(b)?await v(r,{...a,multicallAddress:m,signature:b}):await async function(r,a){const{address:s,factory:o,factoryData:d,hash:u,signature:l,verifierAddress:m,...f}=a,h=await(async()=>o||d?z(l)?l:D({data:d,signature:l,to:o}):l)(),b=m?{to:m,data:c({abi:t,functionName:"isValidSig",args:[s,u,h]}),...f}:{data:n({abi:t,args:[s,u,h],bytecode:i}),...f},{data:p}=await w(r,y,"call")(b).catch(r=>{if(r instanceof e)throw new V;throw r});if(g(p??"0x0"))return!0;throw new V}(r,{...a,verifierAddress:l,signature:b})}catch(r){try{if(u(d(s),await p({hash:o,signature:b})))return!0}catch{}if(r instanceof V)return!1;throw r}}async function v(t,i){const{address:e,blockNumber:o,blockTag:n,hash:d,multicallAddress:u}=i,{authorization:f,data:g,signature:h,to:p}=x(i.signature);if(await A(t,{address:e,blockNumber:o,blockTag:n})===m(["0xef0100",f.address]))return await T(t,{address:e,blockNumber:o,blockTag:n,hash:d,signature:h});const j={address:f.address,chainId:Number(f.chainId),nonce:Number(f.nonce),r:b(f.r,{size:32}),s:b(f.s,{size:32}),yParity:f.yParity};if(!await l({address:e,authorization:j}))throw new V;const y=await w(t,k,"readContract")({...u?{address:u}:{code:s},authorizationList:[j],abi:r,blockNumber:o,blockTag:"pending",functionName:"aggregate3",args:[[...g?[{allowFailure:!0,target:p??e,callData:g}]:[],{allowFailure:!0,target:e,callData:c({abi:a,functionName:"isValidSignature",args:[d,h]})}]]}),N=y[y.length-1]?.returnData;if(N?.startsWith("0x1626ba7e"))return!0;throw new V}async function T(r,t){const{address:s,blockNumber:i,blockTag:e,hash:n,signature:c}=t;if((await w(r,k,"readContract")({address:s,abi:a,args:[n,c],blockNumber:i,blockTag:e,functionName:"isValidSignature"}).catch(r=>{if(r instanceof o)throw new V;throw r})).startsWith("0x1626ba7e"))return!0;throw new V}class V extends Error{}export{T as verifyErc1271,v as verifyErc8010,S as verifyHash};
-//# sourceMappingURL=verifyHash.js.map

package/dist/esm/node_modules/viem/_esm/actions/public/verifyHash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"verifyHash.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/verifyHash.js"],"sourcesContent":["import { SignatureErc6492 } from 'ox/erc6492';\nimport { SignatureErc8010 } from 'ox/erc8010';\nimport { erc1271Abi, erc6492SignatureValidatorAbi, multicall3Abi, } from '../../constants/abis.js';\nimport { erc6492SignatureValidatorByteCode, multicall3Bytecode, } from '../../constants/contracts.js';\nimport { CallExecutionError, ContractFunctionExecutionError, } from '../../errors/contract.js';\nimport { encodeDeployData, } from '../../utils/abi/encodeDeployData.js';\nimport { encodeFunctionData, } from '../../utils/abi/encodeFunctionData.js';\nimport { getAddress, } from '../../utils/address/getAddress.js';\nimport { isAddressEqual, } from '../../utils/address/isAddressEqual.js';\nimport { verifyAuthorization } from '../../utils/authorization/verifyAuthorization.js';\nimport { concatHex } from '../../utils/data/concat.js';\nimport { isHex } from '../../utils/data/isHex.js';\nimport { hexToBool } from '../../utils/encoding/fromHex.js';\nimport { bytesToHex, numberToHex, } from '../../utils/encoding/toHex.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { recoverAddress, } from '../../utils/signature/recoverAddress.js';\nimport { serializeSignature, } from '../../utils/signature/serializeSignature.js';\nimport { call } from './call.js';\nimport { getCode } from './getCode.js';\nimport { readContract } from './readContract.js';\n/**\n * Verifies a message hash onchain using ERC-6492.\n *\n * @param client - Client to use.\n * @param parameters - {@link VerifyHashParameters}\n * @returns Whether or not the signature is valid. {@link VerifyHashReturnType}\n */\nexport async function verifyHash(client, parameters) {\n    const { address, hash, erc6492VerifierAddress: verifierAddress = parameters.universalSignatureVerifierAddress ??\n        client.chain?.contracts?.erc6492Verifier?.address, multicallAddress = parameters.multicallAddress ??\n        client.chain?.contracts?.multicall3?.address, } = parameters;\n    const signature = (() => {\n        const signature = parameters.signature;\n        if (isHex(signature))\n            return signature;\n        if (typeof signature === 'object' && 'r' in signature && 's' in signature)\n            return serializeSignature(signature);\n        return bytesToHex(signature);\n    })();\n    try {\n        if (SignatureErc8010.validate(signature))\n            return await verifyErc8010(client, {\n                ...parameters,\n                multicallAddress,\n                signature,\n            });\n        return await verifyErc6492(client, {\n            ...parameters,\n            verifierAddress,\n            signature,\n        });\n    }\n    catch (error) {\n        // Fallback attempt to verify the signature via ECDSA recovery.\n        try {\n            const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash, signature }));\n            if (verified)\n                return true;\n        }\n        catch { }\n        if (error instanceof VerificationError) {\n            // if the execution fails, the signature was not valid and an internal method inside of the validator reverted\n            // this can happen for many reasons, for example if signer can not be recovered from the signature\n            // or if the signature has no valid format\n            return false;\n        }\n        throw error;\n    }\n}\n/** @internal */\nexport async function verifyErc8010(client, parameters) {\n    const { address, blockNumber, blockTag, hash, multicallAddress } = parameters;\n    const { authorization: authorization_ox, data: initData, signature, to, } = SignatureErc8010.unwrap(parameters.signature);\n    // Check if already delegated\n    const code = await getCode(client, {\n        address,\n        blockNumber,\n        blockTag,\n    });\n    // If already delegated, perform standard ERC-1271 verification.\n    if (code === concatHex(['0xef0100', authorization_ox.address]))\n        return await verifyErc1271(client, {\n            address,\n            blockNumber,\n            blockTag,\n            hash,\n            signature,\n        });\n    const authorization = {\n        address: authorization_ox.address,\n        chainId: Number(authorization_ox.chainId),\n        nonce: Number(authorization_ox.nonce),\n        r: numberToHex(authorization_ox.r, { size: 32 }),\n        s: numberToHex(authorization_ox.s, { size: 32 }),\n        yParity: authorization_ox.yParity,\n    };\n    const valid = await verifyAuthorization({\n        address,\n        authorization,\n    });\n    if (!valid)\n        throw new VerificationError();\n    // Deployless verification.\n    const results = await getAction(client, readContract, 'readContract')({\n        ...(multicallAddress\n            ? { address: multicallAddress }\n            : { code: multicall3Bytecode }),\n        authorizationList: [authorization],\n        abi: multicall3Abi,\n        blockNumber,\n        blockTag: 'pending',\n        functionName: 'aggregate3',\n        args: [\n            [\n                ...(initData\n                    ? [\n                        {\n                            allowFailure: true,\n                            target: to ?? address,\n                            callData: initData,\n                        },\n                    ]\n                    : []),\n                {\n                    allowFailure: true,\n                    target: address,\n                    callData: encodeFunctionData({\n                        abi: erc1271Abi,\n                        functionName: 'isValidSignature',\n                        args: [hash, signature],\n                    }),\n                },\n            ],\n        ],\n    });\n    const data = results[results.length - 1]?.returnData;\n    if (data?.startsWith('0x1626ba7e'))\n        return true;\n    throw new VerificationError();\n}\n/** @internal */\n// biome-ignore lint/correctness/noUnusedVariables: _\nasync function verifyErc6492(client, parameters) {\n    const { address, factory, factoryData, hash, signature, verifierAddress, ...rest } = parameters;\n    const wrappedSignature = await (async () => {\n        // If no `factory` or `factoryData` is provided, it is assumed that the\n        // address is not a Smart Account, or the Smart Account is already deployed.\n        if (!factory && !factoryData)\n            return signature;\n        // If the signature is already wrapped, return the signature.\n        if (SignatureErc6492.validate(signature))\n            return signature;\n        // If the Smart Account is not deployed, wrap the signature with a 6492 wrapper\n        // to perform counterfactual validation.\n        return SignatureErc6492.wrap({\n            data: factoryData,\n            signature,\n            to: factory,\n        });\n    })();\n    const args = verifierAddress\n        ? {\n            to: verifierAddress,\n            data: encodeFunctionData({\n                abi: erc6492SignatureValidatorAbi,\n                functionName: 'isValidSig',\n                args: [address, hash, wrappedSignature],\n            }),\n            ...rest,\n        }\n        : {\n            data: encodeDeployData({\n                abi: erc6492SignatureValidatorAbi,\n                args: [address, hash, wrappedSignature],\n                bytecode: erc6492SignatureValidatorByteCode,\n            }),\n            ...rest,\n        };\n    const { data } = await getAction(client, call, 'call')(args).catch((error) => {\n        if (error instanceof CallExecutionError)\n            throw new VerificationError();\n        throw error;\n    });\n    if (hexToBool(data ?? '0x0'))\n        return true;\n    throw new VerificationError();\n}\n/** @internal */\nexport async function verifyErc1271(client, parameters) {\n    const { address, blockNumber, blockTag, hash, signature } = parameters;\n    const result = await getAction(client, readContract, 'readContract')({\n        address,\n        abi: erc1271Abi,\n        args: [hash, signature],\n        blockNumber,\n        blockTag,\n        functionName: 'isValidSignature',\n    }).catch((error) => {\n        if (error instanceof ContractFunctionExecutionError)\n            throw new VerificationError();\n        throw error;\n    });\n    if (result.startsWith('0x1626ba7e'))\n        return true;\n    throw new VerificationError();\n}\nclass VerificationError extends Error {\n}\n//# sourceMappingURL=verifyHash.js.map"],"names":["async","verifyHash","client","parameters","address","hash","erc6492VerifierAddress","verifierAddress","universalSignatureVerifierAddress","chain","contracts","erc6492Verifier","multicallAddress","multicall3","signature","isHex","serializeSignature","bytesToHex","SignatureErc8010.validate","verifyErc8010","factory","factoryData","rest","wrappedSignature","SignatureErc6492.validate","SignatureErc6492.wrap","data","to","args","encodeFunctionData","abi","erc6492SignatureValidatorAbi","functionName","encodeDeployData","bytecode","erc6492SignatureValidatorByteCode","getAction","call","catch","error","CallExecutionError","VerificationError","hexToBool","verifyErc6492","isAddressEqual","getAddress","recoverAddress","blockNumber","blockTag","authorization","authorization_ox","initData","SignatureErc8010.unwrap","getCode","concatHex","verifyErc1271","chainId","Number","nonce","r","numberToHex","size","s","yParity","verifyAuthorization","results","readContract","code","multicall3Bytecode","authorizationList","multicall3Abi","allowFailure","target","callData","erc1271Abi","length","returnData","startsWith","ContractFunctionExecutionError","Error"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/verifyMessage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"verifyMessage.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/verifyMessage.js"],"sourcesContent":["import { hashMessage } from '../../utils/signature/hashMessage.js';\nimport { verifyHash, } from './verifyHash.js';\n/**\n * Verify that a message was signed by the provided address.\n *\n * Compatible with Smart Contract Accounts & Externally Owned Accounts via [ERC-6492](https://eips.ethereum.org/EIPS/eip-6492).\n *\n * - Docs {@link https://viem.sh/docs/actions/public/verifyMessage}\n *\n * @param client - Client to use.\n * @param parameters - {@link VerifyMessageParameters}\n * @returns Whether or not the signature is valid. {@link VerifyMessageReturnType}\n */\nexport async function verifyMessage(client, { address, message, factory, factoryData, signature, ...callRequest }) {\n    const hash = hashMessage(message);\n    return verifyHash(client, {\n        address,\n        factory: factory,\n        factoryData: factoryData,\n        hash,\n        signature,\n        ...callRequest,\n    });\n}\n//# sourceMappingURL=verifyMessage.js.map"],"names":["async","verifyMessage","client","address","message","factory","factoryData","signature","callRequest","hash","hashMessage","verifyHash"],"mappings":"gHAaOA,eAAeC,EAAcC,GAAQC,QAAEA,EAAOC,QAAEA,EAAOC,QAAEA,EAAOC,YAAEA,EAAWC,UAAEA,KAAcC,IAChG,MAAMC,EAAOC,EAAYN,GACzB,OAAOO,EAAWT,EAAQ,CACtBC,UACAE,QAASA,EACTC,YAAaA,EACbG,OACAF,eACGC,GAEX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/verifyTypedData.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"verifyTypedData.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/verifyTypedData.js"],"sourcesContent":["import { hashTypedData, } from '../../utils/signature/hashTypedData.js';\nimport { verifyHash, } from './verifyHash.js';\n/**\n * Verify that typed data was signed by the provided address.\n *\n * - Docs {@link https://viem.sh/docs/actions/public/verifyTypedData}\n *\n * @param client - Client to use.\n * @param parameters - {@link VerifyTypedDataParameters}\n * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}\n */\nexport async function verifyTypedData(client, parameters) {\n    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;\n    const hash = hashTypedData({ message, primaryType, types, domain });\n    return verifyHash(client, {\n        address,\n        factory: factory,\n        factoryData: factoryData,\n        hash,\n        signature,\n        ...callRequest,\n    });\n}\n//# sourceMappingURL=verifyTypedData.js.map"],"names":["async","verifyTypedData","client","parameters","address","factory","factoryData","signature","message","primaryType","types","domain","callRequest","hash","hashTypedData","verifyHash"],"mappings":"oHAWOA,eAAeC,EAAgBC,EAAQC,GAC1C,MAAMC,QAAEA,EAAOC,QAAEA,EAAOC,YAAEA,EAAWC,UAAEA,EAASC,QAAEA,EAAOC,YAAEA,EAAWC,MAAEA,EAAKC,OAAEA,KAAWC,GAAgBT,EACpGU,EAAOC,EAAc,CAAEN,UAASC,cAAaC,QAAOC,WAC1D,OAAOI,EAAWb,EAAQ,CACtBE,UACAC,QAASA,EACTC,YAAaA,EACbO,OACAN,eACGK,GAEX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"waitForTransactionReceipt.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js"],"sourcesContent":["import { BlockNotFoundError } from '../../errors/block.js';\nimport { TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError, } from '../../errors/transaction.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { observe } from '../../utils/observe.js';\nimport { withResolvers } from '../../utils/promise/withResolvers.js';\nimport { withRetry, } from '../../utils/promise/withRetry.js';\nimport { stringify } from '../../utils/stringify.js';\nimport { getBlock } from './getBlock.js';\nimport { getTransaction, } from './getTransaction.js';\nimport { getTransactionReceipt, } from './getTransactionReceipt.js';\nimport { watchBlockNumber, } from './watchBlockNumber.js';\n/**\n * Waits for the [Transaction](https://viem.sh/docs/glossary/terms#transaction) to be included on a [Block](https://viem.sh/docs/glossary/terms#block) (one confirmation), and then returns the [Transaction Receipt](https://viem.sh/docs/glossary/terms#transaction-receipt).\n *\n * - Docs: https://viem.sh/docs/actions/public/waitForTransactionReceipt\n * - Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_sending-transactions\n * - JSON-RPC Methods:\n *   - Polls [`eth_getTransactionReceipt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionReceipt) on each block until it has been processed.\n *   - If a Transaction has been replaced:\n *     - Calls [`eth_getBlockByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblockbynumber) and extracts the transactions\n *     - Checks if one of the Transactions is a replacement\n *     - If so, calls [`eth_getTransactionReceipt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionReceipt).\n *\n * The `waitForTransactionReceipt` action additionally supports Replacement detection (e.g. sped up Transactions).\n *\n * Transactions can be replaced when a user modifies their transaction in their wallet (to speed up or cancel). Transactions are replaced when they are sent from the same nonce.\n *\n * There are 3 types of Transaction Replacement reasons:\n *\n * - `repriced`: The gas price has been modified (e.g. different `maxFeePerGas`)\n * - `cancelled`: The Transaction has been cancelled (e.g. `value === 0n`)\n * - `replaced`: The Transaction has been replaced (e.g. different `value` or `data`)\n *\n * @param client - Client to use\n * @param parameters - {@link WaitForTransactionReceiptParameters}\n * @returns The transaction receipt. {@link WaitForTransactionReceiptReturnType}\n *\n * @example\n * import { createPublicClient, waitForTransactionReceipt, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const transactionReceipt = await waitForTransactionReceipt(client, {\n *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',\n * })\n */\nexport async function waitForTransactionReceipt(client, parameters) {\n    const { checkReplacement = true, confirmations = 1, hash, onReplaced, retryCount = 6, retryDelay = ({ count }) => ~~(1 << count) * 200, // exponential backoff\n    timeout = 180_000, } = parameters;\n    const observerId = stringify(['waitForTransactionReceipt', client.uid, hash]);\n    const pollingInterval = (() => {\n        if (parameters.pollingInterval)\n            return parameters.pollingInterval;\n        if (client.chain?.experimental_preconfirmationTime)\n            return client.chain.experimental_preconfirmationTime;\n        return client.pollingInterval;\n    })();\n    let transaction;\n    let replacedTransaction;\n    let receipt;\n    let retrying = false;\n    let _unobserve;\n    let _unwatch;\n    const { promise, resolve, reject } = withResolvers();\n    const timer = timeout\n        ? setTimeout(() => {\n            _unwatch?.();\n            _unobserve?.();\n            reject(new WaitForTransactionReceiptTimeoutError({ hash }));\n        }, timeout)\n        : undefined;\n    _unobserve = observe(observerId, { onReplaced, resolve, reject }, async (emit) => {\n        receipt = await getAction(client, getTransactionReceipt, 'getTransactionReceipt')({ hash }).catch(() => undefined);\n        if (receipt && confirmations <= 1) {\n            clearTimeout(timer);\n            emit.resolve(receipt);\n            _unobserve?.();\n            return;\n        }\n        _unwatch = getAction(client, watchBlockNumber, 'watchBlockNumber')({\n            emitMissed: true,\n            emitOnBegin: true,\n            poll: true,\n            pollingInterval,\n            async onBlockNumber(blockNumber_) {\n                const done = (fn) => {\n                    clearTimeout(timer);\n                    _unwatch?.();\n                    fn();\n                    _unobserve?.();\n                };\n                let blockNumber = blockNumber_;\n                if (retrying)\n                    return;\n                try {\n                    // If we already have a valid receipt, let's check if we have enough\n                    // confirmations. If we do, then we can resolve.\n                    if (receipt) {\n                        if (confirmations > 1 &&\n                            (!receipt.blockNumber ||\n                                blockNumber - receipt.blockNumber + 1n < confirmations))\n                            return;\n                        done(() => emit.resolve(receipt));\n                        return;\n                    }\n                    // Get the transaction to check if it's been replaced.\n                    // We need to retry as some RPC Providers may be slow to sync\n                    // up mined transactions.\n                    if (checkReplacement && !transaction) {\n                        retrying = true;\n                        await withRetry(async () => {\n                            transaction = (await getAction(client, getTransaction, 'getTransaction')({ hash }));\n                            if (transaction.blockNumber)\n                                blockNumber = transaction.blockNumber;\n                        }, {\n                            delay: retryDelay,\n                            retryCount,\n                        });\n                        retrying = false;\n                    }\n                    // Get the receipt to check if it's been processed.\n                    receipt = await getAction(client, getTransactionReceipt, 'getTransactionReceipt')({ hash });\n                    // Check if we have enough confirmations. If not, continue polling.\n                    if (confirmations > 1 &&\n                        (!receipt.blockNumber ||\n                            blockNumber - receipt.blockNumber + 1n < confirmations))\n                        return;\n                    done(() => emit.resolve(receipt));\n                }\n                catch (err) {\n                    // If the receipt is not found, the transaction will be pending.\n                    // We need to check if it has potentially been replaced.\n                    if (err instanceof TransactionNotFoundError ||\n                        err instanceof TransactionReceiptNotFoundError) {\n                        if (!transaction) {\n                            retrying = false;\n                            return;\n                        }\n                        try {\n                            replacedTransaction = transaction;\n                            // Let's retrieve the transactions from the current block.\n                            // We need to retry as some RPC Providers may be slow to sync\n                            // up mined blocks.\n                            retrying = true;\n                            const block = await withRetry(() => getAction(client, getBlock, 'getBlock')({\n                                blockNumber,\n                                includeTransactions: true,\n                            }), {\n                                delay: retryDelay,\n                                retryCount,\n                                shouldRetry: ({ error }) => error instanceof BlockNotFoundError,\n                            });\n                            retrying = false;\n                            const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from &&\n                                nonce === replacedTransaction.nonce);\n                            // If we couldn't find a replacement transaction, continue polling.\n                            if (!replacementTransaction)\n                                return;\n                            // If we found a replacement transaction, return it's receipt.\n                            receipt = await getAction(client, getTransactionReceipt, 'getTransactionReceipt')({\n                                hash: replacementTransaction.hash,\n                            });\n                            // Check if we have enough confirmations. If not, continue polling.\n                            if (confirmations > 1 &&\n                                (!receipt.blockNumber ||\n                                    blockNumber - receipt.blockNumber + 1n < confirmations))\n                                return;\n                            let reason = 'replaced';\n                            if (replacementTransaction.to === replacedTransaction.to &&\n                                replacementTransaction.value === replacedTransaction.value &&\n                                replacementTransaction.input === replacedTransaction.input) {\n                                reason = 'repriced';\n                            }\n                            else if (replacementTransaction.from === replacementTransaction.to &&\n                                replacementTransaction.value === 0n) {\n                                reason = 'cancelled';\n                            }\n                            done(() => {\n                                emit.onReplaced?.({\n                                    reason,\n                                    replacedTransaction: replacedTransaction,\n                                    transaction: replacementTransaction,\n                                    transactionReceipt: receipt,\n                                });\n                                emit.resolve(receipt);\n                            });\n                        }\n                        catch (err_) {\n                            done(() => emit.reject(err_));\n                        }\n                    }\n                    else {\n                        done(() => emit.reject(err));\n                    }\n                }\n            },\n        });\n    });\n    return promise;\n}\n//# sourceMappingURL=waitForTransactionReceipt.js.map"],"names":["async","waitForTransactionReceipt","client","parameters","checkReplacement","confirmations","hash","onReplaced","retryCount","retryDelay","count","timeout","observerId","stringify","uid","pollingInterval","chain","experimental_preconfirmationTime","transaction","replacedTransaction","receipt","_unobserve","_unwatch","retrying","promise","resolve","reject","withResolvers","timer","setTimeout","WaitForTransactionReceiptTimeoutError","undefined","observe","emit","getAction","getTransactionReceipt","catch","clearTimeout","watchBlockNumber","emitMissed","emitOnBegin","poll","onBlockNumber","blockNumber_","done","fn","blockNumber","withRetry","getTransaction","delay","err","TransactionNotFoundError","TransactionReceiptNotFoundError","block","getBlock","includeTransactions","shouldRetry","error","BlockNotFoundError","replacementTransaction","transactions","find","from","nonce","reason","to","value","input","transactionReceipt","err_"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/watchBlockNumber.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"watchBlockNumber.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/watchBlockNumber.js"],"sourcesContent":["import { hexToBigInt } from '../../utils/encoding/fromHex.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { observe } from '../../utils/observe.js';\nimport { poll } from '../../utils/poll.js';\nimport { stringify } from '../../utils/stringify.js';\nimport { getBlockNumber, } from './getBlockNumber.js';\n/**\n * Watches and returns incoming block numbers.\n *\n * - Docs: https://viem.sh/docs/actions/public/watchBlockNumber\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_watching-blocks\n * - JSON-RPC Methods:\n *   - When `poll: true`, calls [`eth_blockNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_blocknumber) on a polling interval.\n *   - When `poll: false` & WebSocket Transport, uses a WebSocket subscription via [`eth_subscribe`](https://docs.alchemy.com/reference/eth-subscribe-polygon) and the `\"newHeads\"` event.\n *\n * @param client - Client to use\n * @param parameters - {@link WatchBlockNumberParameters}\n * @returns A function that can be invoked to stop watching for new block numbers. {@link WatchBlockNumberReturnType}\n *\n * @example\n * import { createPublicClient, watchBlockNumber, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const unwatch = watchBlockNumber(client, {\n *   onBlockNumber: (blockNumber) => console.log(blockNumber),\n * })\n */\nexport function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval, }) {\n    const enablePolling = (() => {\n        if (typeof poll_ !== 'undefined')\n            return poll_;\n        if (client.transport.type === 'webSocket' ||\n            client.transport.type === 'ipc')\n            return false;\n        if (client.transport.type === 'fallback' &&\n            (client.transport.transports[0].config.type === 'webSocket' ||\n                client.transport.transports[0].config.type === 'ipc'))\n            return false;\n        return true;\n    })();\n    let prevBlockNumber;\n    const pollBlockNumber = () => {\n        const observerId = stringify([\n            'watchBlockNumber',\n            client.uid,\n            emitOnBegin,\n            emitMissed,\n            pollingInterval,\n        ]);\n        return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {\n            try {\n                const blockNumber = await getAction(client, getBlockNumber, 'getBlockNumber')({ cacheTime: 0 });\n                if (prevBlockNumber !== undefined) {\n                    // If the current block number is the same as the previous,\n                    // we can skip.\n                    if (blockNumber === prevBlockNumber)\n                        return;\n                    // If we have missed out on some previous blocks, and the\n                    // `emitMissed` flag is truthy, let's emit those blocks.\n                    if (blockNumber - prevBlockNumber > 1 && emitMissed) {\n                        for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {\n                            emit.onBlockNumber(i, prevBlockNumber);\n                            prevBlockNumber = i;\n                        }\n                    }\n                }\n                // If the next block number is greater than the previous,\n                // it is not in the past, and we can emit the new block number.\n                if (prevBlockNumber === undefined ||\n                    blockNumber > prevBlockNumber) {\n                    emit.onBlockNumber(blockNumber, prevBlockNumber);\n                    prevBlockNumber = blockNumber;\n                }\n            }\n            catch (err) {\n                emit.onError?.(err);\n            }\n        }, {\n            emitOnBegin,\n            interval: pollingInterval,\n        }));\n    };\n    const subscribeBlockNumber = () => {\n        const observerId = stringify([\n            'watchBlockNumber',\n            client.uid,\n            emitOnBegin,\n            emitMissed,\n        ]);\n        return observe(observerId, { onBlockNumber, onError }, (emit) => {\n            let active = true;\n            let unsubscribe = () => (active = false);\n            (async () => {\n                try {\n                    const transport = (() => {\n                        if (client.transport.type === 'fallback') {\n                            const transport = client.transport.transports.find((transport) => transport.config.type === 'webSocket' ||\n                                transport.config.type === 'ipc');\n                            if (!transport)\n                                return client.transport;\n                            return transport.value;\n                        }\n                        return client.transport;\n                    })();\n                    const { unsubscribe: unsubscribe_ } = await transport.subscribe({\n                        params: ['newHeads'],\n                        onData(data) {\n                            if (!active)\n                                return;\n                            const blockNumber = hexToBigInt(data.result?.number);\n                            emit.onBlockNumber(blockNumber, prevBlockNumber);\n                            prevBlockNumber = blockNumber;\n                        },\n                        onError(error) {\n                            emit.onError?.(error);\n                        },\n                    });\n                    unsubscribe = unsubscribe_;\n                    if (!active)\n                        unsubscribe();\n                }\n                catch (err) {\n                    onError?.(err);\n                }\n            })();\n            return () => unsubscribe();\n        });\n    };\n    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();\n}\n//# sourceMappingURL=watchBlockNumber.js.map"],"names":["watchBlockNumber","client","emitOnBegin","emitMissed","onBlockNumber","onError","poll","poll_","pollingInterval","prevBlockNumber","transport","type","transports","config","observerId","stringify","uid","observe","emit","async","blockNumber","getAction","getBlockNumber","cacheTime","undefined","i","err","interval","pollBlockNumber","active","unsubscribe","find","value","unsubscribe_","subscribe","params","onData","data","hexToBigInt","result","number","error","subscribeBlockNumber"],"mappings":"yTA+BO,SAASA,EAAiBC,GAAQC,YAAEA,GAAc,EAAKC,WAAEA,GAAa,EAAKC,cAAEA,EAAaC,QAAEA,EAASC,KAAMC,EAAKC,gBAAEA,EAAkBP,EAAOO,kBAa9I,IAAIC,EAwFJ,YAnGyB,IAAVF,EACAA,EACmB,cAA1BN,EAAOS,UAAUC,MACS,QAA1BV,EAAOS,UAAUC,OAES,aAA1BV,EAAOS,UAAUC,MAC+B,cAA/CV,EAAOS,UAAUE,WAAW,GAAGC,OAAOF,MACY,QAA/CV,EAAOS,UAAUE,WAAW,GAAGC,OAAOF,OAK1B,MACpB,MAAMG,EAAaC,EAAU,CACzB,mBACAd,EAAOe,IACPd,EACAC,EACAK,IAEJ,OAAOS,EAAQH,EAAY,CAAEV,gBAAeC,WAAYa,GAASZ,EAAKa,UAClE,IACI,MAAMC,QAAoBC,EAAUpB,EAAQqB,EAAgB,iBAAlCD,CAAoD,CAAEE,UAAW,IAC3F,QAAwBC,IAApBf,EAA+B,CAG/B,GAAIW,IAAgBX,EAChB,OAGJ,GAAIW,EAAcX,EAAkB,GAAKN,EACrC,IAAK,IAAIsB,EAAIhB,EAAkB,GAAIgB,EAAIL,EAAaK,IAChDP,EAAKd,cAAcqB,EAAGhB,GACtBA,EAAkBgB,CAG9B,OAGwBD,IAApBf,GACAW,EAAcX,KACdS,EAAKd,cAAcgB,EAAaX,GAChCA,EAAkBW,EAE1B,CACA,MAAOM,GACHR,EAAKb,UAAUqB,EACnB,GACD,CACCxB,cACAyB,SAAUnB,MAiDKoB,GA9CM,MACzB,MAAMd,EAAaC,EAAU,CACzB,mBACAd,EAAOe,IACPd,EACAC,IAEJ,OAAOc,EAAQH,EAAY,CAAEV,gBAAeC,WAAYa,IACpD,IAAIW,GAAS,EACTC,EAAc,IAAOD,GAAS,EAkClC,MAjCA,WACI,IACI,MAAMnB,EAAY,MACd,GAA8B,aAA1BT,EAAOS,UAAUC,KAAqB,CACtC,MAAMD,EAAYT,EAAOS,UAAUE,WAAWmB,KAAMrB,GAAwC,cAA1BA,EAAUG,OAAOF,MACrD,QAA1BD,EAAUG,OAAOF,MACrB,OAAKD,EAEEA,EAAUsB,MADN/B,EAAOS,SAEtB,CACA,OAAOT,EAAOS,SACjB,EATiB,IAUVoB,YAAaG,SAAuBvB,EAAUwB,UAAU,CAC5DC,OAAQ,CAAC,YACT,MAAAC,CAAOC,GACH,IAAKR,EACD,OACJ,MAAMT,EAAckB,EAAYD,EAAKE,QAAQC,QAC7CtB,EAAKd,cAAcgB,EAAaX,GAChCA,EAAkBW,CACtB,EACA,OAAAf,CAAQoC,GACJvB,EAAKb,UAAUoC,EACnB,IAEJX,EAAcG,EACTJ,GACDC,GACR,CACA,MAAOJ,GACHrB,IAAUqB,EACd,CACH,EAhCD,GAiCO,IAAMI,OAGsBY,EAC/C","x_google_ignoreList":[0]}

package/dist/esm/node_modules/viem/_esm/actions/public/watchBlocks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"watchBlocks.js","sources":["../../../../../../../node_modules/viem/_esm/actions/public/watchBlocks.js"],"sourcesContent":["import { getAction } from '../../utils/getAction.js';\nimport { observe } from '../../utils/observe.js';\nimport { poll } from '../../utils/poll.js';\nimport { stringify } from '../../utils/stringify.js';\nimport { getBlock } from './getBlock.js';\n/**\n * Watches and returns information for incoming blocks.\n *\n * - Docs: https://viem.sh/docs/actions/public/watchBlocks\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_watching-blocks\n * - JSON-RPC Methods:\n *   - When `poll: true`, calls [`eth_getBlockByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getBlockByNumber) on a polling interval.\n *   - When `poll: false` & WebSocket Transport, uses a WebSocket subscription via [`eth_subscribe`](https://docs.alchemy.com/reference/eth-subscribe-polygon) and the `\"newHeads\"` event.\n *\n * @param client - Client to use\n * @param parameters - {@link WatchBlocksParameters}\n * @returns A function that can be invoked to stop watching for new block numbers. {@link WatchBlocksReturnType}\n *\n * @example\n * import { createPublicClient, watchBlocks, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const unwatch = watchBlocks(client, {\n *   onBlock: (block) => console.log(block),\n * })\n */\nexport function watchBlocks(client, { blockTag = client.experimental_blockTag ?? 'latest', emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval, }) {\n    const enablePolling = (() => {\n        if (typeof poll_ !== 'undefined')\n            return poll_;\n        if (client.transport.type === 'webSocket' ||\n            client.transport.type === 'ipc')\n            return false;\n        if (client.transport.type === 'fallback' &&\n            (client.transport.transports[0].config.type === 'webSocket' ||\n                client.transport.transports[0].config.type === 'ipc'))\n            return false;\n        return true;\n    })();\n    const includeTransactions = includeTransactions_ ?? false;\n    let prevBlock;\n    const pollBlocks = () => {\n        const observerId = stringify([\n            'watchBlocks',\n            client.uid,\n            blockTag,\n            emitMissed,\n            emitOnBegin,\n            includeTransactions,\n            pollingInterval,\n        ]);\n        return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {\n            try {\n                const block = await getAction(client, getBlock, 'getBlock')({\n                    blockTag,\n                    includeTransactions,\n                });\n                if (block.number !== null && prevBlock?.number != null) {\n                    // If the current block number is the same as the previous,\n                    // we can skip.\n                    if (block.number === prevBlock.number)\n                        return;\n                    // If we have missed out on some previous blocks, and the\n                    // `emitMissed` flag is truthy, let's emit those blocks.\n                    if (block.number - prevBlock.number > 1 && emitMissed) {\n                        for (let i = prevBlock?.number + 1n; i < block.number; i++) {\n                            const block = (await getAction(client, getBlock, 'getBlock')({\n                                blockNumber: i,\n                                includeTransactions,\n                            }));\n                            emit.onBlock(block, prevBlock);\n                            prevBlock = block;\n                        }\n                    }\n                }\n                if (\n                // If no previous block exists, emit.\n                prevBlock?.number == null ||\n                    // If the block tag is \"pending\" with no block number, emit.\n                    (blockTag === 'pending' && block?.number == null) ||\n                    // If the next block number is greater than the previous block number, emit.\n                    // We don't want to emit blocks in the past.\n                    (block.number !== null && block.number > prevBlock.number)) {\n                    emit.onBlock(block, prevBlock);\n                    prevBlock = block;\n                }\n            }\n            catch (err) {\n                emit.onError?.(err);\n            }\n        }, {\n            emitOnBegin,\n            interval: pollingInterval,\n        }));\n    };\n    const subscribeBlocks = () => {\n        let active = true;\n        let emitFetched = true;\n        let unsubscribe = () => (active = false);\n        (async () => {\n            try {\n                if (emitOnBegin) {\n                    getAction(client, getBlock, 'getBlock')({\n                        blockTag,\n                        includeTransactions,\n                    })\n                        .then((block) => {\n                        if (!active)\n                            return;\n                        if (!emitFetched)\n                            return;\n                        onBlock(block, undefined);\n                        emitFetched = false;\n                    })\n                        .catch(onError);\n                }\n                const transport = (() => {\n                    if (client.transport.type === 'fallback') {\n                        const transport = client.transport.transports.find((transport) => transport.config.type === 'webSocket' ||\n                            transport.config.type === 'ipc');\n                        if (!transport)\n                            return client.transport;\n                        return transport.value;\n                    }\n                    return client.transport;\n                })();\n                const { unsubscribe: unsubscribe_ } = await transport.subscribe({\n                    params: ['newHeads'],\n                    async onData(data) {\n                        if (!active)\n                            return;\n                        const block = (await getAction(client, getBlock, 'getBlock')({\n                            blockNumber: data.result?.number,\n                            includeTransactions,\n                        }).catch(() => { }));\n                        if (!active)\n                            return;\n                        onBlock(block, prevBlock);\n                        emitFetched = false;\n                        prevBlock = block;\n                    },\n                    onError(error) {\n                        onError?.(error);\n                    },\n                });\n                unsubscribe = unsubscribe_;\n                if (!active)\n                    unsubscribe();\n            }\n            catch (err) {\n                onError?.(err);\n            }\n        })();\n        return () => unsubscribe();\n    };\n    return enablePolling ? pollBlocks() : subscribeBlocks();\n}\n//# sourceMappingURL=watchBlocks.js.map"],"names":["watchBlocks","client","blockTag","experimental_blockTag","emitMissed","emitOnBegin","onBlock","onError","includeTransactions","includeTransactions_","poll","poll_","pollingInterval","enablePolling","transport","type","transports","config","prevBlock","observerId","stringify","uid","observe","emit","async","block","getAction","getBlock","number","i","blockNumber","err","interval","pollBlocks","active","emitFetched","unsubscribe","then","undefined","catch","find","value","unsubscribe_","subscribe","params","onData","data","result","error","subscribeBlocks"],"mappings":"+OA8BO,SAASA,EAAYC,GAAQC,SAAEA,EAAWD,EAAOE,uBAAyB,SAAQC,WAAEA,GAAa,EAAKC,YAAEA,GAAc,EAAKC,QAAEA,EAAOC,QAAEA,EAASC,oBAAqBC,EAAsBC,KAAMC,EAAKC,gBAAEA,EAAkBX,EAAOW,kBACnO,MAAMC,OACmB,IAAVF,EACAA,EACmB,cAA1BV,EAAOa,UAAUC,MACS,QAA1Bd,EAAOa,UAAUC,OAES,aAA1Bd,EAAOa,UAAUC,MAC+B,cAA/Cd,EAAOa,UAAUE,WAAW,GAAGC,OAAOF,MACY,QAA/Cd,EAAOa,UAAUE,WAAW,GAAGC,OAAOF,MAI5CP,EAAsBC,IAAwB,EACpD,IAAIS,EAmHJ,OAAOL,EAlHY,MACf,MAAMM,EAAaC,EAAU,CACzB,cACAnB,EAAOoB,IACPnB,EACAE,EACAC,EACAG,EACAI,IAEJ,OAAOU,EAAQH,EAAY,CAAEb,UAASC,WAAYgB,GAASb,EAAKc,UAC5D,IACI,MAAMC,QAAcC,EAAUzB,EAAQ0B,EAAU,WAA5BD,CAAwC,CACxDxB,WACAM,wBAEJ,GAAqB,OAAjBiB,EAAMG,QAAwC,MAArBV,GAAWU,OAAgB,CAGpD,GAAIH,EAAMG,SAAWV,EAAUU,OAC3B,OAGJ,GAAIH,EAAMG,OAASV,EAAUU,OAAS,GAAKxB,EACvC,IAAK,IAAIyB,EAAIX,GAAWU,OAAS,GAAIC,EAAIJ,EAAMG,OAAQC,IAAK,CACxD,MAAMJ,QAAeC,EAAUzB,EAAQ0B,EAAU,WAA5BD,CAAwC,CACzDI,YAAaD,EACbrB,wBAEJe,EAAKjB,QAAQmB,EAAOP,GACpBA,EAAYO,CAChB,CAER,EAGqB,MAArBP,GAAWU,QAEO,YAAb1B,GAA2C,MAAjBuB,GAAOG,QAGhB,OAAjBH,EAAMG,QAAmBH,EAAMG,OAASV,EAAUU,UACnDL,EAAKjB,QAAQmB,EAAOP,GACpBA,EAAYO,EAEpB,CACA,MAAOM,GACHR,EAAKhB,UAAUwB,EACnB,GACD,CACC1B,cACA2B,SAAUpB,MA+DKqB,GA5DC,MACpB,IAAIC,GAAS,EACTC,GAAc,EACdC,EAAc,IAAOF,GAAS,EAuDlC,MAtDA,WACI,IACQ7B,GACAqB,EAAUzB,EAAQ0B,EAAU,WAA5BD,CAAwC,CACpCxB,WACAM,wBAEC6B,KAAMZ,IACFS,GAEAC,IAEL7B,EAAQmB,OAAOa,GACfH,GAAc,KAEbI,MAAMhC,GAEf,MAAMO,EAAY,MACd,GAA8B,aAA1Bb,EAAOa,UAAUC,KAAqB,CACtC,MAAMD,EAAYb,EAAOa,UAAUE,WAAWwB,KAAM1B,GAAwC,cAA1BA,EAAUG,OAAOF,MACrD,QAA1BD,EAAUG,OAAOF,MACrB,OAAKD,EAEEA,EAAU2B,MADNxC,EAAOa,SAEtB,CACA,OAAOb,EAAOa,SACjB,EATiB,IAUVsB,YAAaM,SAAuB5B,EAAU6B,UAAU,CAC5DC,OAAQ,CAAC,YACT,YAAMC,CAAOC,GACT,IAAKZ,EACD,OACJ,MAAMT,QAAeC,EAAUzB,EAAQ0B,EAAU,WAA5BD,CAAwC,CACzDI,YAAagB,EAAKC,QAAQnB,OAC1BpB,wBACD+B,MAAM,QACJL,IAEL5B,EAAQmB,EAAOP,GACfiB,GAAc,EACdjB,EAAYO,EAChB,EACA,OAAAlB,CAAQyC,GACJzC,IAAUyC,EACd,IAEJZ,EAAcM,EACTR,GACDE,GACR,CACA,MAAOL,GACHxB,IAAUwB,EACd,CACH,EArDD,GAsDO,IAAMK,KAEqBa,EAC1C","x_google_ignoreList":[0]}