viem 0.0.1-alpha.24 → 0.0.1-alpha.26

package/src/actions/public/call.ts

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

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

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

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

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

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

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

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

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

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

@@ -1,14 +0,0 @@
-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' }
-}