viem 0.0.1-alpha.2 → 0.0.1-alpha.20

package/src/actions/public/call.ts

@@ -0,0 +1,97 @@
+import type { PublicClient } from '../../clients'
+import { InvalidGasArgumentsError } from '../../errors'
+import type {
+  Address,
+  BlockTag,
+  Chain,
+  Formatter,
+  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/createContractEventFilter.test.ts

@@ -0,0 +1,119 @@
+import { expect, test } from 'vitest'
+
+import {
+  accounts,
+  initialBlockNumber,
+  publicClient,
+  usdcContractConfig,
+} from '../../_test'
+
+import { createContractEventFilter } from './createContractEventFilter'
+
+test('default', async () => {
+  expect(
+    (
+      await createContractEventFilter(publicClient, {
+        abi: usdcContractConfig.abi,
+        eventName: 'Transfer',
+      })
+    ).id,
+  ).toBeDefined()
+})
+
+test('args: address', async () => {
+  expect(
+    (
+      await createContractEventFilter(publicClient, {
+        address: usdcContractConfig.address,
+        abi: usdcContractConfig.abi,
+        eventName: 'Transfer',
+      })
+    ).id,
+  ).toBeDefined()
+})
+
+test('args: args', async () => {
+  expect(
+    (
+      await createContractEventFilter(publicClient, {
+        address: usdcContractConfig.address,
+        abi: usdcContractConfig.abi,
+        eventName: 'Transfer',
+        args: {
+          from: accounts[0].address,
+          to: accounts[0].address,
+        },
+      })
+    ).id,
+  ).toBeDefined()
+  expect(
+    (
+      await createContractEventFilter(publicClient, {
+        address: usdcContractConfig.address,
+        abi: usdcContractConfig.abi,
+        eventName: 'Transfer',
+        args: {
+          from: accounts[0].address,
+        },
+      })
+    ).id,
+  ).toBeDefined()
+  expect(
+    (
+      await createContractEventFilter(publicClient, {
+        address: usdcContractConfig.address,
+        abi: usdcContractConfig.abi,
+        eventName: 'Transfer',
+        args: {
+          to: [accounts[0].address, accounts[1].address],
+        },
+      })
+    ).id,
+  ).toBeDefined()
+})
+
+test('args: fromBlock', async () => {
+  expect(
+    (
+      await createContractEventFilter(publicClient, {
+        address: usdcContractConfig.address,
+        abi: usdcContractConfig.abi,
+        eventName: 'Transfer',
+        fromBlock: 'latest',
+      })
+    ).id,
+  ).toBeDefined()
+  expect(
+    (
+      await createContractEventFilter(publicClient, {
+        address: usdcContractConfig.address,
+        abi: usdcContractConfig.abi,
+        eventName: 'Transfer',
+        fromBlock: initialBlockNumber,
+      })
+    ).id,
+  ).toBeDefined()
+})
+
+test('args: toBlock', async () => {
+  expect(
+    (
+      await createContractEventFilter(publicClient, {
+        address: usdcContractConfig.address,
+        abi: usdcContractConfig.abi,
+        eventName: 'Transfer',
+        toBlock: 'latest',
+      })
+    ).id,
+  ).toBeDefined()
+  expect(
+    (
+      await createContractEventFilter(publicClient, {
+        address: usdcContractConfig.address,
+        abi: usdcContractConfig.abi,
+        eventName: 'Transfer',
+        toBlock: initialBlockNumber,
+      })
+    ).id,
+  ).toBeDefined()
+})

package/src/actions/public/createContractEventFilter.ts

@@ -0,0 +1,69 @@
+import { Abi } from 'abitype'
+import type { PublicClient } from '../../clients'
+
+import type {
+  Address,
+  BlockNumber,
+  BlockTag,
+  EventDefinition,
+  ExtractArgsFromEventDefinition,
+  ExtractEventArgsFromAbi,
+  ExtractEventNameFromAbi,
+  Filter,
+} from '../../types'
+import {
+  encodeEventTopics,
+  EncodeEventTopicsArgs,
+  numberToHex,
+} from '../../utils'
+
+export type EventFilterArgs<TEventDefinition extends EventDefinition> =
+  ExtractArgsFromEventDefinition<TEventDefinition>
+
+export type CreateContractEventFilterArgs<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TEventName extends string = any,
+> = {
+  address?: Address | Address[]
+  abi: TAbi
+  eventName: ExtractEventNameFromAbi<TAbi, TEventName>
+  fromBlock?: BlockNumber | BlockTag
+  toBlock?: BlockNumber | BlockTag
+} & ExtractEventArgsFromAbi<TAbi, TEventName>
+export type CreateContractEventFilterResponse = Filter<'event'>
+
+export async function createContractEventFilter<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TEventName extends string = any,
+>(
+  client: PublicClient,
+  {
+    address,
+    abi,
+    args,
+    eventName,
+    fromBlock,
+    toBlock,
+  }: CreateContractEventFilterArgs<TAbi, TEventName>,
+): Promise<CreateContractEventFilterResponse> {
+  const topics = eventName
+    ? encodeEventTopics({
+        abi,
+        args,
+        eventName,
+      } as unknown as EncodeEventTopicsArgs)
+    : undefined
+  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,
+      },
+    ],
+  })
+  return { id, type: 'event' }
+}

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,76 @@
+import type { PublicClient } from '../../clients'
+
+import type {
+  Address,
+  BlockNumber,
+  BlockTag,
+  EventDefinition,
+  ExtractArgsFromEventDefinition,
+  Filter,
+  LogTopic,
+} from '../../types'
+import { getEventSignature, numberToHex } from '../../utils'
+
+export type EventFilterArgs<TEventDefinition extends EventDefinition> =
+  ExtractArgsFromEventDefinition<TEventDefinition>
+
+export type CreateEventFilterArgs<TEventDefinition extends EventDefinition> = {
+  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 EventDefinition,
+>(
+  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 EventDefinition,>({
+  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' }
+}