viem 0.0.1-alpha.14 → 0.0.1-alpha.16

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()
+  })
+})

package/src/actions/public/watchPendingTransactions.ts

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

package/src/actions/test/getTxpoolContent.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from 'vitest'
+
+import { accounts, testClient, walletClient } from '../../_test'
+import { parseEther } from '../../utils'
+import { sendTransaction } from '../wallet/sendTransaction'
+
+import { getTxpoolContent } from './getTxpoolContent'
+import { mine } from './mine'
+
+test('gets txpool content (empty)', async () => {
+  await mine(testClient, { blocks: 1 })
+
+  expect(await getTxpoolContent(testClient)).toMatchInlineSnapshot(`
+    {
+      "pending": {},
+      "queued": {},
+    }
+  `)
+})
+
+test('gets txpool content (pending)', async () => {
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('2'),
+  })
+  await sendTransaction(walletClient, {
+    from: accounts[2].address,
+    to: accounts[3].address,
+    value: parseEther('3'),
+  })
+  const content1 = await getTxpoolContent(testClient)
+  expect(Object.values(content1.pending).length).toBe(2)
+  expect(Object.values(content1.queued).length).toBe(0)
+  expect(content1.pending[accounts[0].address]).toBeDefined()
+  expect(content1.pending[accounts[2].address]).toBeDefined()
+
+  await mine(testClient, { blocks: 1 })
+
+  const content2 = await getTxpoolContent(testClient)
+  expect(Object.values(content2.pending).length).toBe(0)
+  expect(Object.values(content2.queued).length).toBe(0)
+  expect(content2.pending[accounts[0].address]).toBeUndefined()
+  expect(content2.pending[accounts[2].address]).toBeUndefined()
+})

package/src/actions/test/getTxpoolContent.ts

@@ -0,0 +1,7 @@
+import type { TestClient } from '../../clients'
+
+export async function getTxpoolContent(client: TestClient) {
+  return await client.request({
+    method: 'txpool_content',
+  })
+}