viem 0.0.1-cjs.10 → 0.0.1-sushi.26

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

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

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

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

@@ -0,0 +1,42 @@
+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'])
+}