viem 0.0.1-sushi.26 → 0.1.0

package/src/utils/abi/encodeEventTopics.test.ts

@@ -1,345 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { encodeEventTopics } from './encodeEventTopics'
-
-test('Transfer()', () => {
-  expect(
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: [],
-          name: 'Transfer',
-          type: 'event',
-        },
-      ],
-      eventName: 'Transfer',
-    }),
-  ).toEqual([
-    '0x406dade31f7ae4b5dbc276258c28dde5ae6d5c2773c5745802c493a2360e55e0',
-  ])
-  expect(
-    encodeEventTopics({
-      abi: [
-        {
-          name: 'Transfer',
-          type: 'event',
-        },
-      ],
-      eventName: 'Transfer',
-    }),
-  ).toEqual([
-    '0x406dade31f7ae4b5dbc276258c28dde5ae6d5c2773c5745802c493a2360e55e0',
-  ])
-})
-
-test('no args: Transfer(address,address,uint256)', () => {
-  expect(
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: [
-            {
-              indexed: true,
-              name: 'from',
-              type: 'address',
-            },
-            {
-              indexed: true,
-              name: 'to',
-              type: 'address',
-            },
-            {
-              indexed: false,
-              name: 'tokenId',
-              type: 'uint256',
-            },
-          ],
-          name: 'Transfer',
-          type: 'event',
-        },
-      ],
-      eventName: 'Transfer',
-    }),
-  ).toEqual([
-    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
-  ])
-})
-
-test('named args: Transfer(address,address,uint256)', () => {
-  expect(
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: [
-            {
-              indexed: true,
-              name: 'from',
-              type: 'address',
-            },
-            {
-              indexed: true,
-              name: 'to',
-              type: 'address',
-            },
-            {
-              indexed: false,
-              name: 'tokenId',
-              type: 'uint256',
-            },
-          ],
-          name: 'Transfer',
-          type: 'event',
-        },
-      ],
-      eventName: 'Transfer',
-      args: {
-        from: null,
-        to: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-      },
-    }),
-  ).toEqual([
-    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
-    null,
-    '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
-  ])
-})
-
-test('named args: Transfer(address,address,uint256)', () => {
-  expect(
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: [
-            {
-              indexed: true,
-              name: 'from',
-              type: 'address',
-            },
-            {
-              indexed: true,
-              name: 'to',
-              type: 'address',
-            },
-            {
-              indexed: false,
-              name: 'tokenId',
-              type: 'uint256',
-            },
-          ],
-          name: 'Transfer',
-          type: 'event',
-        },
-      ],
-      eventName: 'Transfer',
-      args: {
-        from: null,
-        to: [
-          '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-          '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b',
-        ],
-      },
-    }),
-  ).toEqual([
-    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
-    null,
-    [
-      '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
-      '0x000000000000000000000000c961145a54c96e3ae9baa048c4f4d6b04c13916b',
-    ],
-  ])
-})
-
-test('unnamed args: Transfer(address,address,uint256)', () => {
-  expect(
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: [
-            {
-              indexed: true,
-              type: 'address',
-            },
-            {
-              indexed: true,
-              type: 'address',
-            },
-            {
-              indexed: false,
-              type: 'uint256',
-            },
-          ],
-          name: 'Transfer',
-          type: 'event',
-        },
-      ],
-      eventName: 'Transfer',
-      args: [null, '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC'],
-    }),
-  ).toEqual([
-    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
-    null,
-    '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
-  ])
-})
-
-test('unnamed args: Transfer(address,address,uint256)', () => {
-  expect(
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: [
-            {
-              indexed: true,
-              type: 'address',
-            },
-            {
-              indexed: true,
-              type: 'address',
-            },
-            {
-              indexed: false,
-              type: 'uint256',
-            },
-          ],
-          name: 'Transfer',
-          type: 'event',
-        },
-      ],
-      eventName: 'Transfer',
-      args: [
-        null,
-        [
-          '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-          '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b',
-        ],
-      ],
-    }),
-  ).toEqual([
-    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
-    null,
-    [
-      '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
-      '0x000000000000000000000000c961145a54c96e3ae9baa048c4f4d6b04c13916b',
-    ],
-  ])
-})
-
-test('Foo(string)', () => {
-  expect(
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: [
-            {
-              indexed: true,
-              name: 'message',
-              type: 'string',
-            },
-          ],
-          name: 'Foo',
-          type: 'event',
-        },
-      ],
-      eventName: 'Foo',
-      args: {
-        message: 'hello',
-      },
-    }),
-  ).toEqual([
-    '0x9f0b7f1630bdb7d474466e2dfef0fb9dff65f7a50eec83935b68f77d0808f08a',
-    '0x1c8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36deac8',
-  ])
-})
-
-test('Foo((uint,string))', () => {
-  expect(() =>
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: [
-            {
-              components: [
-                {
-                  internalType: 'uint256',
-                  name: 'a',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'string',
-                  name: 'b',
-                  type: 'string',
-                },
-              ],
-              indexed: true,
-              internalType: 'struct Example.Foo',
-              name: 'x',
-              type: 'tuple',
-            },
-          ],
-          name: 'Bar',
-          type: 'event',
-        },
-      ],
-      eventName: 'Bar',
-      args: {
-        x: {
-          a: 1n,
-          b: 'hello',
-        },
-      },
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(`
-    "Filter type \\"tuple\\" is not supported.
-
-    Version: viem@1.0.2"
-  `)
-})
-
-test("errors: event doesn't exist", () => {
-  expect(() =>
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: [
-            {
-              indexed: true,
-              name: 'message',
-              type: 'string',
-            },
-          ],
-          name: 'Foo',
-          type: 'event',
-        },
-      ],
-      // @ts-expect-error
-      eventName: 'Bar',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(`
-    "Event \\"Bar\\" not found on ABI.
-    Make sure you are using the correct ABI and that the event exists on it.
-
-    Docs: https://viem.sh/docs/contract/encodeEventTopics
-    Version: viem@1.0.2"
-  `)
-})
-
-test("errors: event doesn't exist", () => {
-  expect(
-    encodeEventTopics({
-      abi: [
-        {
-          inputs: undefined,
-          name: 'Foo',
-          type: 'event',
-        },
-      ],
-      eventName: 'Foo',
-      // @ts-expect-error
-      args: {},
-    }),
-  ).toMatchInlineSnapshot(`
-    [
-      "0xbfb4ebcfff8f360b39de1de85df1edc256d63337b743120bf6e2e2144b973d38",
-    ]
-  `)
-})

