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

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

@@ -0,0 +1,187 @@
+import { afterAll, assertType, beforeAll, describe, expect, test } from 'vitest'
+
+import {
+  accounts,
+  initialBlockNumber,
+  publicClient,
+  testClient,
+  transfer1Data,
+  usdcAddress,
+  vitalikAddress,
+  walletClient,
+} from '../../_test'
+
+import {
+  impersonateAccount,
+  mine,
+  setIntervalMining,
+  stopImpersonatingAccount,
+} from '../test'
+import { sendTransaction } from '../wallet'
+import { parseEther } from '../../utils'
+import type { Hash, Log } from '../../types'
+import { createBlockFilter } from './createBlockFilter'
+import { createEventFilter } from './createEventFilter'
+import { createPendingTransactionFilter } from './createPendingTransactionFilter'
+import { getFilterChanges } from './getFilterChanges'
+
+beforeAll(async () => {
+  await setIntervalMining(testClient, { interval: 0 })
+  await impersonateAccount(testClient, {
+    address: vitalikAddress,
+  })
+})
+
+afterAll(async () => {
+  await setIntervalMining(testClient, { interval: 1 })
+  await stopImpersonatingAccount(testClient, {
+    address: vitalikAddress,
+  })
+})
+
+test('default', async () => {
+  const filter = await createPendingTransactionFilter(publicClient)
+  expect(
+    await getFilterChanges(publicClient, { filter }),
+  ).toMatchInlineSnapshot('[]')
+})
+
+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)
+
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('1'),
+  })
+
+  hashes = await getFilterChanges(publicClient, { filter })
+  expect(hashes.length).toBe(1)
+})
+
+test('new blocks', async () => {
+  const filter = await createBlockFilter(publicClient)
+
+  await mine(testClient, { blocks: 2 })
+
+  let hashes = await getFilterChanges(publicClient, { filter })
+  assertType<Hash[]>(hashes)
+  expect(hashes.length).toBe(2)
+
+  hashes = await getFilterChanges(publicClient, { filter })
+  expect(hashes.length).toBe(0)
+
+  await mine(testClient, { blocks: 1 })
+
+  hashes = await getFilterChanges(publicClient, { filter })
+  expect(hashes.length).toBe(1)
+})
+
+describe('events', () => {
+  test('no args', async () => {
+    const filter = await createEventFilter(publicClient)
+
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[0].address),
+    })
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[1].address),
+    })
+
+    await mine(testClient, { blocks: 1 })
+
+    let logs = await getFilterChanges(publicClient, { filter })
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(2)
+
+    logs = await getFilterChanges(publicClient, { filter })
+    expect(logs.length).toBe(0)
+
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[2].address),
+    })
+
+    await mine(testClient, { blocks: 1 })
+
+    logs = await getFilterChanges(publicClient, { filter })
+    expect(logs.length).toBe(1)
+  })
+
+  test('args: event', async () => {
+    const filter = await createEventFilter(publicClient, {
+      event: 'Transfer(address from, address to, uint256 value)',
+    })
+
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[0].address),
+    })
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[1].address),
+    })
+
+    await mine(testClient, { blocks: 1 })
+
+    let logs = await getFilterChanges(publicClient, { filter })
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(2)
+
+    logs = await getFilterChanges(publicClient, { filter })
+    expect(logs.length).toBe(0)
+
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[2].address),
+    })
+
+    await mine(testClient, { blocks: 1 })
+
+    logs = await getFilterChanges(publicClient, { filter })
+    expect(logs.length).toBe(1)
+  })
+
+  test('args: fromBlock/toBlock', async () => {
+    const filter = await createEventFilter(publicClient, {
+      event: 'Transfer(address from, address to, uint256 value)',
+      fromBlock: initialBlockNumber - 5n,
+      toBlock: initialBlockNumber,
+    })
+
+    let logs = await getFilterChanges(publicClient, { filter })
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(1056)
+
+    logs = await getFilterChanges(publicClient, { filter })
+    expect(logs.length).toBe(0)
+  })
+})

package/src/actions/public/getFilterChanges.ts

@@ -0,0 +1,23 @@
+import type { PublicClient } from '../../clients'
+import type { Filter, FilterType, Hash, Log } from '../../types'
+
+import { formatLog } from '../../utils/formatters/log'
+
+export type GetFilterChangesArgs<TFilterType extends FilterType> = {
+  filter: Filter<TFilterType>
+}
+export type GetFilterChangesResponse<TFilterType extends FilterType> =
+  TFilterType extends 'event' ? Log[] : Hash[]
+
+export async function getFilterChanges<TFilterType extends FilterType>(
+  client: PublicClient,
+  { filter }: GetFilterChangesArgs<TFilterType>,
+) {
+  const logs = await client.request({
+    method: 'eth_getFilterChanges',
+    params: [filter.id],
+  })
+  return logs.map((log) =>
+    typeof log === 'string' ? log : formatLog(log),
+  ) as GetFilterChangesResponse<TFilterType>
+}

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

