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

package/src/actions/public/watchContractEvent.ts

@@ -0,0 +1,108 @@
+import { Abi } from 'abitype'
+import type { PublicClient } from '../../clients'
+import type {
+  Address,
+  ExtractEventArgsFromAbi,
+  ExtractEventNameFromAbi,
+  Filter,
+  Log,
+} from '../../types'
+import { observe } from '../../utils/observe'
+import { poll } from '../../utils/poll'
+import {
+  createContractEventFilter,
+  CreateContractEventFilterArgs,
+} from './createContractEventFilter'
+import { getFilterChanges } from './getFilterChanges'
+import { uninstallFilter } from './uninstallFilter'
+
+export type OnLogsResponse = Log[]
+export type OnLogs = (logs: OnLogsResponse) => void
+
+export type WatchContractEventArgs<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TEventName extends string = any,
+> = {
+  /** The address of the contract. */
+  address: Address | Address[]
+  /** Contract ABI. */
+  abi: TAbi
+  /** Whether or not the event logs should be batched on each invocation. */
+  batch?: boolean
+  /** Contract event. */
+  eventName?: ExtractEventNameFromAbi<TAbi, TEventName>
+  /** 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: OnLogs
+  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+  pollingInterval?: number
+} & ExtractEventArgsFromAbi<TAbi, TEventName>
+
+export function watchContractEvent<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TEventName extends string = any,
+>(
+  client: PublicClient,
+  {
+    abi,
+    address,
+    args,
+    batch = true,
+    eventName,
+    onError,
+    onLogs,
+    pollingInterval = client.pollingInterval,
+  }: WatchContractEventArgs<TAbi, TEventName>,
+) {
+  const observerId = JSON.stringify([
+    'watchContractEvent',
+    address,
+    args,
+    batch,
+    client.uid,
+    eventName,
+    pollingInterval,
+  ])
+
+  return observe(observerId, { onLogs, onError }, (emit) => {
+    let filter: Filter<'event'>
+
+    const unwatch = poll(
+      async () => {
+        try {
+          if (!filter) {
+            try {
+              filter = await createContractEventFilter(client, {
+                abi,
+                address,
+                args,
+                eventName,
+              } as unknown as CreateContractEventFilterArgs)
+              return
+            } catch (err) {
+              unwatch()
+              throw err
+            }
+          }
+
+          const logs = await getFilterChanges(client, { filter })
+          if (logs.length === 0) return
+          if (batch) emit.onLogs(logs)
+          else logs.forEach((log) => emit.onLogs([log]))
+        } catch (err) {
+          emit.onError?.(err as Error)
+        }
+      },
+      {
+        emitOnBegin: true,
+        interval: pollingInterval,
+      },
+    )
+
+    return async () => {
+      if (filter) await uninstallFilter(client, { filter })
+      unwatch()
+    }
+  })
+}

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

@@ -0,0 +1,190 @@
+import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest'
+import { wait } from '../../utils/wait'
+import {
+  accounts,
+  publicClient,
+  testClient,
+  transfer1Data,
+  usdcContractConfig,
+  vitalikAddress,
+  walletClient,
+} from '../../_test'
+import { impersonateAccount, stopImpersonatingAccount } from '../test'
+import { sendTransaction } from '../wallet'
+import * as createEventFilter from './createEventFilter'
+import * as getFilterChanges from './getFilterChanges'
+import { OnLogsResponse, watchEvent } from './watchEvent'
+
+beforeAll(async () => {
+  await impersonateAccount(testClient, {
+    address: vitalikAddress,
+  })
+})
+
+afterAll(async () => {
+  await stopImpersonatingAccount(testClient, {
+    address: vitalikAddress,
+  })
+})
+
+test('default', async () => {
+  let logs: OnLogsResponse[] = []
+
+  const unwatch = watchEvent(publicClient, {
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await wait(1000)
+  await sendTransaction(walletClient, {
+    from: vitalikAddress,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[0].address),
+  })
+  await sendTransaction(walletClient, {
+    from: vitalikAddress,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[0].address),
+  })
+  await wait(1000)
+  await sendTransaction(walletClient, {
+    from: vitalikAddress,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[1].address),
+  })
+  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 = watchEvent(publicClient, {
+    batch: false,
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await wait(1000)
+  await sendTransaction(walletClient, {
+    from: vitalikAddress,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[0].address),
+  })
+  await sendTransaction(walletClient, {
+    from: vitalikAddress,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[0].address),
+  })
+  await wait(1000)
+  await sendTransaction(walletClient, {
+    from: vitalikAddress,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[1].address),
+  })
+  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: address', async () => {
+  let logs: OnLogsResponse[] = []
+  let logs2: OnLogsResponse[] = []
+
+  const unwatch = watchEvent(publicClient, {
+    address: usdcContractConfig.address,
+    onLogs: (logs_) => logs.push(logs_),
+  })
+  const unwatch2 = watchEvent(publicClient, {
+    address: '0x0000000000000000000000000000000000000000',
+    onLogs: (logs_) => logs2.push(logs_),
+  })
+
+  await wait(1000)
+  await sendTransaction(walletClient, {
+    from: vitalikAddress,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[0].address),
+  })
+  await wait(2000)
+  unwatch()
+  unwatch2()
+
+  expect(logs.length).toBe(1)
+  expect(logs2.length).toBe(0)
+})
+
+test('args: address + event', async () => {
+  let logs: OnLogsResponse[] = []
+  let logs2: OnLogsResponse[] = []
+
+  const unwatch = watchEvent(publicClient, {
+    address: usdcContractConfig.address,
+    event: 'Transfer(address indexed, address indexed, uint256 indexed)',
+    onLogs: (logs_) => logs.push(logs_),
+  })
+  const unwatch2 = watchEvent(publicClient, {
+    address: usdcContractConfig.address,
+    event: 'Approval(address indexed, address indexed)',
+    onLogs: (logs_) => logs2.push(logs_),
+  })
+
+  await wait(1000)
+  await sendTransaction(walletClient, {
+    from: vitalikAddress,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[0].address),
+  })
+  await wait(2000)
+  unwatch()
+  unwatch2()
+
+  expect(logs.length).toBe(1)
+  expect(logs2.length).toBe(0)
+})
+
+test.todo('args: args')
+
+describe('errors', () => {
+  test('handles error thrown from creating filter', async () => {
+    vi.spyOn(createEventFilter, 'createEventFilter').mockRejectedValueOnce(
+      new Error('foo'),
+    )
+
+    let unwatch: () => void = () => null
+    const error = await new Promise((resolve) => {
+      unwatch = watchEvent(publicClient, {
+        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 = watchEvent(publicClient, {
+          onLogs: () => null,
+          onError: resolve,
+        })
+      })
+      expect(error).toMatchInlineSnapshot('[Error: bar]')
+      unwatch()
+    },
+    { retry: 3 },
+  )
+})

package/src/actions/public/watchEvent.ts

@@ -0,0 +1,95 @@
+import type { PublicClient } from '../../clients'
+import type { Address, EventDefinition, Filter, Log } from '../../types'
+import { observe } from '../../utils/observe'
+import { poll } from '../../utils/poll'
+import { createEventFilter, EventFilterArgs } from './createEventFilter'
+import { getFilterChanges } from './getFilterChanges'
+import { uninstallFilter } from './uninstallFilter'
+
+export type OnLogsResponse = Log[]
+export type OnLogs = (logs: OnLogsResponse) => void
+
+export type WatchEventArgs<TEventDefinition extends EventDefinition> = {
+  /** The address of the contract. */
+  address?: Address | Address[]
+  /** Whether or not the event logs should be batched on each invocation. */
+  batch?: boolean
+  /** 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: OnLogs
+  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+  pollingInterval?: number
+} & (
+  | {
+      event: TEventDefinition
+      args?: EventFilterArgs<TEventDefinition>
+    }
+  | {
+      event?: never
+      args?: never
+    }
+)
+
+export function watchEvent<TEventDefinition extends EventDefinition>(
+  client: PublicClient,
+  {
+    address,
+    args,
+    batch = true,
+    event,
+    onError,
+    onLogs,
+    pollingInterval = client.pollingInterval,
+  }: WatchEventArgs<TEventDefinition>,
+) {
+  const observerId = JSON.stringify([
+    'watchEvent',
+    address,
+    args,
+    batch,
+    client.uid,
+    event,
+    pollingInterval,
+  ])
+
+  return observe(observerId, { onLogs, onError }, (emit) => {
+    let filter: Filter<'event'>
+
+    const unwatch = poll(
+      async () => {
+        try {
+          if (!filter) {
+            try {
+              filter = await createEventFilter(client, {
+                address,
+                args,
+                event: event!,
+              })
+              return
+            } catch (err) {
+              unwatch()
+              throw err
+            }
+          }
+
+          const logs = await getFilterChanges(client, { filter })
+          if (logs.length === 0) return
+          if (batch) emit.onLogs(logs)
+          else logs.forEach((log) => emit.onLogs([log]))
+        } catch (err) {
+          emit.onError?.(err as Error)
+        }
+      },
+      {
+        emitOnBegin: true,
+        interval: pollingInterval,
+      },
+    )
+
+    return async () => {
+      if (filter) await uninstallFilter(client, { filter })
+      unwatch()
+    }
+  })
+}

package/src/actions/public/watchPendingTransactions.ts

@@ -53,6 +53,7 @@ export function watchPendingTransactions(
           }
 
           const hashes = await getFilterChanges(client, { filter })
+          if (hashes.length === 0) return
           if (batch) emit.onTransactions(hashes)
           else hashes.forEach((hash) => emit.onTransactions([hash]))
         } catch (err) {

package/src/actions/wallet/addChain.ts

@@ -1,5 +1,5 @@
-import type { Chain } from '../../chains'
 import type { WalletClient } from '../../clients'
+import type { Chain } from '../../types'
 import { numberToHex } from '../../utils'
 
 export async function addChain(client: WalletClient, chain: Chain) {

package/src/actions/wallet/sendTransaction.ts

@@ -1,7 +1,8 @@
-import type { Chain, Formatter } from '../../chains'
 import type { WalletClient } from '../../clients'
 import { InvalidGasArgumentsError } from '../../errors'
 import type {
+  Chain,
+  Formatter,
   Hash,
   MergeIntersectionProperties,
   TransactionRequest,

package/src/actions/wallet/switchChain.ts

@@ -1,5 +1,5 @@
-import type { Chain } from '../../chains'
 import type { WalletClient } from '../../clients'
+import { Chain } from '../../types'
 import { numberToHex } from '../../utils'
 
 export type SwitchChainArgs = { id: Chain['id'] }

package/src/actions/wallet/writeContract.ts

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