package/src/utils/abi/encodeEventTopics.ts

@@ -1,75 +0,0 @@
-import {
-  Abi,
-  AbiParameter,
-  AbiParameterToPrimitiveType,
-  ExtractAbiEventNames,
-  Narrow,
-} from 'abitype'
-
-import {
-  AbiEventNotFoundError,
-  FilterTypeNotSupportedError,
-} from '../../errors'
-import {
-  EventDefinition,
-  ExtractEventArgsFromAbi,
-  ExtractEventNameFromAbi,
-  Hex,
-} from '../../types'
-import { encodeBytes } from '../encoding'
-import { keccak256, getEventSignature } from '../hash'
-import { encodeAbi } from './encodeAbi'
-import { formatAbiItem } from './formatAbiItem'
-import { getAbiItem, GetAbiItemArgs } from './getAbiItem'
-
-export type EncodeEventTopicsArgs<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TEventName extends string = string,
-> = {
-  abi: Narrow<TAbi>
-  eventName: ExtractEventNameFromAbi<TAbi, TEventName>
-} & ExtractEventArgsFromAbi<TAbi, TEventName>
-
-export function encodeEventTopics<
-  TAbi extends Abi | readonly unknown[],
-  TEventName extends string,
->({ abi, eventName, args }: EncodeEventTopicsArgs<TAbi, TEventName>) {
-  const abiItem = getAbiItem({ abi, args, name: eventName } as GetAbiItemArgs)
-  if (!abiItem)
-    throw new AbiEventNotFoundError(eventName, {
-      docsPath: '/docs/contract/encodeEventTopics',
-    })
-  const definition = formatAbiItem(abiItem)
-  const signature = getEventSignature(definition as EventDefinition)
-
-  let topics: Hex[] = []
-  if (args && 'inputs' in abiItem) {
-    const args_ = Array.isArray(args)
-      ? args
-      : abiItem.inputs?.map((x: any) => (args as any)[x.name]) ?? []
-    topics =
-      abiItem.inputs
-        ?.filter((param) => 'indexed' in param && param.indexed)
-        .map((param, i) =>
-          Array.isArray(args_[i])
-            ? args_[i].map((_: any, j: number) =>
-                encodeArg({ param, value: args_[i][j] }),
-              )
-            : args_[i]
-            ? encodeArg({ param, value: args_[i] })
-            : null,
-        ) ?? []
-  }
-  return [signature, ...topics]
-}
-
-function encodeArg({
-  param,
-  value,
-}: { param: AbiParameter; value: AbiParameterToPrimitiveType<AbiParameter> }) {
-  if (param.type === 'string' || param.type === 'bytes')
-    return keccak256(encodeBytes(value as string))
-  if (param.type === 'tuple' || param.type.match(/^(.*)\[(\d+)?\]$/))
-    throw new FilterTypeNotSupportedError(param.type)
-  return encodeAbi({ params: [param], values: [value] })
-}

