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

package/src/actions/public/watchBlockNumber.ts

@@ -0,0 +1,79 @@
+import type { PublicClient } from '../../clients'
+import { observe } from '../../utils/observe'
+import { poll } from '../../utils/poll'
+import type { GetBlockNumberResponse } from './getBlockNumber'
+import { getBlockNumber } from './getBlockNumber'
+
+export type OnBlockNumberResponse = GetBlockNumberResponse
+export type OnBlockNumber = (
+  blockNumber: OnBlockNumberResponse,
+  prevBlockNumber: OnBlockNumberResponse | undefined,
+) => void
+
+export type WatchBlockNumberArgs = {
+  /** Whether or not to emit the missed block numbers to the callback. */
+  emitMissed?: boolean
+  /** Whether or not to emit the latest block number to the callback when the subscription opens. */
+  emitOnBegin?: boolean
+  /** The callback to call when a new block number is received. */
+  onBlockNumber: OnBlockNumber
+  /** The callback to call when an error occurred when trying to get for a new block. */
+  onError?: (error: Error) => void
+  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+  pollingInterval?: number
+}
+
+/** @description Watches and returns incoming block numbers. */
+export function watchBlockNumber(
+  client: PublicClient,
+  {
+    emitOnBegin = false,
+    emitMissed = false,
+    onBlockNumber,
+    onError,
+    pollingInterval = client.pollingInterval,
+  }: WatchBlockNumberArgs,
+) {
+  const observerId = JSON.stringify([
+    'watchBlockNumber',
+    client.uid,
+    emitOnBegin,
+    emitMissed,
+    pollingInterval,
+  ])
+
+  let prevBlockNumber: GetBlockNumberResponse | undefined
+
+  return observe(observerId, { onBlockNumber, onError }, (emit) =>
+    poll(
+      async () => {
+        try {
+          const blockNumber = await getBlockNumber(client, { maxAge: 0 })
+
+          if (prevBlockNumber) {
+            // If the current block number is the same as the previous,
+            // we can skip.
+            if (blockNumber === prevBlockNumber) return
+
+            // If we have missed out on some previous blocks, and the
+            // `emitMissed` flag is truthy, let's emit those blocks.
+            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
+              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
+                emit.onBlockNumber(i, prevBlockNumber)
+                prevBlockNumber = i
+              }
+            }
+          }
+          prevBlockNumber = blockNumber
+          emit.onBlockNumber(blockNumber, prevBlockNumber)
+        } catch (err) {
+          emit.onError?.(err as Error)
+        }
+      },
+      {
+        emitOnBegin,
+        interval: pollingInterval,
+      },
+    ),
+  )
+}

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

