viem 0.0.1-alpha.19 → 0.0.1-alpha.20

package/src/actions/public/getLogs.ts

@@ -5,6 +5,7 @@ import type {
   Address,
   BlockNumber,
   BlockTag,
+  EventDefinition,
   Hash,
   LogTopic,
 } from '../../types'
@@ -12,7 +13,7 @@ import { numberToHex } from '../../utils'
 import { formatLog } from '../../utils/formatters/log'
 import { buildFilterTopics, EventFilterArgs } from './createEventFilter'
 
-export type GetLogsArgs<TEventDefinition extends `${string}(${string})`> = {
+export type GetLogsArgs<TEventDefinition extends EventDefinition> = {
   /** Address or list of addresses from which logs originated */
   address?: Address | Address[]
 } & (
@@ -43,7 +44,7 @@ export type GetLogsResponse = Log[]
 /**
  * @description Returns a collection of event logs.
  */
-export async function getLogs<TEventDefinition extends `${string}(${string})`,>(
+export async function getLogs<TEventDefinition extends EventDefinition,>(
   client: PublicClient,
   {
     address,

package/src/actions/public/getTransaction.ts

@@ -1,7 +1,6 @@
-import type { Chain } from '../../chains'
 import type { PublicClient } from '../../clients'
 import { TransactionNotFoundError } from '../../errors'
-import type { BlockTag, Hash, RpcTransaction } from '../../types'
+import type { BlockTag, Chain, Hash, RpcTransaction } from '../../types'
 import { format, numberToHex } from '../../utils'
 import type {
   FormattedTransaction,

package/src/actions/public/getTransactionConfirmations.ts

@@ -1,6 +1,5 @@
-import type { Chain } from '../../chains'
 import type { PublicClient } from '../../clients'
-import type { Hash } from '../../types'
+import type { Chain, Hash } from '../../types'
 import type {
   FormattedTransactionReceipt,
   TransactionReceiptFormatter,

package/src/actions/public/getTransactionReceipt.test.ts

@@ -1,9 +1,9 @@
 import { assertType, describe, expect, it, test } from 'vitest'
 
 import { accounts, publicClient, testClient, walletClient } from '../../_test'
-import { celo, defineTransactionReceipt, localhost } from '../../chains'
+import { celo } from '../../chains'
 import { createPublicClient, http } from '../../clients'
-import type { TransactionReceipt } from '../../types'
+import type { Address, TransactionReceipt } from '../../types'
 import { parseEther, parseGwei } from '../../utils'
 import { wait } from '../../utils/wait'
 import { mine } from '../test'
@@ -70,77 +70,39 @@ test('gets transaction receipt', async () => {
 
 test('chain w/ custom block type', async () => {
   const client = createPublicClient({
-    chain: {
-      ...celo,
-      rpcUrls: localhost.rpcUrls,
-      formatters: {
-        transactionReceipt: defineTransactionReceipt({
-          exclude: ['effectiveGasPrice'],
-          format: () => ({
-            foo: 'bar' as const,
-          }),
-        }),
-      },
-    },
+    chain: celo,
     transport: http(),
   })
   const receipt = await getTransactionReceipt(client, {
-    hash: '0xa4b1f606b66105fa45cb5db23d2f6597075701e7f0e2367f4e6a39d17a8cf98b',
+    hash: '0xe47fce1dffbe8e94e8f7c23b0af18160fbc19a1e80e9cb107cafe0856dd4a3f7',
   })
 
   assertType<
-    Omit<TransactionReceipt, 'effectiveGasPrice'> & {
-      foo: 'bar'
+    TransactionReceipt & {
+      feeCurrency: Address | null
+      gatewayFee: bigint | null
+      gatewayFeeRecipient: Address | null
     }
   >(receipt)
-
   expect(receipt).toMatchInlineSnapshot(`
     {
-      "blockHash": "0x89644bbd5c8d682a2e9611170e6c1f02573d866d286f006cbf517eec7254ec2d",
-      "blockNumber": 15131999n,
+      "blockHash": "0xfc279eb47ec9edbd7cb5c6affa4b3367daff930085d532d3cc4a1e004da46bd9",
+      "blockNumber": 17582734n,
       "contractAddress": null,
-      "cumulativeGasUsed": 5814407n,
-      "foo": "bar",
-      "from": "0xa152f8bb749c55e9943a3a0a3111d18ee2b3f94e",
-      "gasUsed": 37976n,
-      "logs": [
-        {
-          "address": "0x15d4c048f83bd7e37d49ea4c83a07267ec4203da",
-          "blockHash": "0x89644bbd5c8d682a2e9611170e6c1f02573d866d286f006cbf517eec7254ec2d",
-          "blockNumber": 15131999n,
-          "data": "0x0000000000000000000000000000000000000000000000000000002b3b6fb3d0",
-          "logIndex": 108n,
-          "removed": false,
-          "topics": [
-            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
-            "0x000000000000000000000000a00f99bc38b1ecda1fd70eaa1cd31d576a9f46b0",
-            "0x000000000000000000000000f16e9b0d03470827a95cdfd0cb8a8a3b46969b91",
-          ],
-          "transactionHash": "0xa4b1f606b66105fa45cb5db23d2f6597075701e7f0e2367f4e6a39d17a8cf98b",
-          "transactionIndex": 69n,
-        },
-        {
-          "address": "0x15d4c048f83bd7e37d49ea4c83a07267ec4203da",
-          "blockHash": "0x89644bbd5c8d682a2e9611170e6c1f02573d866d286f006cbf517eec7254ec2d",
-          "blockNumber": 15131999n,
-          "data": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffd4c4904c2f",
-          "logIndex": 109n,
-          "removed": false,
-          "topics": [
-            "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
-            "0x000000000000000000000000a00f99bc38b1ecda1fd70eaa1cd31d576a9f46b0",
-            "0x000000000000000000000000a152f8bb749c55e9943a3a0a3111d18ee2b3f94e",
-          ],
-          "transactionHash": "0xa4b1f606b66105fa45cb5db23d2f6597075701e7f0e2367f4e6a39d17a8cf98b",
-          "transactionIndex": 69n,
-        },
-      ],
-      "logsBloom": "0x08000000000000000000000000000000000000000000000000001000002000000000000000000000000000000000000000000000080000000000000000200000000000000000000000000008400000000000000000000000000000000000100000000000000000000040000008000000000004000000000000000010000000000000000000000000000000000000000000000000000000000000000000000004020000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000002090000000000000000000000000000000000000000000000000000000000000",
-      "status": "success",
-      "to": "0x15d4c048f83bd7e37d49ea4c83a07267ec4203da",
-      "transactionHash": "0xa4b1f606b66105fa45cb5db23d2f6597075701e7f0e2367f4e6a39d17a8cf98b",
-      "transactionIndex": 69,
-      "type": "eip1559",
+      "cumulativeGasUsed": 1765686n,
+      "effectiveGasPrice": 5000000001n,
+      "feeCurrency": undefined,
+      "from": "0x0372cffb61f23703efae601b1962efee825204bc",
+      "gasUsed": 245109n,
+      "gatewayFee": null,
+      "gatewayFeeRecipient": undefined,
+      "logs": [],
+      "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "status": "reverted",
+      "to": "0x865340af8e50eaf0acec9ebc789b2b425c7e0193",
+      "transactionHash": "0xe47fce1dffbe8e94e8f7c23b0af18160fbc19a1e80e9cb107cafe0856dd4a3f7",
+      "transactionIndex": 4,
+      "type": "legacy",
     }
   `)
 })

package/src/actions/public/getTransactionReceipt.ts

@@ -1,7 +1,6 @@
-import type { Chain } from '../../chains'
 import type { PublicClient } from '../../clients'
 import { TransactionReceiptNotFoundError } from '../../errors'
-import type { Hash } from '../../types'
+import type { Chain, Hash } from '../../types'
 import { format } from '../../utils'
 import type {
   FormattedTransactionReceipt,

package/src/actions/public/index.test.ts

@@ -7,6 +7,8 @@ test('exports actions', () => {
     {
       "call": [Function],
       "createBlockFilter": [Function],
+      "createContractEventFilter": [Function],
+      "createEventFilter": [Function],
       "createPendingTransactionFilter": [Function],
       "deployContract": [Function],
       "estimateGas": [Function],
@@ -33,6 +35,8 @@ test('exports actions', () => {
       "waitForTransactionReceipt": [Function],
       "watchBlockNumber": [Function],
       "watchBlocks": [Function],
+      "watchContractEvent": [Function],
+      "watchEvent": [Function],
       "watchPendingTransactions": [Function],
     }
   `)

package/src/actions/public/index.ts

@@ -13,6 +13,18 @@ export type { CreatePendingTransactionFilterResponse } from './createPendingTran
 export { createBlockFilter } from './createBlockFilter'
 export type { CreateBlockFilterResponse } from './createBlockFilter'
 
+export { createEventFilter } from './createEventFilter'
+export type {
+  CreateEventFilterArgs,
+  CreateEventFilterResponse,
+} from './createEventFilter'
+
+export { createContractEventFilter } from './createContractEventFilter'
+export type {
+  CreateContractEventFilterArgs,
+  CreateContractEventFilterResponse,
+} from './createContractEventFilter'
+
 export { deployContract } from './deployContract'
 export type {
   DeployContractArgs,
@@ -123,6 +135,12 @@ export type {
 export { watchBlocks } from './watchBlocks'
 export type { WatchBlocksArgs, OnBlock, OnBlockResponse } from './watchBlocks'
 
+export { watchContractEvent } from './watchContractEvent'
+export type { WatchContractEventArgs } from './watchContractEvent'
+
+export { watchEvent } from './watchEvent'
+export type { WatchEventArgs, OnLogs, OnLogsResponse } from './watchEvent'
+
 export { watchPendingTransactions } from './watchPendingTransactions'
 export type {
   OnTransactions,

package/src/actions/public/readContract.ts

@@ -1,12 +1,12 @@
 import { Abi } from 'abitype'
 
-import type { Chain, Formatter } from '../../chains'
 import type { PublicClient } from '../../clients'
 import type {
   Address,
   ExtractArgsFromAbi,
   ExtractResultFromAbi,
   ExtractFunctionNameFromAbi,
+  Formatter,
 } from '../../types'
 import {
   EncodeFunctionDataArgs,

package/src/actions/public/simulateContract.ts

@@ -1,9 +1,9 @@
 import { Abi } from 'abitype'
 
-import type { Chain, Formatter } from '../../chains'
 import type { PublicClient } from '../../clients'
 import type {
   Address,
+  Chain,
   ExtractArgsFromAbi,
   ExtractResultFromAbi,
   ExtractFunctionNameFromAbi,

package/src/actions/public/waitForTransactionReceipt.ts

@@ -1,11 +1,10 @@
-import type { Chain } from '../../chains'
 import type { PublicClient } from '../../clients'
 import {
   TransactionNotFoundError,
   TransactionReceiptNotFoundError,
   WaitForTransactionReceiptTimeoutError,
 } from '../../errors'
-import type { Hash, Transaction } from '../../types'
+import type { Chain, Hash, Transaction } from '../../types'
 import { observe } from '../../utils/observe'
 import { getBlock, watchBlockNumber } from '../public'
 

package/src/actions/public/watchBlocks.test.ts

@@ -4,11 +4,13 @@ import type { OnBlockResponse } from './watchBlocks'
 import * as getBlock from './getBlock'
 import { watchBlocks } from './watchBlocks'
 import { mine } from '../test/mine'
-import { publicClient, testClient } from '../../_test'
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
 import { wait } from '../../utils/wait'
-import { celo, localhost } from '../../chains'
+import { celo, Chain, localhost } from '../../chains'
 import { createPublicClient, http } from '../../clients'
 import { setIntervalMining } from '../test'
+import { sendTransaction } from '../wallet'
+import { parseEther } from '../../utils'
 
 test('watches for new blocks', async () => {
   const blocks: OnBlockResponse[] = []
@@ -25,6 +27,29 @@ test('watches for new blocks', async () => {
   expect(prevBlocks.length).toBe(3)
 })
 
+test('args: includeTransactions', async () => {
+  await mine(testClient, { blocks: 1 })
+
+  const blocks: OnBlockResponse<Chain, true>[] = []
+  const unwatch = watchBlocks(publicClient, {
+    includeTransactions: true,
+    onBlock: (block) => {
+      blocks.push(block)
+    },
+  })
+
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('1'),
+  })
+  await wait(2000)
+
+  unwatch()
+  expect(blocks.length).toBe(1)
+  expect(blocks[0].transactions.length).toBe(1)
+})
+
 describe('emitMissed', () => {
   test('emits on missed blocks', async () => {
     await setIntervalMining(testClient, { interval: 0 })

package/src/actions/public/watchBlocks.ts

@@ -1,16 +1,23 @@
-import type { Chain } from '../../chains'
 import type { PublicClient } from '../../clients'
-import type { BlockTag } from '../../types'
+import type { BlockTag, Chain } from '../../types'
 import { observe } from '../../utils/observe'
 import { poll } from '../../utils/poll'
 import type { GetBlockResponse } from './getBlock'
 import { getBlock } from './getBlock'
 
-export type OnBlockResponse<TChain extends Chain = Chain> =
-  GetBlockResponse<TChain>
-export type OnBlock<TChain extends Chain = Chain> = (
-  block: OnBlockResponse<TChain>,
-  prevBlock: OnBlockResponse<TChain> | undefined,
+export type OnBlockResponse<
+  TChain extends Chain = Chain,
+  TIncludeTransactions = false,
+> = Omit<
+  GetBlockResponse<TChain>,
+  TIncludeTransactions extends false ? 'transactions' : ''
+>
+export type OnBlock<
+  TChain extends Chain = Chain,
+  TIncludeTransactions = false,
+> = (
+  block: OnBlockResponse<TChain, TIncludeTransactions>,
+  prevBlock: OnBlockResponse<TChain, TIncludeTransactions> | undefined,
 ) => void
 
 export type WatchBlocksArgs<TChain extends Chain = Chain> = {
@@ -20,18 +27,30 @@ export type WatchBlocksArgs<TChain extends Chain = Chain> = {
   emitMissed?: boolean
   /** Whether or not to emit the block to the callback when the subscription opens. */
   emitOnBegin?: boolean
-  /** The callback to call when a new block is received. */
-  onBlock: OnBlock<TChain>
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: (error: Error) => void
-  /** Whether or not to include transaction data in the response. */
-  includeTransactions?: boolean
   /** Polling frequency (in ms). Defaults to the client's pollingInterval config. */
   pollingInterval?: number
-}
+} & (
+  | {
+      /** Whether or not to include transaction data in the response. */
+      includeTransactions: true
+      /** The callback to call when a new block is received. */
+      onBlock: OnBlock<TChain, true>
+    }
+  | {
+      /** Whether or not to include transaction data in the response. */
+      includeTransactions?: false
+      /** The callback to call when a new block is received. */
+      onBlock: OnBlock<TChain>
+    }
+)
 
 /** @description Watches and returns information for incoming blocks. */
-export function watchBlocks<TChain extends Chain>(
+export function watchBlocks<
+  TChain extends Chain,
+  TWatchBlocksArgs extends WatchBlocksArgs<TChain>,
+>(
   client: PublicClient<any, TChain>,
   {
     blockTag = 'latest',
@@ -41,7 +60,7 @@ export function watchBlocks<TChain extends Chain>(
     onError,
     includeTransactions = false,
     pollingInterval = client.pollingInterval,
-  }: WatchBlocksArgs<TChain>,
+  }: TWatchBlocksArgs,
 ) {
   const observerId = JSON.stringify([
     'watchBlocks',

package/src/actions/public/watchContractEvent.test.ts

@@ -0,0 +1,301 @@
+import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest'
+import { wait } from '../../utils/wait'
+import {
+  accounts,
+  publicClient,
+  testClient,
+  usdcContractConfig,
+  vitalikAddress,
+  walletClient,
+} from '../../_test'
+import { impersonateAccount, stopImpersonatingAccount } from '../test'
+import { writeContract } from '../wallet'
+import * as createContractEventFilter from './createContractEventFilter'
+import * as getFilterChanges from './getFilterChanges'
+import { OnLogsResponse, watchContractEvent } from './watchContractEvent'
+
+beforeAll(async () => {
+  await impersonateAccount(testClient, {
+    address: vitalikAddress,
+  })
+  await impersonateAccount(testClient, {
+    address: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
+  })
+})
+
+afterAll(async () => {
+  await stopImpersonatingAccount(testClient, {
+    address: vitalikAddress,
+  })
+  await stopImpersonatingAccount(testClient, {
+    address: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
+  })
+})
+
+test('default', async () => {
+  let logs: OnLogsResponse[] = []
+
+  const unwatch = watchContractEvent(publicClient, {
+    ...usdcContractConfig,
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [vitalikAddress, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [vitalikAddress, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'approve',
+    args: [vitalikAddress, 1n],
+  })
+
+  await wait(2000)
+  unwatch()
+
+  expect(logs.length).toBe(2)
+  expect(logs[0].length).toBe(2)
+  expect(logs[1].length).toBe(1)
+})
+
+test('args: batch', async () => {
+  let logs: OnLogsResponse[] = []
+
+  const unwatch = watchContractEvent(publicClient, {
+    ...usdcContractConfig,
+    batch: false,
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [vitalikAddress, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [vitalikAddress, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'approve',
+    args: [vitalikAddress, 1n],
+  })
+
+  await wait(2000)
+  unwatch()
+
+  expect(logs.length).toBe(3)
+  expect(logs[0].length).toBe(1)
+  expect(logs[1].length).toBe(1)
+  expect(logs[2].length).toBe(1)
+})
+
+test('args: eventName', async () => {
+  let logs: OnLogsResponse[] = []
+
+  const unwatch = watchContractEvent(publicClient, {
+    ...usdcContractConfig,
+    eventName: 'Transfer',
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [vitalikAddress, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [vitalikAddress, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'approve',
+    args: [vitalikAddress, 1n],
+  })
+
+  await wait(2000)
+  unwatch()
+
+  expect(logs.length).toBe(1)
+  expect(logs[0].length).toBe(2)
+})
+
+test('args: args', async () => {
+  let logs: OnLogsResponse[] = []
+
+  const unwatch = watchContractEvent(publicClient, {
+    ...usdcContractConfig,
+    eventName: 'Transfer',
+    args: {
+      to: accounts[0].address,
+    },
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [accounts[0].address, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [accounts[1].address, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'approve',
+    args: [vitalikAddress, 1n],
+  })
+
+  await wait(2000)
+  unwatch()
+
+  expect(logs.length).toBe(1)
+  expect(logs[0].length).toBe(1)
+})
+
+test('args: args', async () => {
+  let logs: OnLogsResponse[] = []
+
+  const unwatch = watchContractEvent(publicClient, {
+    ...usdcContractConfig,
+    eventName: 'Transfer',
+    args: {
+      to: [accounts[0].address, accounts[1].address],
+    },
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [accounts[0].address, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [accounts[1].address, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'approve',
+    args: [vitalikAddress, 1n],
+  })
+
+  await wait(2000)
+  unwatch()
+
+  expect(logs.length).toBe(1)
+  expect(logs[0].length).toBe(2)
+})
+
+test('args: args', async () => {
+  let logs: OnLogsResponse[] = []
+
+  const unwatch = watchContractEvent(publicClient, {
+    ...usdcContractConfig,
+    eventName: 'Transfer',
+    args: {
+      from: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
+    },
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
+    functionName: 'transfer',
+    args: [accounts[0].address, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'transfer',
+    args: [accounts[1].address, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: vitalikAddress,
+    functionName: 'approve',
+    args: [vitalikAddress, 1n],
+  })
+
+  await wait(2000)
+  unwatch()
+
+  expect(logs.length).toBe(1)
+  expect(logs[0].length).toBe(1)
+})
+
+describe('errors', () => {
+  test('handles error thrown from creating filter', async () => {
+    vi.spyOn(
+      createContractEventFilter,
+      'createContractEventFilter',
+    ).mockRejectedValueOnce(new Error('foo'))
+
+    let unwatch: () => void = () => null
+    const error = await new Promise((resolve) => {
+      unwatch = watchContractEvent(publicClient, {
+        ...usdcContractConfig,
+        onLogs: () => null,
+        onError: resolve,
+      })
+    })
+    expect(error).toMatchInlineSnapshot('[Error: foo]')
+    unwatch()
+  })
+
+  test(
+    'handles error thrown from filter changes',
+    async () => {
+      vi.spyOn(getFilterChanges, 'getFilterChanges').mockRejectedValueOnce(
+        new Error('bar'),
+      )
+
+      let unwatch: () => void = () => null
+      const error = await new Promise((resolve) => {
+        unwatch = watchContractEvent(publicClient, {
+          ...usdcContractConfig,
+          onLogs: () => null,
+          onError: resolve,
+        })
+      })
+      expect(error).toMatchInlineSnapshot('[Error: bar]')
+      unwatch()
+    },
+    { retry: 3 },
+  )
+})