@@ -0,0 +1,102 @@
+import { afterAll, assertType, beforeAll, describe, expect, test } from 'vitest'
+
+import {
+  accounts,
+  initialBlockNumber,
+  publicClient,
+  testClient,
+  transfer1Data,
+  usdcAddress,
+  vitalikAddress,
+  walletClient,
+} from '../../_test'
+
+import {
+  impersonateAccount,
+  mine,
+  setIntervalMining,
+  stopImpersonatingAccount,
+} from '../test'
+import { sendTransaction } from '../wallet'
+import type { Log } from '../../types'
+import { createEventFilter } from './createEventFilter'
+import { getFilterLogs } from './getFilterLogs'
+
+beforeAll(async () => {
+  await setIntervalMining(testClient, { interval: 0 })
+  await impersonateAccount(testClient, {
+    address: vitalikAddress,
+  })
+})
+
+afterAll(async () => {
+  await setIntervalMining(testClient, { interval: 1 })
+  await stopImpersonatingAccount(testClient, {
+    address: vitalikAddress,
+  })
+})
+
+test('default', async () => {
+  const filter = await createEventFilter(publicClient)
+  expect(await getFilterLogs(publicClient, { filter })).toMatchInlineSnapshot(
+    '[]',
+  )
+})
+
+describe('events', () => {
+  test('no args', async () => {
+    const filter = await createEventFilter(publicClient)
+
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[0].address),
+    })
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[1].address),
+    })
+
+    await mine(testClient, { blocks: 1 })
+
+    let logs = await getFilterLogs(publicClient, { filter })
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(2)
+  })
+
+  test('args: event', async () => {
+    const filter = await createEventFilter(publicClient, {
+      event: 'Transfer(address from, address to, uint256 value)',
+    })
+
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[0].address),
+    })
+    await sendTransaction(walletClient, {
+      from: vitalikAddress,
+      to: usdcAddress,
+      data: transfer1Data(accounts[1].address),
+    })
+
+    await mine(testClient, { blocks: 1 })
+
+    let logs = await getFilterLogs(publicClient, { filter })
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(2)
+  })
+
+  test('args: fromBlock/toBlock', async () => {
+    const filter = await createEventFilter(publicClient, {
+      event: 'Transfer(address from, address to, uint256 value)',
+      fromBlock: initialBlockNumber - 5n,
+      toBlock: initialBlockNumber,
+    })
+
+    let logs = await getFilterLogs(publicClient, { filter })
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(1056)
+  })
+})

package/src/actions/public/getFilterLogs.ts

@@ -0,0 +1,20 @@
+import type { PublicClient } from '../../clients'
+import type { Filter, FilterType, Hash, Log } from '../../types'
+
+import { formatLog } from '../../utils/formatters/log'
+
+export type GetFilterLogsArgs = {
+  filter: Filter<'event'>
+}
+export type GetFilterLogsResponse = Log[]
+
+export async function getFilterLogs<TFilterType extends FilterType>(
+  client: PublicClient,
+  { filter }: GetFilterLogsArgs,
+): Promise<GetFilterLogsResponse> {
+  const logs = await client.request({
+    method: 'eth_getFilterLogs',
+    params: [filter.id],
+  })
+  return logs.map(formatLog)
+}

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

@@ -0,0 +1,28 @@
+import { bench, describe } from 'vitest'
+
+import {
+  essentialProvider,
+  ethersProvider,
+  publicClient,
+  web3Provider,
+} from '../../_test'
+
+import { getGasPrice } from './getGasPrice'
+
+describe('Get Gas Price', () => {
+  bench('viem: `getGasPrice`', async () => {
+    await getGasPrice(publicClient)
+  })
+
+  bench('ethers: `getGasPrice`', async () => {
+    await ethersProvider.getGasPrice()
+  })
+
+  bench('web3.js: `getGasPrice`', async () => {
+    await web3Provider.eth.getGasPrice()
+  })
+
+  bench('essential-eth: `getGasPrice`', async () => {
+    await essentialProvider.getGasPrice()
+  })
+})

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

@@ -0,0 +1,8 @@
+import { expect, test } from 'vitest'
+
+import { publicClient } from '../../_test'
+import { getGasPrice } from './getGasPrice'
+
+test('getGasPrice', async () => {
+  expect(await getGasPrice(publicClient)).toBeDefined()
+})

package/src/actions/public/getGasPrice.ts

@@ -0,0 +1,15 @@
+import type { PublicClient } from '../../clients'
+
+export type GetGasPriceResponse = bigint
+
+/**
+ * @description Returns the current price of gas (in wei).
+ */
+export async function getGasPrice(
+  client: PublicClient,
+): Promise<GetGasPriceResponse> {
+  const gasPrice = await client.request({
+    method: 'eth_gasPrice',
+  })
+  return BigInt(gasPrice)
+}

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

@@ -0,0 +1,33 @@
+import { bench, describe } from 'vitest'
+
+import {
+  essentialProvider,
+  ethersProvider,
+  publicClient,
+  web3Provider,
+} from '../../_test'
+
+import { getTransaction } from './getTransaction'
+
+const hash =
+  '0xa4b1f606b66105fa45cb5db23d2f6597075701e7f0e2367f4e6a39d17a8cf98b'
+
+describe('Get Transaction', () => {
+  bench('viem: `getTransaction`', async () => {
+    await getTransaction(publicClient, {
+      hash,
+    })
+  })
+
+  bench('ethers: `getTransaction`', async () => {
+    await ethersProvider.getTransaction(hash)
+  })
+
+  bench('web3.js: `getTransaction`', async () => {
+    await web3Provider.eth.getTransaction(hash)
+  })
+
+  bench('essential-eth: `getTransaction`', async () => {
+    await essentialProvider.getTransaction(hash)
+  })
+})