@@ -0,0 +1,210 @@
+import { describe, expect, test, vi } from 'vitest'
+
+import type { OnBlockResponse } from './watchBlocks'
+import * as getBlock from './getBlock'
+import { watchBlocks } from './watchBlocks'
+import { mine } from '../test/mine'
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
+import { wait } from '../../utils/wait'
+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[] = []
+  const prevBlocks: OnBlockResponse[] = []
+  const unwatch = watchBlocks(publicClient, {
+    onBlock: (block, prevBlock) => {
+      blocks.push(block)
+      prevBlock && block !== prevBlock && prevBlocks.push(prevBlock)
+    },
+  })
+  await wait(5000)
+  unwatch()
+  expect(blocks.length).toBe(4)
+  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 })
+    const blocks: OnBlockResponse[] = []
+    const unwatch = watchBlocks(publicClient, {
+      emitMissed: true,
+      onBlock: (block) => blocks.push(block),
+      pollingInterval: 500,
+    })
+    await mine(testClient, { blocks: 1 })
+    await wait(1000)
+    await mine(testClient, { blocks: 5 })
+    await wait(1000)
+    unwatch()
+    expect(blocks.length).toBe(6)
+    await setIntervalMining(testClient, { interval: 1 })
+  })
+})
+
+describe('emitOnBegin', () => {
+  test('watches for new blocks', async () => {
+    const blocks: OnBlockResponse[] = []
+    const unwatch = watchBlocks(publicClient, {
+      emitOnBegin: true,
+      onBlock: (block) => blocks.push(block),
+    })
+    await wait(5000)
+    unwatch()
+    expect(blocks.length).toBe(5)
+  })
+})
+
+describe('pollingInterval on client', () => {
+  test('watches for new blocks', async () => {
+    const client = createPublicClient({
+      chain: localhost,
+      transport: http(),
+      pollingInterval: 500,
+    })
+
+    const blocks: OnBlockResponse[] = []
+    const unwatch = watchBlocks(client, {
+      onBlock: (block) => blocks.push(block),
+    })
+    await wait(2000)
+    unwatch()
+    expect(blocks.length).toBe(2)
+  })
+})
+
+test('custom chain type', async () => {
+  const client = createPublicClient({
+    chain: celo,
+    transport: http(),
+  })
+
+  const blocks: OnBlockResponse<typeof celo>[] = []
+  const unwatch = watchBlocks(client, {
+    emitOnBegin: true,
+    onBlock: (block) => blocks.push(block),
+  })
+  await wait(2000)
+  unwatch()
+  expect(blocks[0].randomness).toBeDefined()
+})
+
+describe('behavior', () => {
+  test('does not emit when no new incoming blocks', async () => {
+    const blocks: OnBlockResponse[] = []
+    const unwatch = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+      pollingInterval: 100,
+    })
+    await wait(1200)
+    unwatch()
+    expect(blocks.length).toBe(2)
+  })
+
+  test('watch > unwatch > watch', async () => {
+    let blocks: OnBlockResponse[] = []
+    let unwatch = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+    })
+    await wait(3000)
+    unwatch()
+    expect(blocks.length).toBe(2)
+
+    blocks = []
+    unwatch = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+    })
+    await wait(3000)
+    unwatch()
+    expect(blocks.length).toBe(2)
+  })
+
+  test('multiple watchers', async () => {
+    let blocks: OnBlockResponse[] = []
+
+    let unwatch1 = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+    })
+    let unwatch2 = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+    })
+    let unwatch3 = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+    })
+    await wait(3000)
+    unwatch1()
+    unwatch2()
+    unwatch3()
+    expect(blocks.length).toBe(6)
+
+    blocks = []
+
+    unwatch1 = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+    })
+    unwatch2 = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+    })
+    unwatch3 = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+    })
+    await wait(3000)
+    unwatch1()
+    unwatch2()
+    unwatch3()
+    expect(blocks.length).toBe(6)
+  })
+
+  test('immediately unwatch', async () => {
+    const blocks: OnBlockResponse[] = []
+    const unwatch = watchBlocks(publicClient, {
+      onBlock: (block) => blocks.push(block),
+    })
+    unwatch()
+    await wait(3000)
+    expect(blocks.length).toBe(0)
+  })
+})
+
+describe('errors', () => {
+  test('handles error thrown', async () => {
+    vi.spyOn(getBlock, 'getBlock').mockRejectedValue(new Error('foo'))
+
+    let unwatch: () => void = () => null
+    const error = await new Promise((resolve) => {
+      unwatch = watchBlocks(publicClient, {
+        onBlock: () => null,
+        onError: resolve,
+      })
+    })
+    expect(error).toMatchInlineSnapshot('[Error: foo]')
+    unwatch()
+  })
+})

package/src/actions/public/watchBlocks.ts

