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

package/src/actions/public/createEventFilter.ts

@@ -0,0 +1,81 @@
+import type { PublicClient } from '../../clients'
+
+import type {
+  Address,
+  BlockNumber,
+  BlockTag,
+  ExtractArgsFromEventDefinition,
+  Filter,
+  Hex,
+} from '../../types'
+import { getEventSignature, numberToHex } from '../../utils'
+
+export type EventFilterArgs<TEventDefinition extends `${string}(${string})`> =
+  ExtractArgsFromEventDefinition<TEventDefinition>
+
+export type CreateEventFilterArgs<
+  TEventDefinition extends `${string}(${string})`,
+> = {
+  address?: Address | Address[]
+  fromBlock?: BlockNumber | BlockTag
+  toBlock?: BlockNumber | BlockTag
+} & (
+  | {
+      event: TEventDefinition
+      args?: EventFilterArgs<TEventDefinition>
+    }
+  | {
+      event?: never
+      args?: never
+    }
+)
+export type CreateEventFilterResponse = Filter<'event'>
+
+type EncodedArg = Hex | Hex[] | null
+
+export async function createEventFilter<
+  TEventDefinition extends `${string}(${string})`,
+>(
+  client: PublicClient,
+  {
+    address,
+    event,
+    args,
+    fromBlock,
+    toBlock,
+  }: CreateEventFilterArgs<TEventDefinition> = {},
+): Promise<CreateEventFilterResponse> {
+  let topics: EncodedArg[] = []
+  if (event) {
+    topics = buildFilterTopics({ event, args })
+  }
+  const id = await client.request({
+    method: 'eth_newFilter',
+    params: [
+      {
+        address,
+        fromBlock:
+          typeof fromBlock === 'bigint' ? numberToHex(fromBlock) : fromBlock,
+        toBlock: typeof toBlock === 'bigint' ? numberToHex(toBlock) : toBlock,
+        ...(topics.length ? { topics } : {}),
+      },
+    ],
+  })
+  return { id, type: 'event' }
+}
+
+export function buildFilterTopics<
+  TEventDefinition extends `${string}(${string})`,
+>({
+  event,
+  args: _args,
+}: {
+  event: TEventDefinition
+  args?: EventFilterArgs<TEventDefinition>
+}) {
+  const signature = getEventSignature(event)
+
+  // TODO: support args
+
+  return [signature]
+}

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

@@ -0,0 +1,11 @@
+import { bench, describe } from 'vitest'
+
+import { publicClient } from '../../_test'
+
+import { createPendingTransactionFilter } from './createPendingTransactionFilter'
+
+describe('Create Pending Transaction Filter', () => {
+  bench('viem: `createPendingTransactionFilter`', async () => {
+    await createPendingTransactionFilter(publicClient)
+  })
+})

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

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

package/src/actions/public/createPendingTransactionFilter.ts

@@ -0,0 +1,14 @@
+import type { PublicClient } from '../../clients'
+
+import type { Filter } from '../../types'
+
+export type CreatePendingTransactionFilterResponse = Filter<'transaction'>
+
+export async function createPendingTransactionFilter(
+  client: PublicClient,
+): Promise<CreatePendingTransactionFilterResponse> {
+  const id = await client.request({
+    method: 'eth_newPendingTransactionFilter',
+  })
+  return { id, type: 'transaction' }
+}

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

