viem 0.0.1-cjs.10 → 0.0.1-sushi.26

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,195 @@
+import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest'
+import { wait } from '../../utils/wait'
+import {
+  accounts,
+  address,
+  publicClient,
+  testClient,
+  transfer1Data,
+  usdcContractConfig,
+  walletClient,
+} from '../../_test'
+import { impersonateAccount, mine, 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: address.vitalik,
+  })
+  await mine(testClient, { blocks: 1 })
+})
+
+afterAll(async () => {
+  await stopImpersonatingAccount(testClient, {
+    address: address.vitalik,
+  })
+})
+
+test(
+  'default',
+  async () => {
+    let logs: OnLogsResponse[] = []
+
+    const unwatch = watchEvent(publicClient, {
+      onLogs: (logs_) => logs.push(logs_),
+    })
+
+    await wait(1000)
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      to: usdcContractConfig.address,
+      data: transfer1Data(accounts[0].address),
+    })
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      to: usdcContractConfig.address,
+      data: transfer1Data(accounts[0].address),
+    })
+    await wait(1000)
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      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)
+  },
+  { retry: 3 },
+)
+
+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: address.vitalik,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[0].address),
+  })
+  await sendTransaction(walletClient, {
+    from: address.vitalik,
+    to: usdcContractConfig.address,
+    data: transfer1Data(accounts[0].address),
+  })
+  await wait(1000)
+  await sendTransaction(walletClient, {
+    from: address.vitalik,
+    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: address.vitalik,
+    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: address.vitalik,
+    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.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test, vi } from 'vitest'
+
+import type { OnTransactionsResponse } from './watchPendingTransactions'
+import * as createPendingTransactionFilter from './createPendingTransactionFilter'
+import * as getFilterChanges from './getFilterChanges'
+import { watchPendingTransactions } from './watchPendingTransactions'
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
+import { wait } from '../../utils/wait'
+import { sendTransaction } from '../wallet'
+import { parseEther } from '../../utils'
+import { mine, setIntervalMining } from '../test'
+
+test(
+  'watches for pending transactions',
+  async () => {
+    await setIntervalMining(testClient, { interval: 0 })
+    await wait(1000)
+
+    let transactions: OnTransactionsResponse = []
+    const unwatch = watchPendingTransactions(publicClient, {
+      onTransactions: (transactions_) => {
+        transactions = [...transactions, ...transactions_]
+      },
+    })
+    await wait(1000)
+    await sendTransaction(walletClient, {
+      from: accounts[0].address,
+      to: accounts[1].address,
+      value: parseEther('1'),
+    })
+    await wait(1000)
+    await sendTransaction(walletClient, {
+      from: accounts[2].address,
+      to: accounts[3].address,
+      value: parseEther('1'),
+    })
+    await wait(1000)
+    unwatch()
+    expect(transactions.length).toBe(2)
+
+    await setIntervalMining(testClient, { interval: 1 })
+    await mine(testClient, { blocks: 1 })
+  },
+  { timeout: 10_000 },
+)
+
+test('watches for pending transactions (unbatched)', async () => {
+  await setIntervalMining(testClient, { interval: 0 })
+  await wait(1000)
+
+  let transactions: OnTransactionsResponse = []
+  const unwatch = watchPendingTransactions(publicClient, {
+    batch: false,
+    onTransactions: (transactions_) => {
+      transactions = [...transactions, ...transactions_]
+    },
+  })
+  await wait(1000)
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('1'),
+  })
+  await wait(1000)
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('1'),
+  })
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('1'),
+  })
+  await wait(2000)
+  unwatch()
+  expect(transactions.length).toBe(3)
+
+  await setIntervalMining(testClient, { interval: 1 })
+  await mine(testClient, { blocks: 1 })
+})
+
+describe('errors', () => {
+  test('handles error thrown from creating filter', async () => {
+    vi.spyOn(
+      createPendingTransactionFilter,
+      'createPendingTransactionFilter',
+    ).mockRejectedValueOnce(new Error('foo'))
+
+    let unwatch: () => void = () => null
+    const error = await new Promise((resolve) => {
+      unwatch = watchPendingTransactions(publicClient, {
+        onTransactions: () => 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 = watchPendingTransactions(publicClient, {
+        onTransactions: () => null,
+        onError: resolve,
+      })
+    })
+    expect(error).toMatchInlineSnapshot('[Error: bar]')
+    unwatch()
+  })
+})

package/src/actions/public/watchPendingTransactions.ts

@@ -0,0 +1,74 @@
+import type { PublicClient } from '../../clients'
+import type { Filter, Hash } from '../../types'
+import { observe } from '../../utils/observe'
+import { poll } from '../../utils/poll'
+import { createPendingTransactionFilter } from './createPendingTransactionFilter'
+import { getFilterChanges } from './getFilterChanges'
+import { uninstallFilter } from './uninstallFilter'
+
+export type OnTransactionsResponse = Hash[]
+export type OnTransactions = (transactions: OnTransactionsResponse) => void
+
+export type WatchPendingTransactionsArgs = {
+  /** Whether or not the transaction hashes 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 transactions are received. */
+  onTransactions: OnTransactions
+  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+  pollingInterval?: number
+}
+
+export function watchPendingTransactions(
+  client: PublicClient,
+  {
+    batch = true,
+    onError,
+    onTransactions,
+    pollingInterval = client.pollingInterval,
+  }: WatchPendingTransactionsArgs,
+) {
+  const observerId = JSON.stringify([
+    'watchPendingTransactions',
+    client.uid,
+    batch,
+    pollingInterval,
+  ])
+
+  return observe(observerId, { onTransactions, onError }, (emit) => {
+    let filter: Filter<'transaction'>
+
+    const unwatch = poll(
+      async () => {
+        try {
+          if (!filter) {
+            try {
+              filter = await createPendingTransactionFilter(client)
+              return
+            } catch (err) {
+              unwatch()
+              throw err
+            }
+          }
+
+          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) {
+          emit.onError?.(err as Error)
+        }
+      },
+      {
+        emitOnBegin: true,
+        interval: pollingInterval,
+      },
+    )
+
+    return async () => {
+      if (filter) await uninstallFilter(client, { filter })
+      unwatch()
+    }
+  })
+}

package/src/actions/test/dropTransaction.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from 'vitest'
+
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
+import { parseEther } from '../../utils'
+import { getBalance } from '../public/getBalance'
+import { sendTransaction } from '../wallet/sendTransaction'
+import { mine } from './mine'
+import { dropTransaction } from './dropTransaction'
+import { setIntervalMining } from './setIntervalMining'
+
+const sourceAccount = accounts[0]
+const targetAccount = accounts[1]
+
+test('drops transaction', async () => {
+  await setIntervalMining(testClient, { interval: 0 })
+
+  const balance = await getBalance(publicClient, {
+    address: sourceAccount.address,
+  })
+  const hash = await sendTransaction(walletClient, {
+    from: sourceAccount.address,
+    to: targetAccount.address,
+    value: parseEther('2'),
+  })
+  await dropTransaction(testClient, { hash })
+  await mine(testClient, { blocks: 1 })
+  expect(
+    await getBalance(publicClient, {
+      address: sourceAccount.address,
+    }),
+  ).not.toBeLessThan(balance)
+
+  await setIntervalMining(testClient, { interval: 1 })
+})

package/src/actions/test/dropTransaction.ts

@@ -0,0 +1,17 @@
+import type { TestClient } from '../../clients'
+import type { Hash } from '../../types'
+
+export type DropTransactionArgs = {
+  /** The hash of the transaction to drop. */
+  hash: Hash
+}
+
+export async function dropTransaction(
+  client: TestClient,
+  { hash }: DropTransactionArgs,
+) {
+  return await client.request({
+    method: `${client.mode}_dropTransaction`,
+    params: [hash],
+  })
+}

package/src/actions/test/getAutomine.test.ts

@@ -0,0 +1,14 @@
+import { expect, test } from 'vitest'
+
+import { testClient } from '../../_test'
+
+import { getAutomine } from './getAutomine'
+import { setAutomine } from './setAutomine'
+
+// TODO: Anvil sometimes stops interval mining when automining is programatically set.
+test.skip('gets automine status', async () => {
+  await setAutomine(testClient, true)
+  expect(await getAutomine(testClient)).toEqual(true)
+  await setAutomine(testClient, false)
+  expect(await getAutomine(testClient)).toEqual(false)
+})

package/src/actions/test/getAutomine.ts

@@ -0,0 +1,11 @@
+import type { TestClient } from '../../clients'
+
+export type GetAutomineResponse = boolean
+
+export async function getAutomine(
+  client: TestClient,
+): Promise<GetAutomineResponse> {
+  return await client.request({
+    method: `${client.mode}_getAutomine`,
+  })
+}