viem 1.16.6 → 1.17.1

package/actions/public/estimateContractGas.ts

@@ -20,6 +20,7 @@ import {
   type GetContractErrorReturnType,
   getContractError,
 } from '../../utils/errors/getContractError.js'
+import { getAction } from '../../utils/getAction.js'
 import {
   type EstimateGasErrorType,
   type EstimateGasParameters,
@@ -95,7 +96,10 @@ export async function estimateContractGas<
     functionName,
   } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
   try {
-    const gas = await estimateGas(client, {
+    const gas = await getAction(
+      client,
+      estimateGas,
+    )({
       data,
       to: address,
       ...request,

package/actions/public/estimateFeesPerGas.ts

@@ -19,6 +19,7 @@ import type {
   FeeValuesLegacy,
   FeeValuesType,
 } from '../../types/fee.js'
+import { getAction } from '../../utils/getAction.js'
 import type { PrepareTransactionRequestParameters } from '../wallet/prepareTransactionRequest.js'
 import {
   type EstimateMaxPriorityFeePerGasErrorType,
@@ -125,7 +126,7 @@ export async function internal_estimateFeesPerGas<
     (base * BigInt(Math.ceil(baseFeeMultiplier * denominator))) /
     BigInt(denominator)
 
-  const block = block_ ? block_ : await getBlock(client)
+  const block = block_ ? block_ : await getAction(client, getBlock)({})
 
   if (typeof chain?.fees?.estimateFeesPerGas === 'function')
     return chain.fees.estimateFeesPerGas({
@@ -161,7 +162,8 @@ export async function internal_estimateFeesPerGas<
     } as EstimateFeesPerGasReturnType<type>
   }
 
-  const gasPrice = request?.gasPrice ?? multiply(await getGasPrice(client))
+  const gasPrice =
+    request?.gasPrice ?? multiply(await getAction(client, getGasPrice)({}))
   return {
     gasPrice,
   } as EstimateFeesPerGasReturnType<type>

package/actions/public/estimateMaxPriorityFeePerGas.ts

@@ -14,6 +14,7 @@ import {
   type HexToBigIntErrorType,
   hexToBigInt,
 } from '../../utils/encoding/fromHex.js'
+import { getAction } from '../../utils/getAction.js'
 import type { PrepareTransactionRequestParameters } from '../wallet/prepareTransactionRequest.js'
 import { type GetBlockErrorType, getBlock } from './getBlock.js'
 import { type GetGasPriceErrorType, getGasPrice } from './getGasPrice.js'
@@ -82,7 +83,7 @@ export async function internal_estimateMaxPriorityFeePerGas<
 ): Promise<EstimateMaxPriorityFeePerGasReturnType> {
   const { block: block_, chain = client.chain, request } = args || {}
   if (typeof chain?.fees?.defaultPriorityFee === 'function') {
-    const block = block_ || (await getBlock(client))
+    const block = block_ || (await getAction(client, getBlock)({}))
     return chain.fees.defaultPriorityFee({
       block,
       client,
@@ -101,8 +102,8 @@ export async function internal_estimateMaxPriorityFeePerGas<
     // fall back to calculating it manually via `gasPrice - baseFeePerGas`.
     // See: https://github.com/ethereum/pm/issues/328#:~:text=eth_maxPriorityFeePerGas%20after%20London%20will%20effectively%20return%20eth_gasPrice%20%2D%20baseFee
     const [block, gasPrice] = await Promise.all([
-      block_ ? Promise.resolve(block_) : getBlock(client),
-      getGasPrice(client),
+      block_ ? Promise.resolve(block_) : getAction(client, getBlock)({}),
+      getAction(client, getGasPrice)({}),
     ])
 
     if (typeof block.baseFeePerGas !== 'bigint')

package/actions/public/getContractEvents.ts

@@ -13,6 +13,7 @@ import {
   type GetAbiItemParameters,
   getAbiItem,
 } from '../../utils/abi/getAbiItem.js'
+import { getAction } from '../../utils/getAction.js'
 import {
   type GetLogsErrorType,
   type GetLogsParameters,
@@ -130,7 +131,10 @@ export async function getContractEvents<
   const events = !event
     ? (abi as Abi).filter((x) => x.type === 'event')
     : undefined
-  return getLogs(client, {
+  return getAction(
+    client,
+    getLogs,
+  )({
     address,
     args,
     blockHash,

package/actions/public/getTransactionConfirmations.ts

@@ -4,6 +4,7 @@ import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 import type { FormattedTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
+import { getAction } from '../../utils/getAction.js'
 
 import {
   type GetBlockNumberErrorType,
@@ -66,8 +67,8 @@ export async function getTransactionConfirmations<
   { hash, transactionReceipt }: GetTransactionConfirmationsParameters<TChain>,
 ): Promise<GetTransactionConfirmationsReturnType> {
   const [blockNumber, transaction] = await Promise.all([
-    getBlockNumber(client),
-    hash ? getTransaction(client, { hash }) : undefined,
+    getAction(client, getBlockNumber)({}),
+    hash ? getAction(client, getTransaction)({ hash }) : undefined,
   ])
   const transactionBlockNumber =
     transactionReceipt?.blockNumber || transaction?.blockNumber

package/actions/public/multicall.ts

@@ -32,6 +32,7 @@ import {
 } from '../../utils/errors/getContractError.js'
 
 import type { ErrorType } from '../../errors/utils.js'
+import { getAction } from '../../utils/getAction.js'
 import type { CallParameters } from './call.js'
 import { type ReadContractErrorType, readContract } from './readContract.js'
 
@@ -200,7 +201,10 @@ export async function multicall<
 
   const aggregate3Results = await Promise.allSettled(
     chunkedCalls.map((calls) =>
-      readContract(client, {
+      getAction(
+        client,
+        readContract,
+      )({
         abi: multicall3Abi,
         address: multicallAddress!,
         args: [calls],

package/actions/public/readContract.ts

@@ -22,6 +22,7 @@ import {
   type GetContractErrorReturnType,
   getContractError,
 } from '../../utils/errors/getContractError.js'
+import { getAction } from '../../utils/getAction.js'
 
 import { type CallErrorType, type CallParameters, call } from './call.js'
 
@@ -91,7 +92,10 @@ export async function readContract<
     functionName,
   } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
   try {
-    const { data } = await call(client, {
+    const { data } = await getAction(
+      client,
+      call,
+    )({
       data: calldata,
       to: address,
       ...callRequest,

package/actions/public/simulateContract.ts

@@ -32,6 +32,7 @@ import {
 import type { WriteContractParameters } from '../wallet/writeContract.js'
 
 import type { ErrorType } from '../../errors/utils.js'
+import { getAction } from '../../utils/getAction.js'
 import { type CallErrorType, type CallParameters, call } from './call.js'
 
 export type SimulateContractParameters<
@@ -142,7 +143,10 @@ export async function simulateContract<
     functionName,
   } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
   try {
-    const { data } = await call(client, {
+    const { data } = await getAction(
+      client,
+      call,
+    )({
       batch: false,
       data: `${calldata}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
       to: address,

package/actions/public/verifyHash.ts

@@ -15,6 +15,7 @@ import {
 } from '../../utils/data/isBytesEqual.js'
 import type { IsHexErrorType } from '../../utils/data/isHex.js'
 import type { ToHexErrorType } from '../../utils/encoding/toHex.js'
+import { getAction } from '../../utils/getAction.js'
 import { encodeDeployData, isHex, toHex } from '../../utils/index.js'
 import { type CallErrorType, type CallParameters, call } from './call.js'
 
@@ -54,7 +55,10 @@ export async function verifyHash<TChain extends Chain | undefined,>(
   const signatureHex = isHex(signature) ? signature : toHex(signature)
 
   try {
-    const { data } = await call(client, {
+    const { data } = await getAction(
+      client,
+      call,
+    )({
       data: encodeDeployData({
         abi: universalSignatureValidatorAbi,
         args: [address, hash, signatureHex],

package/actions/public/waitForTransactionReceipt.ts

@@ -9,6 +9,7 @@ import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 import type { Transaction } from '../../types/transaction.js'
+import { getAction } from '../../utils/getAction.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { withRetry } from '../../utils/promise/withRetry.js'
 import { stringify } from '../../utils/stringify.js'
@@ -140,7 +141,10 @@ export async function waitForTransactionReceipt<
       observerId,
       { onReplaced, resolve, reject },
       (emit) => {
-        const _unwatch = watchBlockNumber(client, {
+        const _unwatch = getAction(
+          client,
+          watchBlockNumber,
+        )({
           emitMissed: true,
           emitOnBegin: true,
           poll: true,
@@ -178,7 +182,10 @@ export async function waitForTransactionReceipt<
                 retrying = true
                 await withRetry(
                   async () => {
-                    transaction = await getTransaction(client, { hash })
+                    transaction = (await getAction(
+                      client,
+                      getTransaction,
+                    )({ hash })) as GetTransactionReturnType<TChain>
                     if (transaction.blockNumber)
                       blockNumber = transaction.blockNumber
                   },
@@ -192,7 +199,7 @@ export async function waitForTransactionReceipt<
               }
 
               // Get the receipt to check if it's been processed.
-              receipt = await getTransactionReceipt(client, { hash })
+              receipt = await getAction(client, getTransactionReceipt)({ hash })
 
               // Check if we have enough confirmations. If not, continue polling.
               if (
@@ -215,13 +222,16 @@ export async function waitForTransactionReceipt<
                   replacedTransaction = transaction
 
                   // Let's retrieve the transactions from the current block.
-                  const block = await getBlock(client, {
+                  const block = await getAction(
+                    client,
+                    getBlock,
+                  )({
                     blockNumber,
                     includeTransactions: true,
                   })
 
                   const replacementTransaction = (
-                    block.transactions as Transaction[]
+                    block.transactions as {} as Transaction[]
                   ).find(
                     ({ from, nonce }) =>
                       from === replacedTransaction!.from &&
@@ -232,7 +242,10 @@ export async function waitForTransactionReceipt<
                   if (!replacementTransaction) return
 
                   // If we found a replacement transaction, return it's receipt.
-                  receipt = await getTransactionReceipt(client, {
+                  receipt = await getAction(
+                    client,
+                    getTransactionReceipt,
+                  )({
                     hash: replacementTransaction.hash,
                   })
 

package/actions/public/watchBlockNumber.ts

@@ -4,6 +4,7 @@ import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { GetTransportConfig } from '../../types/transport.js'
 import { hexToBigInt } from '../../utils/encoding/fromHex.js'
+import { getAction } from '../../utils/getAction.js'
 import { observe } from '../../utils/observe.js'
 import { type PollErrorType, poll } from '../../utils/poll.js'
 import { stringify } from '../../utils/stringify.js'
@@ -108,7 +109,10 @@ export function watchBlockNumber<
       poll(
         async () => {
           try {
-            const blockNumber = await getBlockNumber(client, { cacheTime: 0 })
+            const blockNumber = await getAction(
+              client,
+              getBlockNumber,
+            )({ cacheTime: 0 })
 
             if (prevBlockNumber) {
               // If the current block number is the same as the previous,

package/actions/public/watchBlocks.ts

@@ -5,6 +5,7 @@ import type { BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type { GetTransportConfig } from '../../types/transport.js'
 import { formatBlock } from '../../utils/formatters/block.js'
+import { getAction } from '../../utils/getAction.js'
 import { observe } from '../../utils/observe.js'
 import { type PollErrorType, poll } from '../../utils/poll.js'
 import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
@@ -140,7 +141,10 @@ export function watchBlocks<
       poll(
         async () => {
           try {
-            const block = await getBlock(client, {
+            const block = await getAction(
+              client,
+              getBlock,
+            )({
               blockTag,
               includeTransactions,
             })
@@ -153,10 +157,13 @@ export function watchBlocks<
               // `emitMissed` flag is truthy, let's emit those blocks.
               if (block.number - prevBlock.number > 1 && emitMissed) {
                 for (let i = prevBlock?.number + 1n; i < block.number; i++) {
-                  const block = await getBlock(client, {
+                  const block = (await getAction(
+                    client,
+                    getBlock,
+                  )({
                     blockNumber: i,
                     includeTransactions,
-                  })
+                  })) as GetBlockReturnType<TChain>
                   emit.onBlock(block as any, prevBlock as any)
                   prevBlock = block
                 }

package/actions/public/watchContractEvent.ts

@@ -25,6 +25,7 @@ import {
   encodeEventTopics,
 } from '../../utils/abi/encodeEventTopics.js'
 import { formatLog } from '../../utils/formatters/log.js'
+import { getAction } from '../../utils/getAction.js'
 import {
   type CreateContractEventFilterParameters,
   createContractEventFilter,
@@ -187,7 +188,10 @@ export function watchContractEvent<
         async () => {
           if (!initialized) {
             try {
-              filter = (await createContractEventFilter(client, {
+              filter = (await getAction(
+                client,
+                createContractEventFilter,
+              )({
                 abi,
                 address,
                 args,
@@ -206,19 +210,22 @@ export function watchContractEvent<
           try {
             let logs: Log[]
             if (filter) {
-              logs = await getFilterChanges(client, { filter })
+              logs = await getAction(client, getFilterChanges)({ filter })
             } else {
               // If the filter doesn't exist, we will fall back to use `getLogs`.
               // The fall back exists because some RPC Providers do not support filters.
 
               // Fetch the block number to use for `getLogs`.
-              const blockNumber = await getBlockNumber(client)
+              const blockNumber = await getAction(client, getBlockNumber)({})
 
               // If the block number has changed, we will need to fetch the logs.
               // If the block number doesn't exist, we are yet to reach the first poll interval,
               // so do not emit any logs.
               if (previousBlockNumber && previousBlockNumber !== blockNumber) {
-                logs = await getContractEvents(client, {
+                logs = await getAction(
+                  client,
+                  getContractEvents,
+                )({
                   abi,
                   address,
                   args,
@@ -250,7 +257,7 @@ export function watchContractEvent<
       )
 
       return async () => {
-        if (filter) await uninstallFilter(client, { filter })
+        if (filter) await getAction(client, uninstallFilter)({ filter })
         unwatch()
       }
     })

package/actions/public/watchEvent.ts

@@ -22,6 +22,7 @@ import {
 } from '../../errors/abi.js'
 import { InvalidInputRpcError } from '../../errors/rpc.js'
 import type { ErrorType } from '../../errors/utils.js'
+import { getAction } from '../../utils/getAction.js'
 import {
   decodeEventLog,
   encodeEventTopics,
@@ -222,7 +223,10 @@ export function watchEvent<
         async () => {
           if (!initialized) {
             try {
-              filter = (await createEventFilter(client, {
+              filter = (await getAction(
+                client,
+                createEventFilter as any,
+              )({
                 address,
                 args,
                 event: event!,
@@ -241,19 +245,22 @@ export function watchEvent<
           try {
             let logs: Log[]
             if (filter) {
-              logs = await getFilterChanges(client, { filter })
+              logs = await getAction(client, getFilterChanges)({ filter })
             } else {
               // If the filter doesn't exist, we will fall back to use `getLogs`.
               // The fall back exists because some RPC Providers do not support filters.
 
               // Fetch the block number to use for `getLogs`.
-              const blockNumber = await getBlockNumber(client)
+              const blockNumber = await getAction(client, getBlockNumber)({})
 
               // If the block number has changed, we will need to fetch the logs.
               // If the block number doesn't exist, we are yet to reach the first poll interval,
               // so do not emit any logs.
               if (previousBlockNumber && previousBlockNumber !== blockNumber) {
-                logs = await getLogs(client, {
+                logs = await getAction(
+                  client,
+                  getLogs,
+                )({
                   address,
                   args,
                   event: event!,
@@ -285,7 +292,7 @@ export function watchEvent<
       )
 
       return async () => {
-        if (filter) await uninstallFilter(client, { filter })
+        if (filter) await getAction(client, uninstallFilter)({ filter })
         unwatch()
       }
     })

package/actions/public/watchPendingTransactions.ts

@@ -5,6 +5,7 @@ import type { Chain } from '../../types/chain.js'
 import type { Filter } from '../../types/filter.js'
 import type { Hash } from '../../types/misc.js'
 import type { GetTransportConfig } from '../../types/transport.js'
+import { getAction } from '../../utils/getAction.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
 import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
@@ -125,7 +126,10 @@ export function watchPendingTransactions<
           try {
             if (!filter) {
               try {
-                filter = await createPendingTransactionFilter(client)
+                filter = await getAction(
+                  client,
+                  createPendingTransactionFilter,
+                )({})
                 return
               } catch (err) {
                 unwatch()
@@ -133,7 +137,7 @@ export function watchPendingTransactions<
               }
             }
 
-            const hashes = await getFilterChanges(client, { filter })
+            const hashes = await getAction(client, getFilterChanges)({ filter })
             if (hashes.length === 0) return
             if (batch) emit.onTransactions(hashes)
             else hashes.forEach((hash) => emit.onTransactions([hash]))
@@ -148,7 +152,7 @@ export function watchPendingTransactions<
       )
 
       return async () => {
-        if (filter) await uninstallFilter(client, { filter })
+        if (filter) await getAction(client, uninstallFilter)({ filter })
         unwatch()
       }
     })

package/actions/wallet/prepareTransactionRequest.ts

@@ -36,6 +36,7 @@ import type { GetChain } from '../../types/chain.js'
 import type { TransactionSerializable } from '../../types/transaction.js'
 import type { UnionOmit } from '../../types/utils.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import type {
   AssertRequestErrorType,
   AssertRequestParameters,
@@ -129,12 +130,15 @@ export async function prepareTransactionRequest<
   if (!account_) throw new AccountNotFoundError()
   const account = parseAccount(account_)
 
-  const block = await getBlock(client, { blockTag: 'latest' })
+  const block = await getAction(client, getBlock)({ blockTag: 'latest' })
 
   const request = { ...args, from: account.address }
 
   if (typeof nonce === 'undefined')
-    request.nonce = await getTransactionCount(client, {
+    request.nonce = await getAction(
+      client,
+      getTransactionCount,
+    )({
       address: account.address,
       blockTag: 'pending',
     })
@@ -189,7 +193,10 @@ export async function prepareTransactionRequest<
   }
 
   if (typeof gas === 'undefined')
-    request.gas = await estimateGas(client, {
+    request.gas = await getAction(
+      client,
+      estimateGas,
+    )({
       ...request,
       account: { address: account.address, type: 'json-rpc' },
     } as EstimateGasParameters)

package/actions/wallet/sendTransaction.ts

@@ -32,6 +32,7 @@ import {
   type FormattedTransactionRequest,
   formatTransactionRequest,
 } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import {
   type AssertRequestErrorType,
   type AssertRequestParameters,
@@ -154,7 +155,7 @@ export async function sendTransaction<
 
     let chainId
     if (chain !== null) {
-      chainId = await getChainId(client)
+      chainId = await getAction(client, getChainId)({})
       assertCurrentChain({
         currentChainId: chainId,
         chain,
@@ -163,7 +164,10 @@ export async function sendTransaction<
 
     if (account.type === 'local') {
       // Prepare the request for signing (assign appropriate fees, etc.)
-      const request = await prepareTransactionRequest(client, {
+      const request = await getAction(
+        client,
+        prepareTransactionRequest,
+      )({
         account,
         accessList,
         chain,
@@ -178,7 +182,7 @@ export async function sendTransaction<
         ...rest,
       } as any)
 
-      if (!chainId) chainId = await getChainId(client)
+      if (!chainId) chainId = await getAction(client, getChainId)({})
 
       const serializer = chain?.serializers?.transaction
       const serializedTransaction = (await account.signTransaction(
@@ -188,7 +192,10 @@ export async function sendTransaction<
         } as TransactionSerializable,
         { serializer },
       )) as Hash
-      return await sendRawTransaction(client, {
+      return await getAction(
+        client,
+        sendRawTransaction,
+      )({
         serializedTransaction,
       })
     }

package/actions/wallet/signTransaction.ts

@@ -27,6 +27,7 @@ import {
   type FormattedTransactionRequest,
   formatTransactionRequest,
 } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import { numberToHex } from '../../utils/index.js'
 import {
   type AssertRequestErrorType,
@@ -127,7 +128,7 @@ export async function signTransaction<
     ...args,
   })
 
-  const chainId = await getChainId(client)
+  const chainId = await getAction(client, getChainId)({})
   if (chain !== null)
     assertCurrentChain({
       currentChainId: chainId,

package/actions/wallet/writeContract.ts

@@ -16,6 +16,7 @@ import {
   encodeFunctionData,
 } from '../../utils/abi/encodeFunctionData.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import {
   type SendTransactionErrorType,
   type SendTransactionParameters,
@@ -138,7 +139,10 @@ export async function writeContract<
     args,
     functionName,
   } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
-  const hash = await sendTransaction(client, {
+  const hash = await getAction(
+    client,
+    sendTransaction,
+  )({
     data: `${data}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
     to: address,
     ...request,

package/chains/definitions/astarZkatana.ts

@@ -0,0 +1,33 @@
+import { defineChain } from '../../utils/chain.js'
+
+export const astarZkatana = /*#__PURE__*/ defineChain({
+  id: 1_261_120,
+  name: 'Astar zkEVM Testnet zKatana',
+  network: 'zKatana',
+  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: [
+        'https://rpc.zkatana.gelato.digital',
+        'https://rpc.startale.com/zkatana',
+      ],
+    },
+    public: {
+      http: [
+        'https://rpc.zkatana.gelato.digital',
+        'https://rpc.startale.com/zkatana',
+      ],
+    },
+  },
+  blockExplorers: {
+    blockscout: {
+      name: 'Blockscout zKatana chain explorer',
+      url: 'https://zkatana.blockscout.com',
+    },
+    default: {
+      name: 'zKatana Explorer',
+      url: 'https://zkatana.explorer.startale.com',
+    },
+  },
+  testnet: true,
+})

package/chains/definitions/modeTestnet.ts

@@ -19,5 +19,11 @@ export const modeTestnet = /*#__PURE__*/ defineChain({
       url: 'https://sepolia.explorer.mode.network',
     },
   },
+  contracts: {
+    multicall3: {
+      address: '0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF',
+      blockCreated: 3019007,
+    },
+  },
   testnet: true,
 })