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

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

@@ -0,0 +1,547 @@
+import { AbiParameter } from 'abitype'
+import { describe, expect, test } from 'vitest'
+import { wagmiContractConfig } from '../../_test'
+import { encodeBytes } from '../encoding'
+import { getAbiItem, isArgOfType } from './getAbiItem'
+
+test('default', () => {
+  expect(
+    getAbiItem({
+      abi: wagmiContractConfig.abi,
+      name: 'balanceOf',
+      args: ['0x0000000000000000000000000000000000000000'],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "inputs": [
+        {
+          "name": "owner",
+          "type": "address",
+        },
+      ],
+      "name": "balanceOf",
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256",
+        },
+      ],
+      "stateMutability": "view",
+      "type": "function",
+    }
+  `)
+})
+
+test('no matching name', () => {
+  expect(
+    getAbiItem({
+      abi: [],
+      // @ts-expect-error
+      name: 'balanceOf',
+      args: ['0x0000000000000000000000000000000000000000'],
+    }),
+  ).toMatchInlineSnapshot('undefined')
+})
+
+test('overloads: no inputs', () => {
+  expect(
+    getAbiItem({
+      abi: [
+        {
+          name: 'balanceOf',
+          outputs: [{ name: 'x', type: 'uint256' }],
+          stateMutability: 'view',
+          type: 'function',
+        },
+        {
+          inputs: [{ name: 'x', type: 'uint256' }],
+          name: 'balanceOf',
+          outputs: [{ name: '', type: 'uint256' }],
+          stateMutability: 'view',
+          type: 'function',
+        },
+      ],
+      name: 'balanceOf',
+      args: ['0x0000000000000000000000000000000000000000'],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "name": "balanceOf",
+      "outputs": [
+        {
+          "name": "x",
+          "type": "uint256",
+        },
+      ],
+      "stateMutability": "view",
+      "type": "function",
+    }
+  `)
+})
+
+test('overloads: undefined inputs', () => {
+  expect(
+    getAbiItem({
+      abi: [
+        {
+          inputs: undefined,
+          name: 'balanceOf',
+          outputs: [{ name: '', type: 'uint256' }],
+          stateMutability: 'view',
+          type: 'function',
+        },
+        {
+          inputs: [],
+          name: 'balanceOf',
+          outputs: [{ name: '', type: 'uint256' }],
+          stateMutability: 'view',
+          type: 'function',
+        },
+      ],
+      name: 'balanceOf',
+      args: ['0x0000000000000000000000000000000000000000'],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "inputs": undefined,
+      "name": "balanceOf",
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256",
+        },
+      ],
+      "stateMutability": "view",
+      "type": "function",
+    }
+  `)
+})
+
+test('overloads: no args', () => {
+  expect(
+    getAbiItem({
+      abi: [
+        {
+          inputs: [{ name: '', type: 'uint256' }],
+          name: 'balanceOf',
+          outputs: [{ name: '', type: 'uint256' }],
+          stateMutability: 'view',
+          type: 'function',
+        },
+        {
+          inputs: [],
+          name: 'balanceOf',
+          outputs: [{ name: '', type: 'uint256' }],
+          stateMutability: 'view',
+          type: 'function',
+        },
+      ],
+      name: 'balanceOf',
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "inputs": [],
+      "name": "balanceOf",
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256",
+        },
+      ],
+      "stateMutability": "view",
+      "type": "function",
+    }
+  `)
+})
+
+test('overload: different lengths', () => {
+  expect(
+    getAbiItem({
+      abi: wagmiContractConfig.abi,
+      name: 'safeTransferFrom',
+      args: [
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        420n,
+      ],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "inputs": [
+        {
+          "name": "from",
+          "type": "address",
+        },
+        {
+          "name": "to",
+          "type": "address",
+        },
+        {
+          "name": "tokenId",
+          "type": "uint256",
+        },
+      ],
+      "name": "safeTransferFrom",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function",
+    }
+  `)
+
+  expect(
+    getAbiItem({
+      abi: wagmiContractConfig.abi,
+      name: 'safeTransferFrom',
+      args: [
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        420n,
+        '0x0000000000000000000000000000000000000000',
+      ],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "inputs": [
+        {
+          "name": "from",
+          "type": "address",
+        },
+        {
+          "name": "to",
+          "type": "address",
+        },
+        {
+          "name": "tokenId",
+          "type": "uint256",
+        },
+        {
+          "name": "_data",
+          "type": "bytes",
+        },
+      ],
+      "name": "safeTransferFrom",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function",
+    }
+  `)
+})
+
+test('overload: different types', () => {
+  const abi = [
+    {
+      inputs: [],
+      name: 'mint',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    },
+    {
+      inputs: [{ name: 'tokenId', type: 'uint256' }],
+      name: 'mint',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    },
+    {
+      inputs: [{ name: 'tokenId', type: 'string' }],
+      name: 'mint',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    },
+  ]
+
+  expect(
+    getAbiItem({
+      abi,
+      name: 'mint',
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "inputs": [],
+      "name": "mint",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function",
+    }
+  `)
+
+  expect(
+    getAbiItem({
+      abi,
+      name: 'mint',
+      args: [420n],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "inputs": [
+        {
+          "name": "tokenId",
+          "type": "uint256",
+        },
+      ],
+      "name": "mint",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function",
+    }
+  `)
+
+  expect(
+    getAbiItem({
+      abi,
+      name: 'mint',
+      args: ['foo'],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "inputs": [
+        {
+          "name": "tokenId",
+          "type": "string",
+        },
+      ],
+      "name": "mint",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function",
+    }
+  `)
+})
+
+test('overloads: tuple', () => {
+  expect(
+    getAbiItem({
+      abi: [
+        {
+          inputs: [
+            { name: 'foo', type: 'uint256' },
+            {
+              name: 'bar',
+              type: 'tuple',
+              components: [
+                { name: 'a', type: 'string' },
+                {
+                  name: 'b',
+                  type: 'tuple',
+                  components: [
+                    { name: 'merp', type: 'string' },
+                    { name: 'meep', type: 'string' },
+                  ],
+                },
+                { name: 'c', type: 'uint256' },
+              ],
+            },
+          ],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'nonpayable',
+          type: 'function',
+        },
+        {
+          inputs: [
+            { name: 'foo', type: 'uint256' },
+            {
+              name: 'bar',
+              type: 'tuple',
+              components: [
+                { name: 'a', type: 'string' },
+                {
+                  name: 'b',
+                  type: 'tuple',
+                  components: [
+                    { name: 'merp', type: 'string' },
+                    { name: 'meep', type: 'string' },
+                  ],
+                },
+                { name: 'c', type: 'address' },
+              ],
+            },
+          ],
+          name: 'foo',
+          outputs: [],
+          stateMutability: 'nonpayable',
+          type: 'function',
+        },
+      ],
+      name: 'foo',
+      args: [
+        420n,
+        {
+          a: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+          b: { merp: 'test', meep: 'test' },
+          c: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+        },
+      ],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "inputs": [
+        {
+          "name": "foo",
+          "type": "uint256",
+        },
+        {
+          "components": [
+            {
+              "name": "a",
+              "type": "string",
+            },
+            {
+              "components": [
+                {
+                  "name": "merp",
+                  "type": "string",
+                },
+                {
+                  "name": "meep",
+                  "type": "string",
+                },
+              ],
+              "name": "b",
+              "type": "tuple",
+            },
+            {
+              "name": "c",
+              "type": "address",
+            },
+          ],
+          "name": "bar",
+          "type": "tuple",
+        },
+      ],
+      "name": "foo",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function",
+    }
+  `)
+})
+
+describe.each([
+  // array
+  { arg: ['foo'], abiParameter: { type: 'string[]' }, expected: true },
+  { arg: ['foo'], abiParameter: { type: 'string[1]' }, expected: true },
+  { arg: [['foo']], abiParameter: { type: 'string[][]' }, expected: true },
+  { arg: [['foo']], abiParameter: { type: 'string[][1]' }, expected: true },
+  {
+    arg: [1n],
+    abiParameter: { type: 'uint256[]' },
+    expected: true,
+  },
+  {
+    arg: [{ foo: 1n, bar: [{ baz: 1n }] }],
+    abiParameter: {
+      type: 'tuple[]',
+      components: [
+        { name: 'foo', type: 'uint256' },
+        {
+          name: 'bar',
+          type: 'tuple[]',
+          components: [{ name: 'baz', type: 'uint256' }],
+        },
+      ],
+    },
+    expected: true,
+  },
+  { arg: ['foo'], abiParameter: { type: 'string[test]' }, expected: false },
+  { arg: [1], abiParameter: { type: 'uint69[]' }, expected: false },
+  // address
+  {
+    arg: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+    abiParameter: { type: 'address' },
+    expected: true,
+  },
+  {
+    arg: 'A0Cf798816D4b9b9866b5330EEa46a18382f251e',
+    abiParameter: { type: 'address' },
+    expected: true,
+  },
+  { arg: 'test', abiParameter: { type: 'address' }, expected: false },
+  // bool
+  { arg: true, abiParameter: { type: 'bool' }, expected: true },
+  { arg: false, abiParameter: { type: 'bool' }, expected: true },
+  { arg: 'true', abiParameter: { type: 'bool' }, expected: false },
+  // bytes
+  { arg: 'foo', abiParameter: { type: 'bytes' }, expected: true },
+  { arg: 'foo', abiParameter: { type: 'bytes32' }, expected: true },
+  { arg: encodeBytes('foo'), abiParameter: { type: 'bytes' }, expected: true },
+  { arg: 1, abiParameter: { type: 'bytes32' }, expected: false },
+  // function
+  { arg: 'foo', abiParameter: { type: 'function' }, expected: true },
+  { arg: 1, abiParameter: { type: 'function' }, expected: false },
+  // int
+  { arg: 1, abiParameter: { type: 'int' }, expected: true },
+  { arg: 1n, abiParameter: { type: 'int' }, expected: true },
+  { arg: 1n, abiParameter: { type: 'int' }, expected: true },
+  { arg: 1, abiParameter: { type: 'uint' }, expected: true },
+  { arg: 1n, abiParameter: { type: 'uint' }, expected: true },
+  { arg: 1n, abiParameter: { type: 'uint' }, expected: true },
+  { arg: 1, abiParameter: { type: 'int256' }, expected: true },
+  { arg: 1, abiParameter: { type: 'uint256' }, expected: true },
+  { arg: 1, abiParameter: { type: 'int69' }, expected: false },
+  { arg: 1, abiParameter: { type: 'uint69' }, expected: false },
+  // string
+  { arg: 'foo', abiParameter: { type: 'string' }, expected: true },
+  { arg: 1, abiParameter: { type: 'string' }, expected: false },
+  // tuple
+  {
+    arg: { bar: 1, baz: 'test' },
+    abiParameter: {
+      name: 'foo',
+      type: 'tuple',
+      components: [
+        { name: 'bar', type: 'uint256' },
+        { name: 'baz', type: 'string' },
+      ],
+    },
+    expected: true,
+  },
+  {
+    arg: [1, 'test'],
+    abiParameter: {
+      name: 'foo',
+      type: 'tuple',
+      components: [
+        { name: 'bar', type: 'uint256' },
+        { name: 'baz', type: 'string' },
+      ],
+    },
+    expected: true,
+  },
+  {
+    arg: { bar: ['test'] },
+    abiParameter: {
+      name: 'foo',
+      type: 'tuple',
+      components: [
+        {
+          name: 'bar',
+          type: 'tuple',
+          components: [{ name: 'baz', type: 'string' }],
+        },
+      ],
+    },
+    expected: true,
+  },
+  {
+    arg: {},
+    abiParameter: {
+      name: 'foo',
+      type: 'tuple',
+      components: [
+        { name: 'bar', type: 'uint256' },
+        { name: 'baz', type: 'uint256' },
+      ],
+    },
+    expected: false,
+  },
+] as { arg: unknown; abiParameter: AbiParameter; expected: boolean }[])(
+  'isArgOfType($arg, $abiParameter)',
+  ({ arg, abiParameter, expected }) => {
+    test(`isArgOfType: returns ${expected}`, () => {
+      expect(isArgOfType(arg, abiParameter)).toEqual(expected)
+    })
+  },
+)

package/src/utils/abi/getAbiItem.ts

@@ -0,0 +1,95 @@
+import type { Abi, AbiParameter, Address, Narrow } from 'abitype'
+import type { ExtractArgsFromAbi, ExtractNameFromAbi } from '../../types'
+import { isAddress } from '../address'
+
+export type GetAbiItemArgs<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = any,
+> = {
+  abi: Narrow<TAbi>
+  name: ExtractNameFromAbi<TAbi, TFunctionName>
+} & Partial<ExtractArgsFromAbi<TAbi, TFunctionName>>
+
+export function getAbiItem<
+  TAbi extends Abi | readonly unknown[],
+  TFunctionName extends string,
+>({ abi, args = [], name }: GetAbiItemArgs<TAbi, TFunctionName>) {
+  const abiItems = (abi as Abi).filter((x) => 'name' in x && x.name === name)
+
+  if (abiItems.length === 0) return undefined
+  if (abiItems.length === 1) return abiItems[0]
+
+  for (const abiItem of abiItems) {
+    if (!('inputs' in abiItem)) continue
+    if (!args || args.length === 0) {
+      if (!abiItem.inputs || abiItem.inputs.length === 0) return abiItem
+      continue
+    }
+    if (!abiItem.inputs) continue
+    if (abiItem.inputs.length === 0) continue
+    const matched = (args as readonly unknown[]).every((arg, index) => {
+      const abiParameter = 'inputs' in abiItem && abiItem.inputs![index]
+      if (!abiParameter) return false
+      return isArgOfType(arg, abiParameter as AbiParameter)
+    })
+    if (matched) return abiItem
+  }
+  return abiItems[0]
+}
+
+export function isArgOfType(arg: unknown, abiParameter: AbiParameter): boolean {
+  const argType = typeof arg
+  const abiParameterType = abiParameter.type
+  switch (abiParameterType) {
+    case 'address':
+      return isAddress(arg as Address)
+    case 'bool':
+      return argType === 'boolean'
+    case 'function':
+      return argType === 'string'
+    case 'string':
+      return argType === 'string'
+    default: {
+      if (abiParameterType === 'tuple' && 'components' in abiParameter)
+        return Object.values(abiParameter.components).every(
+          (component, index) => {
+            return isArgOfType(
+              Object.values(arg as unknown[] | Record<string, unknown>)[index],
+              component as AbiParameter,
+            )
+          },
+        )
+
+      // `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
+      // https://regexr.com/6v8hp
+      if (
+        /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(
+          abiParameterType,
+        )
+      )
+        return argType === 'number' || argType === 'bigint'
+
+      // `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`
+      // https://regexr.com/6va55
+      if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
+        return argType === 'string' || arg instanceof Uint8Array
+
+      // fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays
+      // https://regexr.com/6va6i
+      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+        return (
+          Array.isArray(arg) &&
+          arg.every((x: unknown) =>
+            isArgOfType(x, {
+              ...abiParameter,
+              // Pop off `[]` or `[M]` from end of type
+              type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, ''),
+            } as AbiParameter),
+          )
+        )
+      }
+
+      return false
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "decodeAbi": [Function],
+      "decodeErrorResult": [Function],
+      "decodeEventLog": [Function],
+      "decodeFunctionData": [Function],
+      "decodeFunctionResult": [Function],
+      "encodeAbi": [Function],
+      "encodeDeployData": [Function],
+      "encodeErrorResult": [Function],
+      "encodeEventTopics": [Function],
+      "encodeFunctionData": [Function],
+      "encodeFunctionResult": [Function],
+      "formatAbiItem": [Function],
+      "formatAbiItemWithArgs": [Function],
+      "getAbiItem": [Function],
+    }
+  `)
+})

package/src/utils/abi/index.ts

@@ -0,0 +1,48 @@
+export type { DecodeAbiArgs } from './decodeAbi'
+export { decodeAbi } from './decodeAbi'
+
+export type {
+  DecodeErrorResultArgs,
+  DecodeErrorResultResponse,
+} from './decodeErrorResult'
+export { decodeErrorResult } from './decodeErrorResult'
+
+export type {
+  DecodeEventLogArgs,
+  DecodeEventLogResponse,
+} from './decodeEventLog'
+export { decodeEventLog } from './decodeEventLog'
+
+export type { DecodeFunctionDataArgs } from './decodeFunctionData'
+export { decodeFunctionData } from './decodeFunctionData'
+
+export type {
+  DecodeFunctionResultArgs,
+  DecodeFunctionResultResponse,
+} from './decodeFunctionResult'
+export { decodeFunctionResult } from './decodeFunctionResult'
+
+export type { EncodeAbiArgs } from './encodeAbi'
+export { encodeAbi } from './encodeAbi'
+
+export type { EncodeDeployDataArgs } from './encodeDeployData'
+export { encodeDeployData } from './encodeDeployData'
+
+export type { EncodeErrorResultArgs } from './encodeErrorResult'
+export { encodeErrorResult } from './encodeErrorResult'
+
+export type { EncodeEventTopicsArgs } from './encodeEventTopics'
+export { encodeEventTopics } from './encodeEventTopics'
+
+export type { EncodeFunctionDataArgs } from './encodeFunctionData'
+export { encodeFunctionData } from './encodeFunctionData'
+
+export type { EncodeFunctionResultArgs } from './encodeFunctionResult'
+export { encodeFunctionResult } from './encodeFunctionResult'
+
+export { formatAbiItemWithArgs } from './formatAbiItemWithArgs'
+
+export { formatAbiItem } from './formatAbiItem'
+
+export type { GetAbiItemArgs } from './getAbiItem'
+export { getAbiItem } from './getAbiItem'