viem 0.0.1-alpha.15 → 0.0.1-alpha.17

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

@@ -0,0 +1,166 @@
+import { describe, expect, test, vi } from 'vitest'
+
+import type { OnBlockNumberResponse } from './watchBlockNumber'
+import { watchBlockNumber } from './watchBlockNumber'
+import { publicClient, testClient } from '../../_test'
+import { wait } from '../../utils/wait'
+import { localhost } from '../../chains'
+import { createPublicClient, http } from '../../clients'
+import { mine } from '../test/mine'
+import * as getBlockNumber from './getBlockNumber'
+import { setIntervalMining } from '../test'
+
+test('watches for new block numbers', async () => {
+  const blockNumbers: OnBlockNumberResponse[] = []
+  const unwatch = watchBlockNumber(publicClient, {
+    onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+  })
+  await wait(5000)
+  unwatch()
+  expect(blockNumbers.length).toBe(4)
+})
+
+describe('emitMissed', () => {
+  test('emits on missed blocks', async () => {
+    await setIntervalMining(testClient, { interval: 0 })
+    const blockNumbers: OnBlockNumberResponse[] = []
+    const unwatch = watchBlockNumber(publicClient, {
+      emitMissed: true,
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+      pollingInterval: 500,
+    })
+    await mine(testClient, { blocks: 1 })
+    await wait(1000)
+    await mine(testClient, { blocks: 5 })
+    await wait(1000)
+    unwatch()
+    await setIntervalMining(testClient, { interval: 1 })
+    expect(blockNumbers.length).toBe(6)
+  })
+})
+
+describe('emitOnBegin', () => {
+  test('watches for new block numbers', async () => {
+    const blockNumbers: OnBlockNumberResponse[] = []
+    const unwatch = watchBlockNumber(publicClient, {
+      emitOnBegin: true,
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    await wait(5000)
+    unwatch()
+    expect(blockNumbers.length).toBe(5)
+  })
+})
+
+describe('pollingInterval on client', () => {
+  test('watches for new block numbers', async () => {
+    const client = createPublicClient({
+      chain: localhost,
+      transport: http(),
+      pollingInterval: 500,
+    })
+
+    const blockNumbers: OnBlockNumberResponse[] = []
+    const unwatch = watchBlockNumber(client, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    await wait(2000)
+    unwatch()
+    expect(blockNumbers.length).toBe(2)
+  })
+})
+
+describe('behavior', () => {
+  test('does not emit when no new incoming blocks', async () => {
+    const blockNumbers: OnBlockNumberResponse[] = []
+    const unwatch = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+      pollingInterval: 100,
+    })
+    await wait(1200)
+    unwatch()
+    expect(blockNumbers.length).toBe(2)
+  })
+
+  test('watch > unwatch > watch', async () => {
+    let blockNumbers: OnBlockNumberResponse[] = []
+    let unwatch = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    await wait(3000)
+    unwatch()
+    expect(blockNumbers.length).toBe(2)
+
+    blockNumbers = []
+    unwatch = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    await wait(3000)
+    unwatch()
+    expect(blockNumbers.length).toBe(2)
+  })
+
+  test('multiple watchers', async () => {
+    let blockNumbers: OnBlockNumberResponse[] = []
+
+    let unwatch1 = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    let unwatch2 = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    let unwatch3 = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    await wait(3000)
+    unwatch1()
+    unwatch2()
+    unwatch3()
+    expect(blockNumbers.length).toBe(6)
+
+    blockNumbers = []
+
+    unwatch1 = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    unwatch2 = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    unwatch3 = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    await wait(3000)
+    unwatch1()
+    unwatch2()
+    unwatch3()
+    expect(blockNumbers.length).toBe(6)
+  })
+
+  test('immediately unwatch', async () => {
+    const blockNumbers: OnBlockNumberResponse[] = []
+    const unwatch = watchBlockNumber(publicClient, {
+      onBlockNumber: (blockNumber) => blockNumbers.push(blockNumber),
+    })
+    unwatch()
+    await wait(3000)
+    expect(blockNumbers.length).toBe(0)
+  })
+})
+
+describe('errors', () => {
+  test('handles error thrown', async () => {
+    vi.spyOn(getBlockNumber, 'getBlockNumber').mockRejectedValue(
+      new Error('foo'),
+    )
+
+    let unwatch: () => void = () => null
+    const error = await new Promise((resolve) => {
+      unwatch = watchBlockNumber(publicClient, {
+        onBlockNumber: () => null,
+        onError: resolve,
+      })
+    })
+    expect(error).toMatchInlineSnapshot('[Error: foo]')
+    unwatch()
+  })
+})

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,185 @@
+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 { publicClient, testClient } from '../../_test'
+import { wait } from '../../utils/wait'
+import { celo, localhost } from '../../chains'
+import { createPublicClient, http } from '../../clients'
+import { setIntervalMining } from '../test'
+
+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)
+})
+
+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,95 @@
+import type { Chain } from '../../chains'
+import type { PublicClient } from '../../clients'
+import type { BlockTag } 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,
+) => 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 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
+}
+
+/** @description Watches and returns information for incoming blocks. */
+export function watchBlocks<TChain extends Chain>(
+  client: PublicClient<any, TChain>,
+  {
+    blockTag = 'latest',
+    emitMissed = false,
+    emitOnBegin = false,
+    onBlock,
+    onError,
+    includeTransactions = false,
+    pollingInterval = client.pollingInterval,
+  }: WatchBlocksArgs<TChain>,
+) {
+  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/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()
+  })
+})