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

package/src/actions/public/simulateContract.ts

@@ -0,0 +1,102 @@
+import { Abi } from 'abitype'
+
+import type { Chain, Formatter } from '../../chains'
+import type { PublicClient } from '../../clients'
+import type {
+  Address,
+  ExtractArgsFromAbi,
+  ExtractResultFromAbi,
+  ExtractFunctionNameFromAbi,
+  GetValue,
+} from '../../types'
+import {
+  EncodeFunctionDataArgs,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+} from '../../utils'
+import { WriteContractArgs } from '../wallet'
+import { call, CallArgs, FormattedCall } from './call'
+
+export type FormattedSimulateContract<
+  TFormatter extends Formatter | undefined = Formatter,
+> = FormattedCall<TFormatter>
+
+export type SimulateContractArgs<
+  TChain extends Chain = Chain,
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = any,
+> = Omit<CallArgs<TChain>, 'to' | 'data' | 'value'> & {
+  address: Address
+  abi: TAbi
+  functionName: ExtractFunctionNameFromAbi<
+    TAbi,
+    TFunctionName,
+    'payable' | 'nonpayable'
+  >
+  value?: GetValue<TAbi, TFunctionName, CallArgs<TChain>['value']>
+} & ExtractArgsFromAbi<TAbi, TFunctionName>
+
+export type SimulateContractResponse<
+  TChain extends Chain = Chain,
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = string,
+> = {
+  result: ExtractResultFromAbi<TAbi, TFunctionName>
+  request: WriteContractArgs<TChain, TAbi, TFunctionName> & {
+    address: Address
+    abi: TAbi
+    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  } & ExtractArgsFromAbi<TAbi, TFunctionName>
+}
+
+export async function simulateContract<
+  TChain extends Chain,
+  TAbi extends Abi = Abi,
+  TFunctionName extends string = any,
+>(
+  client: PublicClient,
+  {
+    abi,
+    address,
+    args,
+    functionName,
+    ...callRequest
+  }: SimulateContractArgs<TChain, TAbi, TFunctionName>,
+): Promise<SimulateContractResponse<TChain, TAbi, TFunctionName>> {
+  const calldata = encodeFunctionData({
+    abi,
+    args,
+    functionName,
+  } as unknown as EncodeFunctionDataArgs<TAbi, TFunctionName>)
+  try {
+    const { data } = await call(client, {
+      data: calldata,
+      to: address,
+      ...callRequest,
+    } as unknown as CallArgs<TChain>)
+    const result = decodeFunctionResult({
+      abi,
+      functionName,
+      data: data || '0x',
+    })
+    return {
+      result,
+      request: {
+        abi,
+        address,
+        args,
+        functionName,
+        ...callRequest,
+      },
+    } as unknown as SimulateContractResponse<TChain, TAbi, TFunctionName>
+  } catch (err) {
+    throw getContractError(err, {
+      abi,
+      address,
+      args,
+      functionName,
+      sender: callRequest.from,
+    })
+  }
+}

package/src/actions/public/uninstallFilter.bench.ts

@@ -0,0 +1,13 @@
+import { bench, describe } from 'vitest'
+
+import { publicClient } from '../../_test'
+import { createPendingTransactionFilter } from './createPendingTransactionFilter'
+import { uninstallFilter } from './uninstallFilter'
+
+const filter = await createPendingTransactionFilter(publicClient)
+
+describe('Get Filter Changes', () => {
+  bench('viem: `uninstallFilter`', async () => {
+    await uninstallFilter(publicClient, { filter })
+  })
+})

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

@@ -0,0 +1,65 @@
+import { assertType, expect, test } from 'vitest'
+
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
+
+import { createPendingTransactionFilter } from './createPendingTransactionFilter'
+import { getFilterChanges } from './getFilterChanges'
+import { uninstallFilter } from './uninstallFilter'
+import { mine } from '../test'
+import { sendTransaction } from '../wallet'
+import { parseEther } from '../../utils'
+import type { Hash } from '../../types'
+
+test('default', async () => {
+  const filter = await createPendingTransactionFilter(publicClient)
+  expect(await uninstallFilter(publicClient, { filter })).toBeTruthy()
+})
+
+test('pending txns', async () => {
+  const filter = await createPendingTransactionFilter(publicClient)
+
+  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'),
+  })
+
+  let hashes = await getFilterChanges(publicClient, { filter })
+  assertType<Hash[]>(hashes)
+  expect(hashes.length).toBe(2)
+
+  mine(testClient, { blocks: 1 })
+
+  hashes = await getFilterChanges(publicClient, { filter })
+  expect(hashes.length).toBe(0)
+
+  expect(await uninstallFilter(publicClient, { filter })).toBeTruthy()
+
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('1'),
+  })
+
+  hashes = await getFilterChanges(publicClient, { filter })
+  expect(hashes.length).toBe(0)
+})
+
+test('filter does not exist', async () => {
+  expect(
+    await uninstallFilter(publicClient, {
+      filter: { id: '0x1', type: 'default' },
+    }),
+  ).toBeFalsy()
+})
+
+test('filter already uninstalled', async () => {
+  const filter = await createPendingTransactionFilter(publicClient)
+  expect(await uninstallFilter(publicClient, { filter })).toBeTruthy()
+  expect(await uninstallFilter(publicClient, { filter })).toBeFalsy()
+})

package/src/actions/public/uninstallFilter.ts

@@ -0,0 +1,17 @@
+import type { PublicClient } from '../../clients'
+import type { Filter } from '../../types'
+
+export type UninstallFilterArgs = {
+  filter: Filter<any>
+}
+export type UninstallFilterResponse = boolean
+
+export async function uninstallFilter(
+  client: PublicClient,
+  { filter }: UninstallFilterArgs,
+): Promise<UninstallFilterResponse> {
+  return client.request({
+    method: 'eth_uninstallFilter',
+    params: [filter.id],
+  })
+}

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