@@ -0,0 +1,56 @@
+import { expect, test } from 'vitest'
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
+import { baycContractConfig } from '../../_test/abis'
+import { parseEther } from '../../utils'
+import { mine, setBalance } from '../test'
+import { callContract } from './callContract'
+
+import { deployContract } from './deployContract'
+import { getTransactionReceipt } from './getTransactionReceipt'
+
+test('default', async () => {
+  const hash = await deployContract(walletClient, {
+    ...baycContractConfig,
+    args: ['Bored Ape Wagmi Club', 'BAYC', 69420n, 0n],
+    from: accounts[0].address,
+  })
+  expect(hash).toBeDefined()
+
+  await mine(testClient, { blocks: 1 })
+  const { contractAddress } = await getTransactionReceipt(publicClient, {
+    hash,
+  })
+
+  expect(
+    await callContract(publicClient, {
+      abi: baycContractConfig.abi,
+      address: contractAddress!,
+      functionName: 'symbol',
+    }),
+  ).toBe('BAYC')
+})
+
+test('no funds', async () => {
+  await setBalance(testClient, {
+    address: accounts[0].address,
+    value: parseEther('0'),
+  })
+
+  await expect(() =>
+    deployContract(walletClient, {
+      ...baycContractConfig,
+      args: ['Bored Ape Wagmi Club', 'BAYC', 69420n, 0n],
+      from: accounts[0].address,
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "Transaction creation failed.
+
+    Details: Insufficient funds for gas * price + value
+    Version: viem@1.0.2"
+  `)
+
+  await setBalance(testClient, {
+    address: accounts[0].address,
+    value: parseEther('10000'),
+  })
+})

package/src/actions/public/deployContract.ts

@@ -0,0 +1,39 @@
+import { Abi } from 'abitype'
+import { Chain } from '../../chains'
+import { WalletClient } from '../../clients'
+
+import { ExtractConstructorArgsFromAbi, Hex } from '../../types'
+import { encodeDeployData } from '../../utils'
+import {
+  sendTransaction,
+  SendTransactionArgs,
+  SendTransactionResponse,
+} from '../wallet'
+
+export type DeployContractArgs<
+  TChain extends Chain = Chain,
+  TAbi extends Abi = Abi,
+> = Omit<
+  SendTransactionArgs<TChain>,
+  'accessList' | 'to' | 'data' | 'value'
+> & {
+  abi: TAbi
+  bytecode: Hex
+} & ExtractConstructorArgsFromAbi<TAbi>
+
+export type DeployContractResponse = SendTransactionResponse
+
+export function deployContract<TChain extends Chain, TAbi extends Abi = Abi>(
+  walletClient: WalletClient,
+  { abi, args, bytecode, ...request }: DeployContractArgs<TChain, TAbi>,
+): Promise<DeployContractResponse> {
+  const calldata = encodeDeployData({
+    abi,
+    args,
+    bytecode,
+  } as unknown as DeployContractArgs<TChain, TAbi>)
+  return sendTransaction(walletClient, {
+    ...request,
+    data: calldata,
+  } as unknown as SendTransactionArgs<TChain>)
+}

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

@@ -0,0 +1,46 @@
+import { bench, describe } from 'vitest'
+
+import {
+  accounts,
+  essentialProvider,
+  ethersProvider,
+  publicClient,
+  web3Provider,
+} from '../../_test'
+import { parseEther } from '../../utils'
+
+import { estimateGas } from './estimateGas'
+
+describe('Estimate Gas', () => {
+  bench('viem: `estimateGas`', async () => {
+    await estimateGas(publicClient, {
+      from: accounts[0].address,
+      to: accounts[1].address,
+      value: parseEther('1'),
+    })
+  })
+
+  bench('ethers: `estimateGas`', async () => {
+    await ethersProvider.estimateGas({
+      from: accounts[0].address,
+      to: accounts[1].address,
+      value: parseEther('1'),
+    })
+  })
+
+  bench('web3.js: `estimateGas`', async () => {
+    await web3Provider.eth.estimateGas({
+      from: accounts[0].address,
+      to: accounts[1].address,
+      value: '1000000000000',
+    })
+  })
+
+  bench('essential-eth: `call`', async () => {
+    await essentialProvider.estimateGas({
+      from: accounts[0].address,
+      to: accounts[1].address,
+      value: '1000000000000',
+    })
+  })
+})

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

@@ -0,0 +1,92 @@
+import { expect, test } from 'vitest'
+
+import {
+  accounts,
+  initialBlockNumber,
+  publicClient,
+  testClient,
+} from '../../_test'
+import { parseEther, parseGwei } from '../../utils'
+import { reset } from '../test'
+import { estimateGas } from './estimateGas'
+
+const wethContractAddress = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
+
+test('estimates gas', async () => {
+  expect(
+    await estimateGas(publicClient, {
+      from: accounts[0].address,
+      to: accounts[1].address,
+      value: parseEther('1'),
+    }),
+  ).toMatchInlineSnapshot('21000n')
+})
+
+test('args: blockNumber', async () => {
+  await reset(testClient, {
+    blockNumber: BigInt(parseInt(process.env.VITE_ANVIL_BLOCK_NUMBER!)),
+    jsonRpcUrl: process.env.VITE_ANVIL_FORK_URL,
+  })
+  expect(
+    await estimateGas(publicClient, {
+      blockNumber: initialBlockNumber,
+      from: accounts[0].address,
+      to: accounts[1].address,
+      value: parseEther('1'),
+    }),
+  ).toMatchInlineSnapshot('21000n')
+})
+
+test('args: data', async () => {
+  expect(
+    await estimateGas(publicClient, {
+      data: '0x00000000000000000000000000000000000000000000000004fefa17b7240000',
+      from: accounts[0].address,
+      to: wethContractAddress,
+    }),
+  ).toMatchInlineSnapshot('26145n')
+})
+
+test('args: gasPrice', async () => {
+  expect(
+    await estimateGas(publicClient, {
+      from: accounts[0].address,
+      to: accounts[1].address,
+      gasPrice: parseGwei('33'),
+      value: parseEther('1'),
+    }),
+  ).toMatchInlineSnapshot('21000n')
+})
+
+test('args: maxFeePerGas', async () => {
+  expect(
+    await estimateGas(publicClient, {
+      from: accounts[0].address,
+      to: accounts[1].address,
+      maxFeePerGas: parseGwei('33'),
+      value: parseEther('1'),
+    }),
+  ).toMatchInlineSnapshot('21000n')
+})
+
+test('args: maxPriorityFeePerGas', async () => {
+  expect(
+    await estimateGas(publicClient, {
+      from: accounts[0].address,
+      to: accounts[1].address,
+      maxPriorityFeePerGas: parseGwei('2'),
+      value: parseEther('1'),
+    }),
+  ).toMatchInlineSnapshot('21000n')
+})
+
+test('args: gas', async () => {
+  expect(
+    await estimateGas(publicClient, {
+      from: accounts[0].address,
+      to: accounts[1].address,
+      gas: parseGwei('2'),
+      value: parseEther('1'),
+    }),
+  ).toMatchInlineSnapshot('21000n')
+})

package/src/actions/public/estimateGas.ts

@@ -0,0 +1,61 @@
+import type { PublicClient } from '../../clients'
+import type {
+  BlockTag,
+  EstimateGasParameters,
+  RpcEstimateGasParameters,
+} from '../../types'
+import { numberToHex } from '../../utils'
+
+export type EstimateGasArgs = EstimateGasParameters &
+  (
+    | {
+        /** The balance of the account at a block number. */
+        blockNumber?: bigint
+        blockTag?: never
+      }
+    | {
+        blockNumber?: never
+        /** The balance of the account at a block tag. */
+        blockTag?: BlockTag
+      }
+  )
+
+export type EstimateGasResponse = bigint
+
+/**
+ * @description Estimates the gas necessary to complete a transaction without submitting it to the network.
+ */
+export async function estimateGas(
+  client: PublicClient,
+  {
+    blockNumber,
+    blockTag = 'latest',
+    data,
+    from,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    to,
+    value,
+  }: EstimateGasArgs,
+): Promise<EstimateGasResponse> {
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
+  const parameters = {
+    data,
+    from,
+    gas: gas ? numberToHex(gas) : undefined,
+    gasPrice: gasPrice ? numberToHex(gasPrice) : undefined,
+    maxFeePerGas: maxFeePerGas ? numberToHex(maxFeePerGas) : undefined,
+    maxPriorityFeePerGas: maxPriorityFeePerGas
+      ? numberToHex(maxPriorityFeePerGas)
+      : undefined,
+    to,
+    value: value ? numberToHex(value) : undefined,
+  } as RpcEstimateGasParameters
+  const balance = await client.request({
+    method: 'eth_estimateGas',
+    params: [parameters, blockNumberHex || blockTag],
+  })
+  return BigInt(balance)
+}

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

@@ -0,0 +1,83 @@
+import { expect, test } from 'vitest'
+
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
+import { parseEther } from '../../utils'
+import { getBlockNumber, sendTransaction } from '..'
+import { mine, setBalance } from '../test'
+
+import { getBalance } from './getBalance'
+
+const sourceAccount = accounts[0]
+const targetAccount = accounts[1]
+
+async function setup() {
+  await setBalance(testClient, {
+    address: targetAccount.address,
+    value: targetAccount.balance,
+  })
+
+  await sendTransaction(walletClient, {
+    from: sourceAccount.address,
+    to: targetAccount.address,
+    value: parseEther('1'),
+  })
+  await mine(testClient, { blocks: 1 })
+  await sendTransaction(walletClient, {
+    from: sourceAccount.address,
+    to: targetAccount.address,
+    value: parseEther('2'),
+  })
+  await mine(testClient, { blocks: 1 })
+  await sendTransaction(walletClient, {
+    from: sourceAccount.address,
+    to: targetAccount.address,
+    value: parseEther('3'),
+  })
+  await mine(testClient, { blocks: 1 })
+}
+
+test('gets balance', async () => {
+  await setup()
+  expect(
+    await getBalance(publicClient, { address: targetAccount.address }),
+  ).toMatchInlineSnapshot('10006000000000000000000n')
+})
+
+test('gets balance at latest', async () => {
+  await setup()
+  expect(
+    await getBalance(publicClient, {
+      address: targetAccount.address,
+      blockTag: 'latest',
+    }),
+  ).toMatchInlineSnapshot('10006000000000000000000n')
+})
+
+test('gets balance at block number', async () => {
+  await setup()
+  const currentBlockNumber = await getBlockNumber(publicClient)
+  expect(
+    await getBalance(publicClient, {
+      address: targetAccount.address,
+      blockNumber: currentBlockNumber,
+    }),
+  ).toMatchInlineSnapshot('10006000000000000000000n')
+  expect(
+    await getBalance(publicClient, {
+      address: targetAccount.address,
+      blockNumber: currentBlockNumber - 1n,
+    }),
+  ).toMatchInlineSnapshot('10003000000000000000000n')
+  expect(
+    await getBalance(publicClient, {
+      address: targetAccount.address,
+      blockNumber: currentBlockNumber - 2n,
+    }),
+  ).toMatchInlineSnapshot('10001000000000000000000n')
+  expect(
+    await getBalance(publicClient, {
+      address: targetAccount.address,
+      blockNumber: currentBlockNumber - 3n,
+    }),
+  ).toMatchInlineSnapshot('10000000000000000000000n')
+})

package/src/actions/public/getBalance.ts

@@ -0,0 +1,37 @@
+import type { PublicClient } from '../../clients'
+import type { Address, BlockTag } from '../../types'
+import { numberToHex } from '../../utils'
+
+export type GetBalanceArgs = {
+  /** The address of the account. */
+  address: Address
+} & (
+  | {
+      /** The balance of the account at a block number. */
+      blockNumber?: bigint
+      blockTag?: never
+    }
+  | {
+      blockNumber?: never
+      /** The balance of the account at a block tag. */
+      blockTag?: BlockTag
+    }
+)
+
+export type GetBalanceResponse = bigint
+
+/**
+ * @description Returns the balance of an address in wei.
+ */
+export async function getBalance(
+  client: PublicClient,
+  { address, blockNumber, blockTag = 'latest' }: GetBalanceArgs,
+): Promise<GetBalanceResponse> {
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
+
+  const balance = await client.request({
+    method: 'eth_getBalance',
+    params: [address, blockNumberHex || blockTag],
+  })
+  return BigInt(balance)
+}

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

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