viem 0.0.1-sushi.27 → 0.1.0

package/src/actions/public/getFilterLogs.ts

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

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

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

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

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

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

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

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

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