viem 0.0.1-alpha.24 → 0.0.1-alpha.26

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

@@ -1,322 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-import { accounts, publicClient, testClient, walletClient } from '../../_test'
-import { WaitForTransactionReceiptTimeoutError } from '../../errors'
-import { wait } from '../../utils/wait'
-import { waitForTransactionReceipt } from './waitForTransactionReceipt'
-import { hexToNumber, parseEther, parseGwei } from '../../utils'
-import { sendTransaction } from '..'
-import { mine, setIntervalMining } from '../test'
-
-const sourceAccount = accounts[0]
-const targetAccount = accounts[1]
-
-test('waits for transaction (send -> wait -> mine)', async () => {
-  const hash = await sendTransaction(walletClient, {
-    from: sourceAccount.address,
-    to: targetAccount.address,
-    value: parseEther('1'),
-  })
-  const { status } = await waitForTransactionReceipt(publicClient, {
-    hash,
-  })
-  expect(status).toBe('success')
-})
-
-test('waits for transaction (send -> mine -> wait)', async () => {
-  const hash = await sendTransaction(walletClient, {
-    from: sourceAccount.address,
-    to: targetAccount.address,
-    value: parseEther('1'),
-  })
-  await mine(testClient, { blocks: 1 })
-  const { status } = await waitForTransactionReceipt(publicClient, {
-    hash,
-  })
-  expect(status).toBe('success')
-})
-
-describe('replaced transactions', () => {
-  test('repriced', async () => {
-    await mine(testClient, { blocks: 10 })
-    await setIntervalMining(testClient, { interval: 0 })
-
-    const nonce = hexToNumber(
-      (await publicClient.request({
-        method: 'eth_getTransactionCount',
-        params: [sourceAccount.address, 'latest'],
-      })) ?? '0x0',
-    )
-
-    const hash = await sendTransaction(walletClient, {
-      from: sourceAccount.address,
-      to: targetAccount.address,
-      value: parseEther('1'),
-      maxFeePerGas: parseGwei('10'),
-      nonce,
-    })
-
-    let replacement: any
-    const [receipt] = await Promise.all([
-      waitForTransactionReceipt(publicClient, {
-        hash,
-        onReplaced: (replacement_) => (replacement = replacement_),
-      }),
-      (async () => {
-        await wait(100)
-
-        // speed up
-        await sendTransaction(walletClient, {
-          from: sourceAccount.address,
-          to: targetAccount.address,
-          value: parseEther('1'),
-          nonce,
-          maxFeePerGas: parseGwei('20'),
-        })
-
-        await setIntervalMining(testClient, { interval: 1 })
-      })(),
-    ])
-
-    expect(receipt !== null).toBeTruthy()
-    expect(replacement.reason).toBe('repriced')
-    expect(replacement.replacedTransaction).toBeDefined()
-    expect(replacement.transaction).toBeDefined()
-    expect(replacement.transactionReceipt).toBeDefined()
-  })
-
-  test('repriced (skipped blocks)', async () => {
-    await mine(testClient, { blocks: 10 })
-    await setIntervalMining(testClient, { interval: 0 })
-
-    const nonce = hexToNumber(
-      (await publicClient.request({
-        method: 'eth_getTransactionCount',
-        params: [sourceAccount.address, 'latest'],
-      })) ?? '0x0',
-    )
-
-    const hash = await sendTransaction(walletClient, {
-      from: sourceAccount.address,
-      to: targetAccount.address,
-      value: parseEther('1'),
-      maxFeePerGas: parseGwei('10'),
-      nonce,
-    })
-
-    const [receipt] = await Promise.all([
-      waitForTransactionReceipt(publicClient, {
-        hash,
-      }),
-      (async () => {
-        await wait(100)
-
-        // speed up
-        await sendTransaction(walletClient, {
-          from: sourceAccount.address,
-          to: targetAccount.address,
-          value: parseEther('1'),
-          nonce,
-          maxFeePerGas: parseGwei('20'),
-        })
-
-        await wait(1000)
-        await mine(testClient, { blocks: 5 })
-      })(),
-    ])
-
-    expect(receipt !== null).toBeTruthy()
-
-    await setIntervalMining(testClient, { interval: 1 })
-  })
-
-  test('cancelled', async () => {
-    await mine(testClient, { blocks: 10 })
-    await setIntervalMining(testClient, { interval: 0 })
-
-    const nonce = hexToNumber(
-      (await publicClient.request({
-        method: 'eth_getTransactionCount',
-        params: [sourceAccount.address, 'latest'],
-      })) ?? '0x0',
-    )
-
-    const hash = await sendTransaction(walletClient, {
-      from: sourceAccount.address,
-      to: targetAccount.address,
-      value: parseEther('1'),
-      maxFeePerGas: parseGwei('10'),
-      nonce,
-    })
-
-    let replacement: any
-    const [receipt] = await Promise.all([
-      waitForTransactionReceipt(publicClient, {
-        hash,
-        onReplaced: (replacement_) => (replacement = replacement_),
-      }),
-      (async () => {
-        await wait(100)
-
-        // speed up
-        await sendTransaction(walletClient, {
-          from: sourceAccount.address,
-          to: sourceAccount.address,
-          value: parseEther('0'),
-          nonce,
-          maxFeePerGas: parseGwei('20'),
-        })
-
-        await setIntervalMining(testClient, { interval: 1 })
-      })(),
-    ])
-
-    expect(receipt !== null).toBeTruthy()
-    expect(replacement.reason).toBe('cancelled')
-    expect(replacement.replacedTransaction).toBeDefined()
-    expect(replacement.transaction).toBeDefined()
-    expect(replacement.transactionReceipt).toBeDefined()
-  })
-
-  test('replaced', async () => {
-    await mine(testClient, { blocks: 10 })
-    await setIntervalMining(testClient, { interval: 0 })
-
-    const nonce = hexToNumber(
-      (await publicClient.request({
-        method: 'eth_getTransactionCount',
-        params: [sourceAccount.address, 'latest'],
-      })) ?? '0x0',
-    )
-
-    const hash = await sendTransaction(walletClient, {
-      from: sourceAccount.address,
-      to: targetAccount.address,
-      value: parseEther('1'),
-      maxFeePerGas: parseGwei('10'),
-      nonce,
-    })
-
-    let replacement: any
-    const [receipt] = await Promise.all([
-      waitForTransactionReceipt(publicClient, {
-        hash,
-        onReplaced: (replacement_) => (replacement = replacement_),
-      }),
-      (async () => {
-        await wait(100)
-
-        // speed up
-        await sendTransaction(walletClient, {
-          from: sourceAccount.address,
-          to: targetAccount.address,
-          value: parseEther('2'),
-          nonce,
-          maxFeePerGas: parseGwei('20'),
-        })
-
-        await setIntervalMining(testClient, { interval: 1 })
-      })(),
-    ])
-
-    expect(receipt !== null).toBeTruthy()
-    expect(replacement.reason).toBe('replaced')
-    expect(replacement.replacedTransaction).toBeDefined()
-    expect(replacement.transaction).toBeDefined()
-    expect(replacement.transactionReceipt).toBeDefined()
-  })
-})
-
-describe('args: confirmations', () => {
-  test('waits for confirmations', async () => {
-    const hash = await sendTransaction(walletClient, {
-      from: sourceAccount.address,
-      to: targetAccount.address,
-      value: parseEther('1'),
-      maxFeePerGas: parseGwei('10'),
-    })
-
-    const start = Date.now()
-    const receipt = await waitForTransactionReceipt(publicClient, {
-      hash,
-      confirmations: 3,
-    })
-    const end = Date.now()
-
-    expect(receipt !== null).toBeTruthy()
-    expect(end - start).toBeGreaterThan(3000 - 100)
-    expect(end - start).toBeLessThanOrEqual(3000 + 100)
-  })
-
-  test('waits for confirmations (replaced)', async () => {
-    await mine(testClient, { blocks: 10 })
-    await setIntervalMining(testClient, { interval: 0 })
-
-    const nonce = hexToNumber(
-      (await publicClient.request({
-        method: 'eth_getTransactionCount',
-        params: [sourceAccount.address, 'latest'],
-      })) ?? '0x0',
-    )
-
-    const hash = await sendTransaction(walletClient, {
-      from: sourceAccount.address,
-      to: targetAccount.address,
-      value: parseEther('1'),
-      maxFeePerGas: parseGwei('10'),
-      nonce,
-    })
-
-    const [receipt] = await Promise.all([
-      waitForTransactionReceipt(publicClient, {
-        confirmations: 3,
-        hash,
-      }),
-      (async () => {
-        await wait(100)
-
-        // speed up
-        await sendTransaction(walletClient, {
-          from: sourceAccount.address,
-          to: targetAccount.address,
-          value: parseEther('1'),
-          nonce,
-          maxFeePerGas: parseGwei('20'),
-        })
-
-        await wait(1000)
-        await setIntervalMining(testClient, { interval: 1 })
-      })(),
-    ])
-
-    expect(receipt !== null).toBeTruthy()
-  })
-})
-
-test('args: timeout', async () => {
-  const hash = await sendTransaction(walletClient, {
-    from: sourceAccount.address,
-    to: targetAccount.address,
-    value: parseEther('1'),
-  })
-  await expect(() =>
-    waitForTransactionReceipt(publicClient, {
-      hash,
-      timeout: 500,
-    }),
-  ).rejects.toThrowError(WaitForTransactionReceiptTimeoutError)
-})
-
-describe('errors', () => {
-  test('throws when transaction not found', async () => {
-    await expect(() =>
-      waitForTransactionReceipt(publicClient, {
-        hash: '0xa4b1f606b66105fa45cb5db23d2f6597075701e7f0e2367f4e6a39d17a8cf98f',
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Transaction with hash \\"0xa4b1f606b66105fa45cb5db23d2f6597075701e7f0e2367f4e6a39d17a8cf98f\\" could not be found.
-
-      Version: viem@1.0.2"
-    `)
-  })
-})

package/src/actions/public/waitForTransactionReceipt.ts

@@ -1,170 +0,0 @@
-import type { PublicClient } from '../../clients'
-import {
-  TransactionNotFoundError,
-  TransactionReceiptNotFoundError,
-  WaitForTransactionReceiptTimeoutError,
-} from '../../errors'
-import type { Chain, Hash, Transaction } from '../../types'
-import { observe } from '../../utils/observe'
-import { getBlock, watchBlockNumber } from '../public'
-
-import type { GetTransactionResponse } from './getTransaction'
-import { getTransaction } from './getTransaction'
-import type { GetTransactionReceiptResponse } from './getTransactionReceipt'
-import { getTransactionReceipt } from './getTransactionReceipt'
-
-export type ReplacementReason = 'cancelled' | 'replaced' | 'repriced'
-export type ReplacementResponse<TChain extends Chain = Chain> = {
-  reason: ReplacementReason
-  replacedTransaction: Transaction
-  transaction: Transaction
-  transactionReceipt: GetTransactionReceiptResponse<TChain>
-}
-
-export type WaitForTransactionReceiptResponse<TChain extends Chain = Chain> =
-  GetTransactionReceiptResponse<TChain>
-
-export type WaitForTransactionReceiptArgs<TChain extends Chain = Chain> = {
-  /** The number of confirmations (blocks that have passed) to wait before resolving. */
-  confirmations?: number
-  /** The hash of the transaction. */
-  hash: Hash
-  onReplaced?: (response: ReplacementResponse<TChain>) => void
-  /** Polling frequency (in ms). Defaults to the client's pollingInterval config. */
-  pollingInterval?: number
-  /** Optional timeout (in milliseconds) to wait before stopping polling. */
-  timeout?: number
-}
-
-export async function waitForTransactionReceipt<TChain extends Chain>(
-  client: PublicClient<any, TChain>,
-  {
-    confirmations = 1,
-    hash,
-    onReplaced,
-    pollingInterval = client.pollingInterval,
-    timeout,
-  }: WaitForTransactionReceiptArgs<TChain>,
-): Promise<WaitForTransactionReceiptResponse<TChain>> {
-  const observerId = JSON.stringify([
-    'waitForTransactionReceipt',
-    client.uid,
-    hash,
-  ])
-
-  let transaction: GetTransactionResponse<TChain> | undefined
-  let replacedTransaction: GetTransactionResponse<TChain> | undefined
-  let receipt: GetTransactionReceiptResponse<TChain>
-
-  return new Promise((resolve, reject) => {
-    if (timeout)
-      setTimeout(
-        () => reject(new WaitForTransactionReceiptTimeoutError({ hash })),
-        timeout,
-      )
-
-    const unobserve = observe(
-      observerId,
-      { onReplaced, resolve, reject },
-      (emit) => {
-        const unwatch = watchBlockNumber(client, {
-          emitMissed: true,
-          emitOnBegin: true,
-          pollingInterval,
-          async onBlockNumber(blockNumber) {
-            const done = async (fn: () => void) => {
-              unwatch()
-              fn()
-              unobserve()
-            }
-
-            try {
-              // If we already have a valid receipt, let's check if we have enough
-              // confirmations. If we do, then we can resolve.
-              if (receipt) {
-                if (blockNumber - receipt.blockNumber + 1n < confirmations)
-                  return
-
-                done(() => emit.resolve(receipt))
-                return
-              }
-
-              // Get the transaction to check if it's been replaced.
-              transaction = await getTransaction(client, { hash })
-
-              // Get the receipt to check if it's been processed.
-              receipt = await getTransactionReceipt(client, { hash })
-
-              // Check if we have enough confirmations. If not, continue polling.
-              if (blockNumber - receipt.blockNumber + 1n < confirmations) return
-
-              done(() => emit.resolve(receipt))
-            } catch (err) {
-              // If the receipt is not found, the transaction will be pending.
-              // We need to check if it has potentially been replaced.
-              if (
-                transaction &&
-                (err instanceof TransactionNotFoundError ||
-                  err instanceof TransactionReceiptNotFoundError)
-              ) {
-                replacedTransaction = transaction
-
-                // Let's retrieve the transactions from the current block.
-                const block = await getBlock(client, {
-                  blockNumber,
-                  includeTransactions: true,
-                })
-
-                const replacementTransaction = (
-                  block.transactions as Transaction[]
-                ).find(
-                  ({ from, nonce }) =>
-                    from === replacedTransaction!.from &&
-                    nonce === replacedTransaction!.nonce,
-                )
-
-                // If we couldn't find a replacement transaction, continue polling.
-                if (!replacementTransaction) return
-
-                // If we found a replacement transaction, return it's receipt.
-                receipt = await getTransactionReceipt(client, {
-                  hash: replacementTransaction.hash,
-                })
-
-                // Check if we have enough confirmations. If not, continue polling.
-                if (blockNumber - receipt.blockNumber + 1n < confirmations)
-                  return
-
-                let reason: ReplacementReason = 'replaced'
-                if (
-                  replacementTransaction.to === replacedTransaction.to &&
-                  replacementTransaction.value === replacedTransaction.value
-                ) {
-                  reason = 'repriced'
-                } else if (
-                  replacementTransaction.from === replacementTransaction.to &&
-                  replacementTransaction.value === 0n
-                ) {
-                  reason = 'cancelled'
-                }
-
-                done(() => {
-                  emit.onReplaced?.({
-                    reason,
-                    replacedTransaction: replacedTransaction!,
-                    transaction: replacementTransaction,
-                    transactionReceipt: receipt,
-                  })
-                  emit.resolve(receipt)
-                })
-              } else {
-                done(() => emit.reject(err))
-              }
-            }
-          },
-        })
-        return unwatch
-      },
-    )
-  })
-}

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

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