viem 0.0.1-alpha.25 → 0.0.1-alpha.26

package/src/actions/public/watchBlockNumber.ts

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

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

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

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