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

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

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

@@ -0,0 +1,171 @@
+import type { Chain } from '../../chains'
+import type { PublicClient } from '../../clients'
+import {
+  TransactionNotFoundError,
+  TransactionReceiptNotFoundError,
+  WaitForTransactionReceiptTimeoutError,
+} from '../../errors'
+import type { 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

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