package/src/utils/abi/encodeFunctionData.test.ts

@@ -1,138 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { encodeFunctionData } from './encodeFunctionData'
-
-test('foo()', () => {
-  expect(
-    encodeFunctionData({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [],
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ],
-      functionName: 'foo',
-    }),
-  ).toEqual('0xc2985578')
-  expect(
-    encodeFunctionData({
-      abi: [
-        {
-          name: 'foo',
-          outputs: [],
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ],
-      functionName: 'foo',
-    }),
-  ).toEqual('0xc2985578')
-})
-
-test('bar(uint256)', () => {
-  expect(
-    encodeFunctionData({
-      abi: [
-        {
-          inputs: [
-            {
-              internalType: 'uint256',
-              name: 'a',
-              type: 'uint256',
-            },
-          ],
-          name: 'bar',
-          outputs: [],
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ],
-      functionName: 'bar',
-      args: [1n],
-    }),
-  ).toEqual(
-    '0x0423a1320000000000000000000000000000000000000000000000000000000000000001',
-  )
-})
-
-test('getVoter((uint256,bool,address,uint256))', () => {
-  expect(
-    encodeFunctionData({
-      abi: [
-        {
-          inputs: [
-            {
-              components: [
-                {
-                  internalType: 'uint256',
-                  name: 'weight',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'bool',
-                  name: 'voted',
-                  type: 'bool',
-                },
-                {
-                  internalType: 'address',
-                  name: 'delegate',
-                  type: 'address',
-                },
-                {
-                  internalType: 'uint256',
-                  name: 'vote',
-                  type: 'uint256',
-                },
-              ],
-              internalType: 'struct Ballot.Voter',
-              name: 'voter',
-              type: 'tuple',
-            },
-          ],
-          name: 'getVoter',
-          outputs: [],
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ],
-      functionName: 'getVoter',
-      args: [
-        {
-          delegate: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-          vote: 41n,
-          voted: true,
-          weight: 69420n,
-        },
-      ],
-    }),
-  ).toEqual(
-    '0xf37414670000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
-  )
-})
-
-test("errors: function doesn't exist", () => {
-  expect(() =>
-    encodeFunctionData({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [],
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ],
-      // @ts-expect-error
-      functionName: 'bar',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(`
-    "Function \\"bar\\" not found on ABI.
-    Make sure you are using the correct ABI and that the function exists on it.
-
-    Docs: https://viem.sh/docs/contract/encodeFunctionData
-    Version: viem@1.0.2"
-  `)
-})

package/src/utils/abi/encodeFunctionData.ts

@@ -1,42 +0,0 @@
-import { Abi, Narrow } from 'abitype'
-
-import { AbiFunctionNotFoundError } from '../../errors'
-import { ExtractArgsFromAbi, ExtractFunctionNameFromAbi } from '../../types'
-import { concatHex } from '../data'
-import { getFunctionSignature } from '../hash'
-import { encodeAbi } from './encodeAbi'
-import { formatAbiItem } from './formatAbiItem'
-import { getAbiItem, GetAbiItemArgs } from './getAbiItem'
-
-export type EncodeFunctionDataArgs<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = {
-  abi: Narrow<TAbi>
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
-} & ExtractArgsFromAbi<TAbi, TFunctionName>
-
-export function encodeFunctionData<
-  TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
->({ abi, args, functionName }: EncodeFunctionDataArgs<TAbi, TFunctionName>) {
-  const description = getAbiItem({
-    abi,
-    args,
-    name: functionName,
-  } as GetAbiItemArgs)
-  if (!description)
-    throw new AbiFunctionNotFoundError(functionName, {
-      docsPath: '/docs/contract/encodeFunctionData',
-    })
-  const definition = formatAbiItem(description)
-  const signature = getFunctionSignature(definition)
-  const data =
-    'inputs' in description && description.inputs
-      ? encodeAbi({
-          params: description.inputs,
-          values: (args ?? []) as any,
-        })
-      : undefined
-  return concatHex([signature, data ?? '0x'])
-}