@@ -0,0 +1,114 @@
+import type { PublicClient } from '../../clients'
+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,
+  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> = {
+  /** The block tag. Defaults to "latest". */
+  blockTag?: BlockTag
+  /** Whether or not to emit the missed blocks to the callback. */
+  emitMissed?: boolean
+  /** Whether or not to emit the block to the callback when the subscription opens. */
+  emitOnBegin?: boolean
+  /** The callback to call when an error occurred when trying to get for a new block. */
+  onError?: (error: Error) => void
+  /** 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,
+  TWatchBlocksArgs extends WatchBlocksArgs<TChain>,
+>(
+  client: PublicClient<any, TChain>,
+  {
+    blockTag = 'latest',
+    emitMissed = false,
+    emitOnBegin = false,
+    onBlock,
+    onError,
+    includeTransactions = false,
+    pollingInterval = client.pollingInterval,
+  }: TWatchBlocksArgs,
+) {
+  const observerId = JSON.stringify([
+    'watchBlocks',
+    client.uid,
+    emitMissed,
+    emitOnBegin,
+    includeTransactions,
+    pollingInterval,
+  ])
+
+  let prevBlock: GetBlockResponse<TChain> | undefined
+
+  return observe(observerId, { onBlock, onError }, (emit) =>
+    poll(
+      async () => {
+        try {
+          const block = await getBlock(client, {
+            blockTag,
+            includeTransactions,
+          })
+          if (block.number && prevBlock?.number) {
+            // If the current block number is the same as the previous,
+            // we can skip.
+            if (block.number === prevBlock.number) return
+
+            // If we have missed out on some previous blocks, and the
+            // `emitMissed` flag is truthy, let's emit those blocks.
+            if (block.number - prevBlock.number > 1 && emitMissed) {
+              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
+                const block = await getBlock(client, {
+                  blockNumber: i,
+                  includeTransactions,
+                })
+                emit.onBlock(block, prevBlock)
+                prevBlock = block
+              }
+            }
+          }
+          emit.onBlock(block, prevBlock)
+          prevBlock = block
+        } catch (err) {
+          emit.onError?.(err as Error)
+        }
+      },
+      {
+        emitOnBegin,
+        interval: pollingInterval,
+      },
+    ),
+  )
+}

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

@@ -0,0 +1,305 @@
+import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest'
+import { wait } from '../../utils/wait'
+import {
+  accounts,
+  address,
+  publicClient,
+  testClient,
+  usdcContractConfig,
+  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: address.vitalik,
+  })
+  await impersonateAccount(testClient, {
+    address: address.usdcHolder,
+  })
+})
+
+afterAll(async () => {
+  await stopImpersonatingAccount(testClient, {
+    address: address.vitalik,
+  })
+  await stopImpersonatingAccount(testClient, {
+    address: address.usdcHolder,
+  })
+})
+
+test(
+  'default',
+  async () => {
+    let logs: OnLogsResponse[] = []
+
+    const unwatch = watchContractEvent(publicClient, {
+      ...usdcContractConfig,
+      onLogs: (logs_) => logs.push(logs_),
+    })
+
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [address.vitalik, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [address.vitalik, 1n],
+    })
+    await wait(1000)
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
+
+    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 = watchContractEvent(publicClient, {
+    ...usdcContractConfig,
+    batch: false,
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'transfer',
+    args: [address.vitalik, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'transfer',
+    args: [address.vitalik, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'approve',
+    args: [address.vitalik, 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: address.vitalik,
+    functionName: 'transfer',
+    args: [address.vitalik, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'transfer',
+    args: [address.vitalik, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'approve',
+    args: [address.vitalik, 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: address.vitalik,
+    functionName: 'transfer',
+    args: [accounts[0].address, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'transfer',
+    args: [accounts[1].address, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'approve',
+    args: [address.vitalik, 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: address.vitalik,
+    functionName: 'transfer',
+    args: [accounts[0].address, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'transfer',
+    args: [accounts[1].address, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'approve',
+    args: [address.vitalik, 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: address.usdcHolder,
+    },
+    onLogs: (logs_) => logs.push(logs_),
+  })
+
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.usdcHolder,
+    functionName: 'transfer',
+    args: [accounts[0].address, 1n],
+  })
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'transfer',
+    args: [accounts[1].address, 1n],
+  })
+  await wait(1000)
+  await writeContract(walletClient, {
+    ...usdcContractConfig,
+    from: address.vitalik,
+    functionName: 'approve',
+    args: [address.vitalik, 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 },
+  )
+})