viem 0.0.1-cjs.10 → 0.0.1-sushi.26

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,19 @@
+import { bench, describe } from 'vitest'
+
+import { 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()
+  })
+})

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/getLogs.test.ts

@@ -0,0 +1,306 @@
+import { afterAll, assertType, beforeAll, describe, expect, test } from 'vitest'
+
+import {
+  accounts,
+  address,
+  initialBlockNumber,
+  publicClient,
+  testClient,
+  transfer1Data,
+  usdcContractConfig,
+  walletClient,
+} from '../../_test'
+
+import {
+  impersonateAccount,
+  mine,
+  setIntervalMining,
+  stopImpersonatingAccount,
+} from '../test'
+import { sendTransaction, writeContract } from '../wallet'
+import type { Log } from '../../types'
+import { getLogs } from './getLogs'
+import { getBlock } from './getBlock'
+
+beforeAll(async () => {
+  await setIntervalMining(testClient, { interval: 0 })
+  await impersonateAccount(testClient, {
+    address: address.vitalik,
+  })
+  await impersonateAccount(testClient, {
+    address: address.usdcHolder,
+  })
+})
+
+afterAll(async () => {
+  await setIntervalMining(testClient, { interval: 1 })
+  await stopImpersonatingAccount(testClient, {
+    address: address.vitalik,
+  })
+  await impersonateAccount(testClient, {
+    address: address.usdcHolder,
+  })
+})
+
+test('default', async () => {
+  const logs = await getLogs(publicClient)
+  expect(logs).toMatchInlineSnapshot('[]')
+})
+
+describe('events', () => {
+  test('no args', async () => {
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      to: usdcContractConfig.address,
+      data: transfer1Data(accounts[0].address),
+    })
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      to: usdcContractConfig.address,
+      data: transfer1Data(accounts[1].address),
+    })
+    await mine(testClient, { blocks: 1 })
+
+    let logs = await getLogs(publicClient)
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(2)
+  })
+
+  test('args: event', async () => {
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      to: usdcContractConfig.address,
+      data: transfer1Data(accounts[0].address),
+    })
+    await sendTransaction(walletClient, {
+      from: address.vitalik,
+      to: usdcContractConfig.address,
+      data: transfer1Data(accounts[1].address),
+    })
+
+    await mine(testClient, { blocks: 1 })
+
+    let logs = await getLogs(publicClient, {
+      event: 'Transfer(address from, address to, uint256 value)',
+    })
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(2)
+  })
+
+  test('args: fromBlock/toBlock', async () => {
+    let logs = await getLogs(publicClient, {
+      event: 'Transfer(address from, address to, uint256 value)',
+      fromBlock: initialBlockNumber - 5n,
+      toBlock: initialBlockNumber,
+    })
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(1056)
+  })
+
+  test('args: blockHash', async () => {
+    const block = await getBlock(publicClient, {
+      blockNumber: initialBlockNumber - 1n,
+    })
+    let logs = await getLogs(publicClient, {
+      event: 'Transfer(address from, address to, uint256 value)',
+      blockHash: block.hash!,
+    })
+    assertType<Log[]>(logs)
+    expect(logs.length).toBe(118)
+  })
+
+  test('args: singular `from`', async () => {
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.usdcHolder,
+      functionName: 'transfer',
+      args: [accounts[0].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      (
+        await getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            from: address.vitalik,
+          },
+        })
+      ).length,
+    ).toBe(2)
+    expect(
+      (
+        await getLogs(publicClient, {
+          event: 'Transfer(address indexed, address indexed, uint256)',
+          args: [address.vitalik],
+        })
+      ).length,
+    ).toBe(2)
+  })
+
+  test('args: multiple `from`', async () => {
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.usdcHolder,
+      functionName: 'transfer',
+      args: [accounts[0].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      (
+        await getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            from: [address.usdcHolder, address.vitalik],
+          },
+        })
+      ).length,
+    ).toBe(3)
+    expect(
+      (
+        await getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            from: [address.usdcHolder, address.vitalik],
+          },
+        })
+      ).length,
+    ).toBe(3)
+  })
+
+  test('args: singular `to`', async () => {
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.usdcHolder,
+      functionName: 'transfer',
+      args: [accounts[0].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      (
+        await getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            to: accounts[0].address,
+          },
+        })
+      ).length,
+    ).toBe(1)
+    expect(
+      (
+        await getLogs(publicClient, {
+          event: 'Transfer(address indexed, address indexed, uint256)',
+          args: [null, accounts[0].address],
+        })
+      ).length,
+    ).toBe(1)
+  })
+
+  test('args: multiple `to`', async () => {
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.usdcHolder,
+      functionName: 'transfer',
+      args: [accounts[0].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      (
+        await getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            to: [accounts[0].address, accounts[1].address],
+          },
+        })
+      ).length,
+    ).toBe(3)
+    expect(
+      (
+        await getLogs(publicClient, {
+          event: 'Transfer(address indexed, address indexed, uint256)',
+          args: [null, [accounts[0].address, accounts[1].address]],
+        })
+      ).length,
+    ).toBe(3)
+  })
+})

