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

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

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

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

@@ -1,23 +0,0 @@
-import { expect, test } from 'vitest'
-
-import * as utils from './index'
-
-test('exports utils', () => {
-  expect(utils).toMatchInlineSnapshot(`
-    {
-      "decodeAbi": [Function],
-      "decodeErrorResult": [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

@@ -1,42 +0,0 @@
-export type { DecodeAbiArgs } from './decodeAbi'
-export { decodeAbi } from './decodeAbi'
-
-export type {
-  DecodeErrorResultArgs,
-  DecodeErrorResultResponse,
-} from './decodeErrorResult'
-export { decodeErrorResult } from './decodeErrorResult'
-
-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'