viem 0.4.0-main.20230430T212953 → 1.0.0

package/src/actions/public/readContract.ts

@@ -1,28 +1,29 @@
 import type { Abi } from 'abitype'
 
-import type { PublicClient, Transport } from '../../clients/index.js'
-import type { BaseError } from '../../errors/index.js'
+import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { BaseError } from '../../errors/base.js'
+import type { Chain } from '../../types/chain.js'
 import type {
-  Chain,
   ContractFunctionConfig,
   ContractFunctionResult,
-} from '../../types/index.js'
+} from '../../types/contract.js'
 import {
+  type DecodeFunctionResultParameters,
   decodeFunctionResult,
+} from '../../utils/abi/decodeFunctionResult.js'
+import {
+  type EncodeFunctionDataParameters,
   encodeFunctionData,
-  getContractError,
-} from '../../utils/index.js'
-import type {
-  DecodeFunctionResultParameters,
-  EncodeFunctionDataParameters,
-} from '../../utils/index.js'
-import { call } from './call.js'
-import type { CallParameters } from './call.js'
+} from '../../utils/abi/encodeFunctionData.js'
+import { getContractError } from '../../utils/errors/getContractError.js'
+
+import { type CallParameters, call } from './call.js'
 
 export type ReadContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = string,
-> = Pick<CallParameters, 'blockNumber' | 'blockTag'> &
+> = Pick<CallParameters, 'account' | 'blockNumber' | 'blockTag'> &
   ContractFunctionConfig<TAbi, TFunctionName, 'view' | 'pure'>
 
 export type ReadContractReturnType<
@@ -38,7 +39,7 @@ export type ReadContractReturnType<
  *
  * 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.
  *
- * 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).
+ * Internally, uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
  *
  * @param client - Client to use
  * @param parameters - {@link ReadContractParameters}
@@ -91,7 +92,10 @@ export async function readContract<
       args,
       functionName,
       data: data || '0x',
-    } as DecodeFunctionResultParameters<TAbi, TFunctionName>)
+    } as DecodeFunctionResultParameters<
+      TAbi,
+      TFunctionName
+    >) as ReadContractReturnType<TAbi, TFunctionName>
   } catch (err) {
     throw getContractError(err as BaseError, {
       abi: abi as Abi,

package/src/actions/public/simulateContract.ts

@@ -1,27 +1,28 @@
 import type { Abi } from 'abitype'
 
-import type { PublicClient, Transport } from '../../clients/index.js'
-import type { BaseError } from '../../errors/index.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { BaseError } from '../../errors/base.js'
+import type { Chain } from '../../types/chain.js'
 import type {
-  Chain,
   ContractFunctionConfig,
   ContractFunctionResult,
   GetValue,
-  Hex,
-} from '../../types/index.js'
+} from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
 import {
+  type DecodeFunctionResultParameters,
   decodeFunctionResult,
+} from '../../utils/abi/decodeFunctionResult.js'
+import {
+  type EncodeFunctionDataParameters,
   encodeFunctionData,
-  getContractError,
-  parseAccount,
-} from '../../utils/index.js'
-import type {
-  DecodeFunctionResultParameters,
-  EncodeFunctionDataParameters,
-} from '../../utils/index.js'
-import type { WriteContractParameters } from '../wallet/index.js'
-import { call } from './call.js'
-import type { CallParameters } from './call.js'
+} from '../../utils/abi/encodeFunctionData.js'
+import { getContractError } from '../../utils/errors/getContractError.js'
+import type { WriteContractParameters } from '../wallet/writeContract.js'
+
+import { type CallParameters, call } from './call.js'
 
 export type SimulateContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
@@ -54,9 +55,10 @@ export type SimulateContractReturnType<
       undefined,
       TChainOverride
     >,
-    'chain'
+    'chain' | 'functionName'
   > & {
     chain: TChainOverride
+    functionName: TFunctionName
   } & ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>
 }
 
@@ -66,9 +68,9 @@ export type SimulateContractReturnType<
  * - Docs: https://viem.sh/docs/contract/simulateContract.html
  * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/writing-to-contracts
  *
- * 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.
+ * 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.html), but also supports contract write functions.
  *
- * 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).
+ * Internally, uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
  *
  * @param client - Client to use
  * @param parameters - {@link SimulateContractParameters}