package/src/actions/public/getLogs.ts

@@ -0,0 +1,84 @@
+import type { PublicClient } from '../../clients'
+import type {
+  Log,
+  RpcLog,
+  Address,
+  BlockNumber,
+  BlockTag,
+  EventDefinition,
+  Hash,
+  LogTopic,
+} from '../../types'
+import { numberToHex } from '../../utils'
+import { formatLog } from '../../utils/formatters/log'
+import { buildFilterTopics, EventFilterArgs } from './createEventFilter'
+
+export type GetLogsArgs<TEventDefinition extends EventDefinition> = {
+  /** Address or list of addresses from which logs originated */
+  address?: Address | Address[]
+} & (
+  | { event: TEventDefinition; args?: EventFilterArgs<TEventDefinition> }
+  | {
+      event?: never
+      args?: never
+    }
+) &
+  (
+    | {
+        /** Block number or tag after which to include logs */
+        fromBlock?: BlockNumber<bigint> | BlockTag
+        /** Block number or tag before which to include logs */
+        toBlock?: BlockNumber<bigint> | BlockTag
+        blockHash?: never
+      }
+    | {
+        fromBlock?: never
+        toBlock?: never
+        /** Hash of block to include logs from */
+        blockHash?: Hash
+      }
+  )
+
+export type GetLogsResponse = Log[]
+
+/**
+ * @description Returns a collection of event logs.
+ */
+export async function getLogs<TEventDefinition extends EventDefinition,>(
+  client: PublicClient,
+  {
+    address,
+    blockHash,
+    fromBlock,
+    toBlock,
+    event,
+    args,
+  }: GetLogsArgs<TEventDefinition> = {},
+): Promise<GetLogsResponse> {
+  let topics: LogTopic[] = []
+  if (event) {
+    topics = buildFilterTopics({ event, args })
+  }
+  let logs: RpcLog[]
+  if (blockHash) {
+    logs = await client.request({
+      method: 'eth_getLogs',
+      params: [{ address, topics, blockHash }],
+    })
+  } else {
+    logs = await client.request({
+      method: 'eth_getLogs',
+      params: [
+        {
+          address,
+          topics,
+          fromBlock:
+            typeof fromBlock === 'bigint' ? numberToHex(fromBlock) : fromBlock,
+          toBlock: typeof toBlock === 'bigint' ? numberToHex(toBlock) : toBlock,
+        },
+      ],
+    })
+  }
+
+  return logs.map(formatLog)
+}

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

@@ -0,0 +1,34 @@
+import { expect, test } from 'vitest'
+import {
+  initialBlockNumber,
+  publicClient,
+  wagmiContractConfig,
+} from '../../_test'
+
+import { getBytecode } from './getBytecode'
+import { getStorageAt } from './getStorageAt'
+
+test('default', async () => {
+  expect(
+    await getStorageAt(publicClient, {
+      address: wagmiContractConfig.address,
+      slot: '0x0',
+    }),
+  ).toBe('0x7761676d6900000000000000000000000000000000000000000000000000000a')
+  expect(
+    await getStorageAt(publicClient, {
+      address: wagmiContractConfig.address,
+      slot: '0x1',
+    }),
+  ).toBe('0x5741474d4900000000000000000000000000000000000000000000000000000a')
+})
+
+test('args: blockNumber', async () => {
+  expect(
+    await getStorageAt(publicClient, {
+      address: wagmiContractConfig.address,
+      slot: '0x0',
+      blockNumber: initialBlockNumber,
+    }),
+  ).toBe('0x7761676d6900000000000000000000000000000000000000000000000000000a')
+})

package/src/actions/public/getStorageAt.ts

@@ -0,0 +1,32 @@
+import { PublicClient } from '../../clients'
+import { Address, BlockTag, Hex } from '../../types'
+import { numberToHex } from '../../utils'
+
+export type GetStorageAtArgs = {
+  address: Address
+  slot: Hex
+} & (
+  | {
+      blockNumber?: never
+      blockTag?: BlockTag
+    }
+  | {
+      blockNumber?: bigint
+      blockTag?: never
+    }
+)
+
+export type GetStorageAtResponse = Hex | undefined
+
+export async function getStorageAt(
+  client: PublicClient,
+  { address, blockNumber, blockTag = 'latest', slot }: GetStorageAtArgs,
+): Promise<GetStorageAtResponse> {
+  const blockNumberHex =
+    blockNumber !== undefined ? numberToHex(blockNumber) : undefined
+  const data = await client.request({
+    method: 'eth_getStorageAt',
+    params: [address, slot, blockNumberHex || blockTag],
+  })
+  return data
+}

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

@@ -0,0 +1,33 @@
+import { bench, describe } from 'vitest'
+
+import {
+  ethersProvider,
+  ethersV6Provider,
+  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('ethers@6: `getTransaction`', async () => {
+    await ethersV6Provider.getTransaction(hash)
+  })
+
+  bench('web3.js: `getTransaction`', async () => {
+    await web3Provider.eth.getTransaction(hash)
+  })
+})