viem 0.0.1-sushi.26 → 0.1.0

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,277 +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('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',
-    ])
-
-    expect(
-      buildFilterTopics({
-        event:
-          'Transfer(string indexed baz, uint indexed foo, bool indexed bar)',
-        args: {
-          baz: 'watermelon sugar high',
-          foo: 12,
-          bar: true,
-        },
-      }),
-    ).toEqual([
-      '0xd72ffe8f642f870a4e0b389d4e008752294ecfa2a379b4a9790c067aef635088',
-      '0xdb31e24017b555ff340729aa37fadedf910b5395e13a218e76e155c39527bf02',
-      '0x000000000000000000000000000000000000000000000000000000000000000c',
-      '0x0000000000000000000000000000000000000000000000000000000000000001',
-    ])
-
-    expect(
-      buildFilterTopics({
-        event:
-          'Transfer(bytes indexed baz, uint indexed foo, bool indexed bar)',
-        args: {
-          baz: '0x69420',
-          foo: 12,
-          bar: true,
-        },
-      }),
-    ).toEqual([
-      '0xd0ac01db7189fe6027705e6dda462153bf4aec72630a11dcec054ac78bac314d',
-      '0xd36b1a27d526376a81ba9b34292f4103e8340cc80a493e43aa00a14ebd0df4c5',
-      '0x000000000000000000000000000000000000000000000000000000000000000c',
-      '0x0000000000000000000000000000000000000000000000000000000000000001',
-    ])
-  })
-
-  test('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',
-      ],
-    ])
-  })
-})

package/src/actions/public/createEventFilter.ts

@@ -1,93 +0,0 @@
-import { Abi } from 'abitype'
-import type { PublicClient } from '../../clients'
-
-import type {
-  Address,
-  BlockNumber,
-  BlockTag,
-  EventDefinition,
-  ExtractArgsFromEventDefinition,
-  Filter,
-  LogTopic,
-} from '../../types'
-import {
-  EncodeEventTopicsArgs,
-  encodeEventTopics,
-  extractFunctionName,
-  extractFunctionParams,
-  numberToHex,
-  getAbiItem,
-} 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,
-}: {
-  event: TEventDefinition
-  args?: EventFilterArgs<TEventDefinition>
-}) {
-  const eventName = extractFunctionName(event)!
-  const abi = unstable_parseAbi(event)
-  return encodeEventTopics({ abi, eventName, args } as EncodeEventTopicsArgs)
-}
-
-// REFACTOR: Implement a full version of `parseAbi` that supports more types (functions, errors) & more complex arg types (structs & arrays).
-function unstable_parseAbi(definition: EventDefinition): Abi {
-  const name = extractFunctionName(definition)!
-  const params = extractFunctionParams(definition)
-  return [
-    {
-      type: 'event',
-      name,
-      inputs: params || [],
-    },
-  ]
-}

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)
-  })
-})