package/src/actions/public/uninstallFilter.ts

@@ -1,5 +1,7 @@
-import type { PublicClient, Transport } from '../../clients/index.js'
-import type { Chain, Filter } from '../../types/index.js'
+import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
+import type { Filter } from '../../types/filter.js'
 
 export type UninstallFilterParameters = {
   filter: Filter<any>
@@ -13,9 +15,9 @@ export type UninstallFilterReturnType = boolean
  * - JSON-RPC Methods: [`eth_uninstallFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_uninstallFilter)
  *
  * Destroys a Filter that was created from one of the following Actions:
- * - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)
- * - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)
- * - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)
+ * - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter.html)
+ * - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter.html)
+ * - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter.html)
  *
  * @param client - Client to use
  * @param parameters - {@link UninstallFilterParameters}

package/src/actions/public/verifyHash.ts

@@ -0,0 +1,62 @@
+import type { Address } from 'abitype'
+
+import type { Chain } from '../../chains.js'
+import type { PublicClient } from '../../clients/createPublicClient.js'
+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 { ByteArray, Hex } from '../../types/misc.js'
+import { isBytesEqual } from '../../utils/data/isBytesEqual.js'
+import { encodeDeployData, isHex, toHex } from '../../utils/index.js'
+import { type CallParameters, call } from './call.js'
+
+export type VerifyHashParameters = Pick<
+  CallParameters,
+  'blockNumber' | 'blockTag'
+> & {
+  /** The address that signed the original message. */
+  address: Address
+  /** The hash to be verified. */
+  hash: Hex
+  /** The signature that was generated by signing the message with the address's private key. */
+  signature: Hex | ByteArray
+}
+
+export type VerifyHashReturnType = boolean
+
+/**
+ * Verifies a message hash on chain using ERC-6492.
+ *
+ * @param client - Client to use.
+ * @param parameters - {@link VerifyHashParameters}
+ * @returns Whether or not the signature is valid. {@link VerifyHashReturnType}
+ */
+export async function verifyHash<TChain extends Chain | undefined,>(
+  client: PublicClient<Transport, TChain>,
+  { address, hash, signature, ...callRequest }: VerifyHashParameters,
+): Promise<VerifyHashReturnType> {
+  const signatureHex = isHex(signature) ? signature : toHex(signature)
+
+  try {
+    const { data } = await call(client, {
+      data: encodeDeployData({
+        abi: universalSignatureValidatorAbi,
+        args: [address, hash, signatureHex],
+        bytecode: universalSignatureValidatorByteCode,
+      }),
+      ...callRequest,
+    } as unknown as CallParameters)
+
+    return isBytesEqual(data ?? '0x0', '0x1')
+  } catch (error) {
+    if (error instanceof CallExecutionError) {
+      // if the execution fails, the signature was not valid and an internal method inside of the validator reverted
+      // this can happen for many reasons, for example if signer can not be recovered from the signature
+      // or if the signature has no valid format
+      return false
+    }
+
+    throw error
+  }
+}

package/src/actions/public/verifyMessage.ts

@@ -0,0 +1,42 @@
+import type { Chain } from '../../chains.js'
+import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Transport } from '../../clients/transports/createTransport.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 { Address } from 'abitype'
+
+export type VerifyMessageParameters = Omit<VerifyHashParameters, 'hash'> & {
+  /** The address that signed the original message. */
+  address: Address
+  /** The message to be verified. */
+  message: SignableMessage
+  /** The signature that was generated by signing the message with the address's private key. */
+  signature: Hex | ByteArray
+}
+
+export type VerifyMessageReturnType = boolean
+
+/**
+ * Verify that a message was signed by the provided address.
+ *
+ * Compatible with Smart Contract Accounts & Externally Owned Accounts via [ERC-6492](https://eips.ethereum.org/EIPS/eip-6492).
+ *
+ * - Docs {@link https://viem.sh/docs/actions/public/verifyMessage.html}
+ *
+ * @param client - Client to use.
+ * @param parameters - {@link VerifyMessageParameters}
+ * @returns Whether or not the signature is valid. {@link VerifyMessageReturnType}
+ */
+export async function verifyMessage<TChain extends Chain | undefined,>(
+  client: PublicClient<Transport, TChain>,
+  { address, message, signature, ...callRequest }: VerifyMessageParameters,
+): Promise<VerifyMessageReturnType> {
+  const hash = hashMessage(message)
+  return verifyHash(client, {
+    address,
+    hash,
+    signature,
+    ...callRequest,
+  })
+}

package/src/actions/public/verifyTypedData.ts

@@ -0,0 +1,51 @@
+import type { Chain } from '../../chains.js'
+import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import type { TypedDataDefinition } from '../../types/typedData.js'
+import { hashTypedData } from '../../utils/index.js'
+import { type VerifyHashParameters, verifyHash } from './verifyHash.js'
+import type { Address, TypedData } from 'abitype'
+
+export type VerifyTypedDataParameters<
+  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
+  TPrimaryType extends string = string,
+> = Omit<VerifyHashParameters, 'hash'> &
+  TypedDataDefinition<TTypedData, TPrimaryType> & {
+    /** The address to verify the typed data for. */
+    address: Address
+    /** The signature to verify */
+    signature: Hex | ByteArray
+  }
+
+export type VerifyTypedDataReturnType = boolean
+
+/**
+ * Verify that typed data was signed by the provided address.
+ *
+ * - Docs {@link https://viem.sh/docs/actions/public/verifyTypedData.html}
+ *
+ * @param client - Client to use.
+ * @param parameters - {@link VerifyTypedDataParameters}
+ * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}
+ */
+export async function verifyTypedData<TChain extends Chain | undefined,>(
+  client: PublicClient<Transport, TChain>,
+  {
+    address,
+    signature,
+    message,
+    primaryType,
+    types,
+    domain,
+    ...callRequest
+  }: VerifyTypedDataParameters,
+): Promise<VerifyTypedDataReturnType> {
+  const hash = hashTypedData({ message, primaryType, types, domain })
+  return verifyHash(client, {
+    address,
+    hash,
+    signature,
+    ...callRequest,
+  })
+}

package/src/actions/public/waitForTransactionReceipt.ts

@@ -1,17 +1,27 @@
-import type { PublicClient, Transport } from '../../clients/index.js'
+import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
 import {
   TransactionNotFoundError,
   TransactionReceiptNotFoundError,
   WaitForTransactionReceiptTimeoutError,
-} from '../../errors/index.js'
-import type { Chain, Hash, Transaction } from '../../types/index.js'
+} from '../../errors/transaction.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 { getBlock, watchBlockNumber } from './index.js'
+import { withRetry } from '../../utils/promise/withRetry.js'
+import { stringify } from '../../utils/stringify.js'
 
-import type { GetTransactionReturnType } from './getTransaction.js'
-import { getTransaction } from './getTransaction.js'
-import type { GetTransactionReceiptReturnType } from './getTransactionReceipt.js'
-import { getTransactionReceipt } from './getTransactionReceipt.js'
+import { getBlock } from './getBlock.js'
+import {
+  type GetTransactionReturnType,
+  getTransaction,
+} from './getTransaction.js'
+import {
+  type GetTransactionReceiptReturnType,
+  getTransactionReceipt,
+} from './getTransactionReceipt.js'
+import { watchBlockNumber } from './watchBlockNumber.js'
 
 export type ReplacementReason = 'cancelled' | 'replaced' | 'repriced'
 export type ReplacementReturnType<
@@ -98,15 +108,12 @@ export async function waitForTransactionReceipt<
     timeout,
   }: WaitForTransactionReceiptParameters<TChain>,
 ): Promise<WaitForTransactionReceiptReturnType<TChain>> {
-  const observerId = JSON.stringify([
-    'waitForTransactionReceipt',
-    client.uid,
-    hash,
-  ])
+  const observerId = stringify(['waitForTransactionReceipt', client.uid, hash])
 
   let transaction: GetTransactionReturnType<TChain> | undefined
   let replacedTransaction: GetTransactionReturnType<TChain> | undefined
   let receipt: GetTransactionReceiptReturnType<TChain>
+  let retrying = false
 
   return new Promise((resolve, reject) => {
     if (timeout)
@@ -124,7 +131,11 @@ export async function waitForTransactionReceipt<
           emitOnBegin: true,
           poll: true,
           pollingInterval,
-          async onBlockNumber(blockNumber) {
+          async onBlockNumber(blockNumber_) {
+            if (retrying) return
+
+            let blockNumber = blockNumber_
+
             const done = async (fn: () => void) => {
               unwatch()
               fn()
@@ -143,13 +154,34 @@ export async function waitForTransactionReceipt<
               }
 
               // Get the transaction to check if it's been replaced.
-              transaction = await getTransaction(client, { hash })
+              // We need to retry as some RPC Providers may be slow to sync
+              // up mined transactions.
+              if (!transaction) {
+                retrying = true
+                await withRetry(
+                  async () => {
+                    transaction = await getTransaction(client, { hash })
+                    if (transaction.blockNumber)
+                      blockNumber = transaction.blockNumber
+                  },
+                  {
+                    // exponential backoff
+                    delay: ({ count }) => ~~(1 << count) * 200,
+                    retryCount: 6,
+                  },
+                )
+                retrying = false
+              }
 
               // Get the receipt to check if it's been processed.
               receipt = await getTransactionReceipt(client, { hash })
 
               // Check if we have enough confirmations. If not, continue polling.
-              if (blockNumber - receipt.blockNumber + 1n < confirmations) return
+              if (
+                confirmations > 0 &&
+                blockNumber - receipt.blockNumber + 1n < confirmations
+              )
+                return
 
               done(() => emit.resolve(receipt))
             } catch (err) {

package/src/actions/public/watchBlockNumber.ts

@@ -1,10 +1,16 @@
-import type { PublicClient, Transport } from '../../clients/index.js'
-import type { Chain, GetTransportConfig } from '../../types/index.js'
-import { hexToBigInt } from '../../utils/index.js'
+import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetTransportConfig } from '../../types/transport.js'
+import { hexToBigInt } from '../../utils/encoding/fromHex.js'
 import { observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
-import type { GetBlockNumberReturnType } from './getBlockNumber.js'
-import { getBlockNumber } from './getBlockNumber.js'
+import { stringify } from '../../utils/stringify.js'
+
+import {
+  type GetBlockNumberReturnType,
+  getBlockNumber,
+} from './getBlockNumber.js'
 
 export type OnBlockNumberParameter = GetBlockNumberReturnType
 export type OnBlockNumberFn = (
@@ -87,7 +93,7 @@ export function watchBlockNumber<
   let prevBlockNumber: GetBlockNumberReturnType | undefined
 
   const pollBlockNumber = () => {
-    const observerId = JSON.stringify([
+    const observerId = stringify([
       'watchBlockNumber',
       client.uid,
       emitOnBegin,

package/src/actions/public/watchBlocks.ts

@@ -1,9 +1,13 @@
-import type { PublicClient, Transport } from '../../clients/index.js'
-import type { BlockTag, Chain, GetTransportConfig } from '../../types/index.js'
+import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { BlockTag } from '../../types/block.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetTransportConfig } from '../../types/transport.js'
 import { observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
-import type { GetBlockReturnType } from './getBlock.js'
-import { getBlock } from './getBlock.js'
+import { stringify } from '../../utils/stringify.js'
+
+import { type GetBlockReturnType, getBlock } from './getBlock.js'
 
 export type OnBlockParameter<TChain extends Chain | undefined = Chain> =
   GetBlockReturnType<TChain>
@@ -97,7 +101,7 @@ export function watchBlocks<
   let prevBlock: GetBlockReturnType<TChain> | undefined
 
   const pollBlocks = () => {
-    const observerId = JSON.stringify([
+    const observerId = stringify([
       'watchBlocks',
       client.uid,
       emitMissed,

package/src/actions/public/watchContractEvent.ts

@@ -1,39 +1,45 @@
-import type { Abi, ExtractAbiEvent, Narrow } from 'abitype'
-import type { PublicClient, Transport } from '../../clients/index.js'
-import type {
-  Address,
-  Chain,
-  GetEventArgs,
-  InferEventName,
-  Filter,
-  Log,
-} from '../../types/index.js'
-import type { GetAbiItemParameters } from '../../utils/index.js'
-import { getAbiItem } from '../../utils/index.js'
+import type { Abi, Address, ExtractAbiEvent, Narrow } from 'abitype'
+
+import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetEventArgs, InferEventName } from '../../types/contract.js'
+import type { Filter } from '../../types/filter.js'
+import type { Log } from '../../types/log.js'
+import {
+  type GetAbiItemParameters,
+  getAbiItem,
+} from '../../utils/abi/getAbiItem.js'
 import { observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
-import { createContractEventFilter } from './createContractEventFilter.js'
-import type { CreateContractEventFilterParameters } from './createContractEventFilter.js'
+import { stringify } from '../../utils/stringify.js'
+
+import {
+  type CreateContractEventFilterParameters,
+  createContractEventFilter,
+} from './createContractEventFilter.js'
 import { getBlockNumber } from './getBlockNumber.js'
 import { getFilterChanges } from './getFilterChanges.js'
-import { getLogs } from './getLogs.js'
-import type { GetLogsParameters } from './getLogs.js'
+import { type GetLogsParameters, getLogs } from './getLogs.js'
 import { uninstallFilter } from './uninstallFilter.js'
 
 export type OnLogsParameter<
   TAbi extends Abi | readonly unknown[] = readonly unknown[],
   TEventName extends string = string,
+  TStrict extends boolean | undefined = undefined,
 > = TAbi extends Abi
-  ? Log<bigint, number, ExtractAbiEvent<TAbi, TEventName>>[]
+  ? Log<bigint, number, ExtractAbiEvent<TAbi, TEventName>, TStrict>[]
   : Log[]
 export type OnLogsFn<
   TAbi extends Abi | readonly unknown[] = readonly unknown[],
   TEventName extends string = string,
-> = (logs: OnLogsParameter<TAbi, TEventName>) => void
+  TStrict extends boolean | undefined = undefined,
+> = (logs: OnLogsParameter<TAbi, TEventName, TStrict>) => void
 
 export type WatchContractEventParameters<
   TAbi extends Abi | readonly unknown[] = readonly unknown[],
   TEventName extends string = string,
+  TStrict extends boolean | undefined = undefined,
 > = {
   /** The address of the contract. */
   address?: Address | Address[]
@@ -47,9 +53,14 @@ export type WatchContractEventParameters<
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: (error: Error) => void
   /** The callback to call when new event logs are received. */
-  onLogs: OnLogsFn<TAbi, TEventName>
+  onLogs: OnLogsFn<TAbi, TEventName, TStrict>
   /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
   pollingInterval?: number
+  /**
+   * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
+   * @default false
+   */
+  strict?: TStrict
 }
 
 export type WatchContractEventReturnType = () => void
@@ -61,7 +72,7 @@ export type WatchContractEventReturnType = () => void
  *
  * This Action will batch up all the event logs found within the [`pollingInterval`](https://viem.sh/docs/contract/watchContractEvent.html#pollinginterval-optional), and invoke them via [`onLogs`](https://viem.sh/docs/contract/watchContractEvent.html#onLogs).
  *
- * `watchContractEvent` will attempt to create an [Event Filter](https://viem.sh/docs/contract/createContractEventFilter) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchContractEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs) instead.
+ * `watchContractEvent` will attempt to create an [Event Filter](https://viem.sh/docs/contract/createContractEventFilter.html) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchContractEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs) instead.
  *
  * @param client - Client to use
  * @param parameters - {@link WatchContractEventParameters}
@@ -88,6 +99,7 @@ export function watchContractEvent<
   TChain extends Chain | undefined,
   TAbi extends Abi | readonly unknown[],
   TEventName extends string,
+  TStrict extends boolean | undefined = undefined,
 >(
   client: PublicClient<Transport, TChain>,
   {
@@ -99,9 +111,10 @@ export function watchContractEvent<
     onError,
     onLogs,
     pollingInterval = client.pollingInterval,
-  }: WatchContractEventParameters<TAbi, TEventName>,
+    strict: strict_,
+  }: WatchContractEventParameters<TAbi, TEventName, TStrict>,
 ): WatchContractEventReturnType {
-  const observerId = JSON.stringify([
+  const observerId = stringify([
     'watchContractEvent',
     address,
     args,
@@ -110,6 +123,7 @@ export function watchContractEvent<
     eventName,
     pollingInterval,
   ])
+  const strict = strict_ ?? false
 
   return observe(observerId, { onLogs, onError }, (emit) => {
     let previousBlockNumber: bigint
@@ -125,6 +139,7 @@ export function watchContractEvent<
               address,
               args,
               eventName,
+              strict,
             } as unknown as CreateContractEventFilterParameters)) as Filter<
               'event',
               TAbi,