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

package/src/actions/public/call.ts

@@ -0,0 +1,96 @@
+import type { Chain, Formatter } from '../../chains'
+import type { PublicClient } from '../../clients'
+import { InvalidGasArgumentsError } from '../../errors'
+import type {
+  Address,
+  BlockTag,
+  Hex,
+  MergeIntersectionProperties,
+  TransactionRequest,
+} from '../../types'
+import { extract, Formatted, TransactionRequestFormatter } from '../../utils'
+import { format, formatTransactionRequest, numberToHex } from '../../utils'
+
+export type FormattedCall<
+  TFormatter extends Formatter | undefined = Formatter,
+> = MergeIntersectionProperties<
+  Formatted<TFormatter, TransactionRequest, true>,
+  TransactionRequest
+>
+
+export type CallArgs<TChain extends Chain = Chain> = FormattedCall<
+  TransactionRequestFormatter<TChain>
+> & {
+  chain?: TChain
+  from?: 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 CallResponse = { data: Hex | undefined }
+
+export async function call<TChain extends Chain>(
+  client: PublicClient,
+  {
+    blockNumber,
+    blockTag = 'latest',
+    chain,
+    from,
+    accessList,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value,
+    ...rest
+  }: CallArgs<TChain>,
+): Promise<CallResponse> {
+  if (
+    maxFeePerGas !== undefined &&
+    maxPriorityFeePerGas !== undefined &&
+    maxFeePerGas < maxPriorityFeePerGas
+  )
+    throw new InvalidGasArgumentsError()
+
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
+
+  const formatter = chain?.formatters?.transactionRequest
+  const request_ = format(
+    {
+      from,
+      accessList,
+      data,
+      gas,
+      gasPrice,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      nonce,
+      to,
+      value,
+      // Pick out extra data that might exist on the chain's transaction request type.
+      ...extract(rest, { formatter }),
+    } as TransactionRequest,
+    {
+      formatter: formatter || formatTransactionRequest,
+    },
+  )
+
+  const response = await client.request({
+    method: 'eth_call',
+    params: [request_, blockNumberHex || blockTag],
+  })
+  if (response === '0x') return { data: undefined }
+  return { data: response }
+}

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

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

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

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

package/src/actions/public/createBlockFilter.ts

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

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

@@ -0,0 +1,245 @@
+import { describe, expect, test } from 'vitest'
+
+import { accounts, initialBlockNumber, publicClient } from '../../_test'
+
+import { numberToHex, pad } from '../../utils'
+import { buildFilterTopics, createEventFilter } from './createEventFilter'
+
+describe('default', () => {
+  test('no args', async () => {
+    const filter = await createEventFilter(publicClient)
+    expect(filter.id).toBeDefined()
+    expect(filter.type).toBe('event')
+  })
+
+  test('args: address', async () => {
+    await createEventFilter(publicClient, {
+      address: accounts[0].address,
+    })
+  })
+
+  test('args: event', async () => {
+    await createEventFilter(publicClient, {
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
+    })
+  })
+
+  test('args: args (named)', async () => {
+    await createEventFilter(publicClient, {
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
+      args: {
+        from: accounts[0].address,
+        to: accounts[0].address,
+      },
+    })
+    await createEventFilter(publicClient, {
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
+      args: {
+        from: accounts[0].address,
+      },
+    })
+    await createEventFilter(publicClient, {
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
+      args: {
+        to: [accounts[0].address, accounts[1].address],
+      },
+    })
+  })
+
+  test('args: args (unnamed)', async () => {
+    await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      args: [accounts[0].address, accounts[1].address],
+    })
+    await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      args: [[accounts[0].address, accounts[1].address]],
+    })
+    await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      args: [null, accounts[0].address],
+    })
+    await createEventFilter(publicClient, {
+      event: 'Transfer(address,address,uint256)',
+      args: [],
+    })
+  })
+
+  test('args: fromBlock', async () => {
+    await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      fromBlock: initialBlockNumber,
+    })
+    await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      fromBlock: 'latest',
+    })
+  })
+
+  test('args: toBlock', async () => {
+    await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      toBlock: initialBlockNumber,
+    })
+    await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      toBlock: 'latest',
+    })
+  })
+})
+
+describe('buildFilterTopics', () => {
+  test('no args', () => {
+    expect(
+      buildFilterTopics({
+        event: 'Transfer(address indexed from, address indexed to)',
+      }),
+    ).toEqual([
+      '0x4853ae1b4d437c4255ac16cd3ceda3465975023f27cb141584cd9d44440fed82',
+    ])
+
+    expect(
+      buildFilterTopics({
+        event: 'NoArgs()',
+      }),
+    ).toEqual([
+      '0xd144d9e3e4304378a275ce8c55f48e681b2038a3792520b00766e2cecef576f5',
+    ])
+  })
+
+  test.skip('named args', () => {
+    expect(
+      buildFilterTopics({
+        event: 'Transfer(address indexed from, address indexed to)',
+        args: {
+          from: accounts[0].address,
+          to: accounts[1].address,
+        },
+      }),
+    ).toEqual([
+      '0x4853ae1b4d437c4255ac16cd3ceda3465975023f27cb141584cd9d44440fed82',
+      '0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+      '0x00000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c8',
+    ])
+
+    expect(
+      buildFilterTopics({
+        event: 'Transfer(address indexed from, address indexed to)',
+        args: {
+          from: accounts[0].address,
+        },
+      }),
+    ).toEqual([
+      '0x4853ae1b4d437c4255ac16cd3ceda3465975023f27cb141584cd9d44440fed82',
+      '0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+      null,
+    ])
+
+    expect(
+      buildFilterTopics({
+        event:
+          'Transfer(address indexed from, uint indexed foo, bool indexed bar)',
+        args: {
+          from: accounts[0].address,
+          foo: 12,
+          bar: true,
+        },
+      }),
+    ).toEqual([
+      '0x053222ddc7d30875376c5627c53670e97f3b5741a004c9429ae150ba4def00da',
+      '0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+      '0x000000000000000000000000000000000000000000000000000000000000000c',
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+    ])
+  })
+
+  test.skip('unnamed args', () => {
+    expect(
+      buildFilterTopics({
+        event: 'Transfer(address indexed, address indexed, uint indexed)',
+        args: [accounts[0].address, accounts[1].address, 69420n],
+      }),
+    ).toEqual([
+      '0x930a61a57a70a73c2a503615b87e2e54fe5b9cdeacda518270b852296ab1a377',
+      '0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+      '0x00000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c8',
+      pad(numberToHex(69420n)),
+    ])
+
+    expect(
+      buildFilterTopics({
+        event: 'Transfer(address indexed, address indexed)',
+        args: [null, accounts[0].address],
+      }),
+    ).toEqual([
+      '0x4853ae1b4d437c4255ac16cd3ceda3465975023f27cb141584cd9d44440fed82',
+      null,
+      '0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+    ])
+
+    expect(
+      buildFilterTopics({
+        event: 'Transfer(address indexed, address indexed)',
+        args: [null, [accounts[0].address, accounts[1].address]],
+      }),
+    ).toEqual([
+      '0x4853ae1b4d437c4255ac16cd3ceda3465975023f27cb141584cd9d44440fed82',
+      null,
+      [
+        '0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+        '0x00000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c8',
+      ],
+    ])
+
+    expect(
+      buildFilterTopics({
+        event: 'Transfer(address indexed, address indexed)',
+        args: [
+          [accounts[2].address, accounts[3].address],
+          [accounts[0].address, accounts[1].address],
+        ],
+      }),
+    ).toEqual([
+      '0x4853ae1b4d437c4255ac16cd3ceda3465975023f27cb141584cd9d44440fed82',
+      [
+        '0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc',
+        '0x00000000000000000000000090f79bf6eb2c4f870365e785982e1f101e93b906',
+      ],
+      [
+        '0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+        '0x00000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c8',
+      ],
+    ])
+
+    expect(
+      buildFilterTopics({
+        event: 'Transfer(address indexed, uint indexed, bool indexed)',
+        args: [
+          [accounts[2].address, accounts[3].address],
+          [23, 32],
+          [true, false],
+        ],
+      }),
+    ).toEqual([
+      '0x053222ddc7d30875376c5627c53670e97f3b5741a004c9429ae150ba4def00da',
+      [
+        '0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc',
+        '0x00000000000000000000000090f79bf6eb2c4f870365e785982e1f101e93b906',
+      ],
+      [
+        '0x0000000000000000000000000000000000000000000000000000000000000017',
+        '0x0000000000000000000000000000000000000000000000000000000000000020',
+      ],
+      [
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+      ],
+    ])
+  })
+
+  // TODO: more arg types
+})

package/src/actions/public/createEventFilter.ts

@@ -0,0 +1,79 @@
+import type { PublicClient } from '../../clients'
+
+import type {
+  Address,
+  BlockNumber,
+  BlockTag,
+  ExtractArgsFromEventDefinition,
+  Filter,
+  LogTopic,
+} 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'>
+
+export async function createEventFilter<
+  TEventDefinition extends `${string}(${string})`,
+>(
+  client: PublicClient,
+  {
+    address,
+    event,
+    args,
+    fromBlock,
+    toBlock,
+  }: CreateEventFilterArgs<TEventDefinition> = {},
+): Promise<CreateEventFilterResponse> {
+  let topics: LogTopic[] = []
+  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 { deployContract } from './deployContract'
+import { getTransactionReceipt } from './getTransactionReceipt'
+import { simulateContract } from './simulateContract'
+
+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 simulateContract(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',
+    })
+  })
+})