viem 2.0.0-alpha.8 → 2.0.0-beta.0

package/actions/public/simulateContract.ts

@@ -1,9 +1,14 @@
-import type { Abi } from 'abitype'
+import type { Abi, Address } from 'abitype'
 
-import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../accounts/utils/parseAccount.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { BaseError } from '../../errors/base.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Account, ParseAccount } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 import type {
   ContractFunctionArgs,
@@ -15,12 +20,22 @@ import type {
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import type { Prettify, UnionEvaluate, UnionOmit } from '../../types/utils.js'
-import { decodeFunctionResult } from '../../utils/abi/decodeFunctionResult.js'
-import { encodeFunctionData } from '../../utils/abi/encodeFunctionData.js'
-import { getContractError } from '../../utils/errors/getContractError.js'
+import {
+  type DecodeFunctionResultErrorType,
+  decodeFunctionResult,
+} from '../../utils/abi/decodeFunctionResult.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../utils/abi/encodeFunctionData.js'
+import {
+  type GetContractErrorReturnType,
+  getContractError,
+} from '../../utils/errors/getContractError.js'
 import type { WriteContractParameters } from '../wallet/writeContract.js'
 
-import { type CallParameters, call } from './call.js'
+import { getAction } from '../../utils/getAction.js'
+import { type CallErrorType, type CallParameters, call } from './call.js'
 
 export type SimulateContractParameters<
   abi extends Abi | readonly unknown[] = Abi,
@@ -35,7 +50,9 @@ export type SimulateContractParameters<
   > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
   chain extends Chain | undefined = Chain | undefined,
   chainOverride extends Chain | undefined = Chain | undefined,
+  accountOverride extends Account | Address | undefined = undefined,
 > = {
+  account?: accountOverride
   chain?: chainOverride
   /** Data to append to the end of the calldata. Useful for adding a ["domain" tag](https://opensea.notion.site/opensea/Seaport-Order-Attributions-ec2d69bf455041a5baa490941aad307f). */
   dataSuffix?: Hex
@@ -47,7 +64,7 @@ export type SimulateContractParameters<
 > &
   UnionOmit<
     CallParameters<chainOverride extends Chain ? chainOverride : chain>,
-    'batch' | 'to' | 'data' | 'value'
+    'account' | 'batch' | 'to' | 'data' | 'value'
   > &
   GetValue<
     abi,
@@ -69,7 +86,12 @@ export type SimulateContractReturnType<
     functionName
   > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
   chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
   chainOverride extends Chain | undefined = Chain | undefined,
+  accountOverride extends Account | Address | undefined =
+    | Account
+    | Address
+    | undefined,
   ///
   minimizedAbi extends Abi = readonly [
     ExtractAbiFunctionForArgs<
@@ -79,6 +101,11 @@ export type SimulateContractReturnType<
       args
     >,
   ],
+  resolvedAccount extends Account | undefined = accountOverride extends
+    | Account
+    | Address
+    ? ParseAccount<accountOverride>
+    : account,
 > = {
   result: ContractFunctionReturnType<
     minimizedAbi,
@@ -97,7 +124,7 @@ export type SimulateContractReturnType<
           undefined,
           chainOverride
         >,
-        'abi' | 'args' | 'chain' | 'functionName'
+        'account' | 'abi' | 'args' | 'chain' | 'functionName'
       >
     > &
       ContractFunctionParameters<
@@ -107,10 +134,18 @@ export type SimulateContractReturnType<
         args
       > & {
         chain: chainOverride
-      }
+      } & (resolvedAccount extends Account
+        ? { account: resolvedAccount }
+        : { account?: undefined })
   >
 }
 
+export type SimulateContractErrorType =
+  | ParseAccountErrorType
+  | EncodeFunctionDataErrorType
+  | GetContractErrorReturnType<CallErrorType | DecodeFunctionResultErrorType>
+  | ErrorType
+
 /**
  * Simulates/validates a contract interaction. This is useful for retrieving **return data** and **revert reasons** of contract write functions.
  *
@@ -144,6 +179,7 @@ export type SimulateContractReturnType<
  */
 export async function simulateContract<
   chain extends Chain | undefined,
+  account extends Account | undefined,
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
   args extends ContractFunctionArgs<
@@ -152,31 +188,45 @@ export async function simulateContract<
     functionName
   >,
   chainOverride extends Chain | undefined,
+  accountOverride extends Account | Address | undefined = undefined,
 >(
-  client: Client<Transport, chain>,
+  client: Client<Transport, chain, account>,
   parameters: SimulateContractParameters<
     abi,
     functionName,
     args,
     chain,
-    chainOverride
+    chainOverride,
+    accountOverride
   >,
 ): Promise<
-  SimulateContractReturnType<abi, functionName, args, chain, chainOverride>
+  SimulateContractReturnType<
+    abi,
+    functionName,
+    args,
+    chain,
+    account,
+    chainOverride,
+    accountOverride
+  >
 > {
   const { abi, address, args, dataSuffix, functionName, ...callRequest } =
     parameters as SimulateContractParameters
 
   const account = callRequest.account
     ? parseAccount(callRequest.account)
-    : undefined
+    : client.account
   const calldata = encodeFunctionData({ abi, args, functionName })
   try {
-    const { data } = await call(client, {
+    const { data } = await getAction(
+      client,
+      call,
+    )({
       batch: false,
       data: `${calldata}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
       to: address,
       ...callRequest,
+      account,
     })
     const result = decodeFunctionResult({
       abi,
@@ -197,13 +247,16 @@ export async function simulateContract<
         dataSuffix,
         functionName,
         ...callRequest,
+        account,
       },
     } as unknown as SimulateContractReturnType<
       abi,
       functionName,
       args,
       chain,
-      chainOverride
+      account,
+      chainOverride,
+      accountOverride
     >
   } catch (error) {
     throw getContractError(error as BaseError, {

package/actions/public/uninstallFilter.ts

@@ -1,13 +1,17 @@
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { Filter } from '../../types/filter.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
 
 export type UninstallFilterParameters = {
   filter: Filter<any>
 }
 export type UninstallFilterReturnType = boolean
 
+export type UninstallFilterErrorType = RequestErrorType | ErrorType
+
 /**
  * Destroys a [`Filter`](https://viem.sh/docs/glossary/types.html#filter).
  *

package/actions/public/verifyHash.ts

@@ -5,11 +5,19 @@ import type { Transport } from '../../clients/transports/createTransport.js'
 import { universalSignatureValidatorAbi } from '../../constants/abis.js'
 import { universalSignatureValidatorByteCode } from '../../constants/contracts.js'
 import { CallExecutionError } from '../../errors/contract.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { isBytesEqual } from '../../utils/data/isBytesEqual.js'
+import type { EncodeDeployDataErrorType } from '../../utils/abi/encodeDeployData.js'
+import {
+  type IsBytesEqualErrorType,
+  isBytesEqual,
+} 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 CallParameters, call } from './call.js'
+import { type CallErrorType, type CallParameters, call } from './call.js'
 
 export type VerifyHashParameters = Pick<
   CallParameters,
@@ -25,6 +33,14 @@ export type VerifyHashParameters = Pick<
 
 export type VerifyHashReturnType = boolean
 
+export type VerifyHashErrorType =
+  | CallErrorType
+  | IsHexErrorType
+  | ToHexErrorType
+  | IsBytesEqualErrorType
+  | EncodeDeployDataErrorType
+  | ErrorType
+
 /**
  * Verifies a message hash on chain using ERC-6492.
  *
@@ -32,14 +48,17 @@ export type VerifyHashReturnType = boolean
  * @param parameters - {@link VerifyHashParameters}
  * @returns Whether or not the signature is valid. {@link VerifyHashReturnType}
  */
-export async function verifyHash<TChain extends Chain | undefined,>(
+export async function verifyHash<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
   { address, hash, signature, ...callRequest }: VerifyHashParameters,
 ): Promise<VerifyHashReturnType> {
   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/verifyMessage.ts

@@ -2,10 +2,16 @@ import type { Address } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 import { hashMessage } from '../../utils/index.js'
-import { type VerifyHashParameters, verifyHash } from './verifyHash.js'
+import type { HashMessageErrorType } from '../../utils/signature/hashMessage.js'
+import {
+  type VerifyHashErrorType,
+  type VerifyHashParameters,
+  verifyHash,
+} from './verifyHash.js'
 
 export type VerifyMessageParameters = Omit<VerifyHashParameters, 'hash'> & {
   /** The address that signed the original message. */
@@ -18,6 +24,11 @@ export type VerifyMessageParameters = Omit<VerifyHashParameters, 'hash'> & {
 
 export type VerifyMessageReturnType = boolean
 
+export type VerifyMessageErrorType =
+  | HashMessageErrorType
+  | VerifyHashErrorType
+  | ErrorType
+
 /**
  * Verify that a message was signed by the provided address.
  *
@@ -29,7 +40,7 @@ export type VerifyMessageReturnType = boolean
  * @param parameters - {@link VerifyMessageParameters}
  * @returns Whether or not the signature is valid. {@link VerifyMessageReturnType}
  */
-export async function verifyMessage<TChain extends Chain | undefined,>(
+export async function verifyMessage<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
   { address, message, signature, ...callRequest }: VerifyMessageParameters,
 ): Promise<VerifyMessageReturnType> {

package/actions/public/verifyTypedData.ts

@@ -2,11 +2,19 @@ import type { Address, TypedData } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
-import { hashTypedData } from '../../utils/signature/hashTypedData.js'
-import { type VerifyHashParameters, verifyHash } from './verifyHash.js'
+import {
+  type HashTypedDataErrorType,
+  hashTypedData,
+} from '../../utils/signature/hashTypedData.js'
+import {
+  type VerifyHashErrorType,
+  type VerifyHashParameters,
+  verifyHash,
+} from './verifyHash.js'
 
 export type VerifyTypedDataParameters<
   TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
@@ -21,6 +29,11 @@ export type VerifyTypedDataParameters<
 
 export type VerifyTypedDataReturnType = boolean
 
+export type VerifyTypedDataErrorType =
+  | HashTypedDataErrorType
+  | VerifyHashErrorType
+  | ErrorType
+
 /**
  * Verify that typed data was signed by the provided address.
  *
@@ -30,7 +43,7 @@ export type VerifyTypedDataReturnType = boolean
  * @param parameters - {@link VerifyTypedDataParameters}
  * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}
  */
-export async function verifyTypedData<TChain extends Chain | undefined,>(
+export async function verifyTypedData<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
   {
     address,

package/actions/public/waitForTransactionReceipt.ts

@@ -5,23 +5,30 @@ import {
   TransactionReceiptNotFoundError,
   WaitForTransactionReceiptTimeoutError,
 } from '../../errors/transaction.js'
+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 { observe } from '../../utils/observe.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'
 
-import { getBlock } from './getBlock.js'
+import { type GetBlockErrorType, getBlock } from './getBlock.js'
 import {
+  type GetTransactionErrorType,
   type GetTransactionReturnType,
   getTransaction,
 } from './getTransaction.js'
 import {
+  type GetTransactionReceiptErrorType,
   type GetTransactionReceiptReturnType,
   getTransactionReceipt,
 } from './getTransactionReceipt.js'
-import { watchBlockNumber } from './watchBlockNumber.js'
+import {
+  type WatchBlockNumberErrorType,
+  watchBlockNumber,
+} from './watchBlockNumber.js'
 
 export type ReplacementReason = 'cancelled' | 'replaced' | 'repriced'
 export type ReplacementReturnType<
@@ -58,6 +65,14 @@ export type WaitForTransactionReceiptParameters<
   timeout?: number
 }
 
+export type WaitForTransactionReceiptErrorType =
+  | ObserveErrorType
+  | GetBlockErrorType
+  | GetTransactionErrorType
+  | GetTransactionReceiptErrorType
+  | WatchBlockNumberErrorType
+  | ErrorType
+
 /**
  * Waits for the [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) to be included on a [Block](https://viem.sh/docs/glossary/terms.html#block) (one confirmation), and then returns the [Transaction Receipt](https://viem.sh/docs/glossary/terms.html#transaction-receipt). If the Transaction reverts, then the action will throw an error.
  *
@@ -126,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,
@@ -164,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
                   },
@@ -178,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 (
@@ -201,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 &&
@@ -218,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

@@ -1,10 +1,12 @@
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+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 { poll } from '../../utils/poll.js'
+import { type PollErrorType, poll } from '../../utils/poll.js'
 import { stringify } from '../../utils/stringify.js'
 
 import {
@@ -48,6 +50,8 @@ export type WatchBlockNumberParameters<
 
 export type WatchBlockNumberReturnType = () => void
 
+export type WatchBlockNumberErrorType = PollErrorType | ErrorType
+
 /**
  * Watches and returns incoming block numbers.
  *
@@ -105,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

@@ -1,12 +1,14 @@
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
 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 { poll } from '../../utils/poll.js'
-import { stringify } from '../../utils/stringify.js'
+import { type PollErrorType, poll } from '../../utils/poll.js'
+import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
 
 import { type GetBlockReturnType, getBlock } from './getBlock.js'
 
@@ -66,6 +68,11 @@ export type WatchBlocksParameters<
 
 export type WatchBlocksReturnType = () => void
 
+export type WatchBlocksErrorType =
+  | StringifyErrorType
+  | PollErrorType
+  | ErrorType
+
 /**
  * Watches and returns information for incoming blocks.
  *
@@ -131,7 +138,10 @@ export function watchBlocks<
       poll(
         async () => {
           try {
-            const block = await getBlock(client, {
+            const block = await getAction(
+              client,
+              getBlock,
+            )({
               blockTag,
               includeTransactions,
             })
@@ -144,10 +154,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

@@ -1,19 +1,21 @@
-import type { Abi, AbiEvent, Address, ExtractAbiEvent } from 'abitype'
+import type { Abi, Address, ExtractAbiEvent } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
+import type { Filter } from '../../types/filter.js'
+import type { Log } from '../../types/log.js'
+
 import {
   DecodeLogDataMismatch,
   DecodeLogTopicsMismatch,
 } from '../../errors/abi.js'
 import { InvalidInputRpcError } from '../../errors/rpc.js'
-import type { Chain } from '../../types/chain.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   ContractEventArgs,
   ContractEventName,
 } from '../../types/contract.js'
-import type { Filter } from '../../types/filter.js'
-import type { Log } from '../../types/log.js'
 import type { LogTopic } from '../../types/misc.js'
 import type { GetPollOptions } from '../../types/transport.js'
 import { decodeEventLog } from '../../utils/abi/decodeEventLog.js'
@@ -21,18 +23,18 @@ import {
   type EncodeEventTopicsParameters,
   encodeEventTopics,
 } from '../../utils/abi/encodeEventTopics.js'
-import {
-  type GetAbiItemParameters,
-  getAbiItem,
-} from '../../utils/abi/getAbiItem.js'
 import { formatLog } from '../../utils/formatters/log.js'
-import { observe } from '../../utils/observe.js'
+import { getAction } from '../../utils/getAction.js'
+import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
-import { stringify } from '../../utils/stringify.js'
+import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
 import { createContractEventFilter } from './createContractEventFilter.js'
 import { getBlockNumber } from './getBlockNumber.js'
+import {
+  type GetContractEventsParameters,
+  getContractEvents,
+} from './getContractEvents.js'
 import { getFilterChanges } from './getFilterChanges.js'
-import { getLogs } from './getLogs.js'
 import { uninstallFilter } from './uninstallFilter.js'
 
 export type WatchContractEventOnLogsParameter<
@@ -85,11 +87,16 @@ export type WatchContractEventParameters<
    * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
    * @default false
    */
-  strict?: strict | undefined
+  strict?: strict | boolean | undefined
 } & GetPollOptions<transport>
 
 export type WatchContractEventReturnType = () => void
 
+export type WatchContractEventErrorType =
+  | StringifyErrorType
+  | ObserveErrorType
+  | ErrorType
+
 /**
  * Watches and returns emitted contract event logs.
  *
@@ -167,7 +174,10 @@ export function watchContractEvent<
         async () => {
           if (!initialized) {
             try {
-              filter = (await createContractEventFilter(client, {
+              filter = (await getAction(
+                client,
+                createContractEventFilter,
+              )({
                 abi,
                 address,
                 args: args as any,
@@ -182,28 +192,29 @@ 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 getLogs(client, {
+                logs = await getAction(
+                  client,
+                  getContractEvents,
+                )({
+                  abi,
                   address,
                   args: args as any,
                   fromBlock: previousBlockNumber + 1n,
                   toBlock: blockNumber,
-                  event: getAbiItem({
-                    abi,
-                    name: eventName,
-                  } as unknown as GetAbiItemParameters) as AbiEvent,
-                })
+                  strict,
+                } as {} as GetContractEventsParameters)
               } else {
                 logs = []
               }
@@ -228,7 +239,7 @@ export function watchContractEvent<
       )
 
       return async () => {
-        if (filter) await uninstallFilter(client, { filter })
+        if (filter) await getAction(client, uninstallFilter)({ filter })
         unwatch()
       }
     })