viem 0.0.1-sushi.27 → 0.1.1

package/src/actions/public/watchContractEvent.ts

@@ -1,108 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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`,
-  })
-}