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

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

@@ -1,333 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { decodeFunctionResult } from './decodeFunctionResult'
-
-test('returns ()', () => {
-  expect(
-    decodeFunctionResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      functionName: 'foo',
-      data: '0x',
-    }),
-  ).toEqual(undefined)
-  expect(
-    decodeFunctionResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      functionName: 'foo',
-      // @ts-expect-error
-      data: '',
-    }),
-  ).toEqual(undefined)
-})
-
-test('returns (address)', () => {
-  expect(
-    decodeFunctionResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [
-            {
-              internalType: 'address',
-              name: 'sender',
-              type: 'address',
-            },
-          ],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      functionName: 'foo',
-      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
-    }),
-  ).toEqual('0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC')
-})
-
-test('returns (Bar)', () => {
-  expect(
-    decodeFunctionResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'bar',
-          outputs: [
-            {
-              components: [
-                {
-                  components: [
-                    {
-                      internalType: 'address',
-                      name: 'sender',
-                      type: 'address',
-                    },
-                    {
-                      internalType: 'uint256',
-                      name: 'x',
-                      type: 'uint256',
-                    },
-                    {
-                      internalType: 'bool',
-                      name: 'y',
-                      type: 'bool',
-                    },
-                  ],
-                  internalType: 'struct Example.Foo',
-                  name: 'foo',
-                  type: 'tuple',
-                },
-                {
-                  internalType: 'address',
-                  name: 'sender',
-                  type: 'address',
-                },
-                {
-                  internalType: 'uint32',
-                  name: 'z',
-                  type: 'uint32',
-                },
-              ],
-              internalType: 'struct Example.Bar',
-              name: 'res',
-              type: 'tuple',
-            },
-          ],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      functionName: 'bar',
-      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000045',
-    }),
-  ).toEqual({
-    foo: {
-      sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-      x: 69420n,
-      y: true,
-    },
-    sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-    z: 69,
-  })
-})
-
-test('returns (Bar, string)', () => {
-  expect(
-    decodeFunctionResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'baz',
-          outputs: [
-            {
-              components: [
-                {
-                  components: [
-                    {
-                      internalType: 'address',
-                      name: 'sender',
-                      type: 'address',
-                    },
-                    {
-                      internalType: 'uint256',
-                      name: 'x',
-                      type: 'uint256',
-                    },
-                    {
-                      internalType: 'bool',
-                      name: 'y',
-                      type: 'bool',
-                    },
-                  ],
-                  internalType: 'struct Example.Foo',
-                  name: 'foo',
-                  type: 'tuple',
-                },
-                {
-                  internalType: 'address',
-                  name: 'sender',
-                  type: 'address',
-                },
-                {
-                  internalType: 'uint32',
-                  name: 'z',
-                  type: 'uint32',
-                },
-              ],
-              internalType: 'struct Example.Bar',
-              name: 'res',
-              type: 'tuple',
-            },
-            {
-              internalType: 'string',
-              name: 'bob',
-              type: 'string',
-            },
-          ],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      functionName: 'baz',
-      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000057761676d69000000000000000000000000000000000000000000000000000000',
-    }),
-  ).toEqual([
-    {
-      foo: {
-        sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-        x: 69420n,
-        y: true,
-      },
-      sender: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-      z: 69,
-    },
-    'wagmi',
-  ])
-})
-
-test('overloads', () => {
-  expect(
-    decodeFunctionResult({
-      abi: [
-        {
-          inputs: [{ internalType: 'uint256', name: 'x', type: 'uint256' }],
-          name: 'foo',
-          outputs: [
-            {
-              internalType: 'uint256',
-              name: 'x',
-              type: 'uint256',
-            },
-          ],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [
-            {
-              internalType: 'address',
-              name: 'sender',
-              type: 'address',
-            },
-          ],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      functionName: 'foo',
-      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
-    }),
-  ).toEqual('0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC')
-
-  expect(
-    decodeFunctionResult({
-      abi: [
-        {
-          inputs: [{ internalType: 'uint256', name: 'x', type: 'uint256' }],
-          name: 'foo',
-          outputs: [
-            {
-              internalType: 'uint256',
-              name: 'x',
-              type: 'uint256',
-            },
-          ],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [
-            {
-              internalType: 'address',
-              name: 'sender',
-              type: 'address',
-            },
-          ],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      functionName: 'foo',
-      data: '0x0000000000000000000000000000000000000000000000000000000000000069',
-      args: [10n],
-    }),
-  ).toEqual(105n)
-})
-
-test("error: function doesn't exist", () => {
-  expect(() =>
-    decodeFunctionResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [
-            {
-              internalType: 'address',
-              name: 'sender',
-              type: 'address',
-            },
-          ],
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      // @ts-expect-error
-      functionName: 'baz',
-      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(
-    `
-    "Function \\"baz\\" 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/decodeFunctionResult
-    Version: viem@1.0.2"
-  `,
-  )
-})
-
-test("error: function doesn't exist", () => {
-  expect(() =>
-    decodeFunctionResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          stateMutability: 'pure',
-          type: 'function',
-        },
-      ],
-      functionName: 'foo',
-      data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(
-    `
-    "Function \\"foo\\" does not contain any \`outputs\` on ABI.
-    Cannot decode function result without knowing what the parameter types are.
-    Make sure you are using the correct ABI and that the function exists on it.
-
-    Docs: https://viem.sh/docs/contract/decodeFunctionResult
-    Version: viem@1.0.2"
-  `,
-  )
-})

package/src/utils/abi/decodeFunctionResult.ts

@@ -1,57 +0,0 @@
-import { Abi, Narrow } from 'abitype'
-import {
-  AbiFunctionNotFoundError,
-  AbiFunctionOutputsNotFoundError,
-} from '../../errors'
-import {
-  ExtractArgsFromAbi,
-  ExtractFunctionNameFromAbi,
-  ExtractResultFromAbi,
-  Hex,
-} from '../../types'
-import { decodeAbi } from './decodeAbi'
-import { getAbiItem, GetAbiItemArgs } from './getAbiItem'
-
-const docsPath = '/docs/contract/decodeFunctionResult'
-
-export type DecodeFunctionResultArgs<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = {
-  abi: Narrow<TAbi>
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
-  data: Hex
-} & Partial<ExtractArgsFromAbi<TAbi, TFunctionName>>
-
-export type DecodeFunctionResultResponse<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = ExtractResultFromAbi<TAbi, TFunctionName>
-
-export function decodeFunctionResult<
-  TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
->({
-  abi,
-  args,
-  functionName,
-  data,
-}: DecodeFunctionResultArgs<TAbi, TFunctionName>): DecodeFunctionResultResponse<
-  TAbi,
-  TFunctionName
-> {
-  const description = getAbiItem({
-    abi,
-    args,
-    name: functionName,
-  } as GetAbiItemArgs)
-  if (!description)
-    throw new AbiFunctionNotFoundError(functionName, { docsPath })
-  if (!('outputs' in description))
-    throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath })
-
-  const values = decodeAbi({ data, params: description.outputs })
-  if (values && values.length > 1) return values as any
-  if (values && values.length === 1) return values[0] as any
-  return undefined as any
-}

package/src/utils/abi/encodeAbi.bench.ts

@@ -1,163 +0,0 @@
-import { AbiCoder } from 'ethers/lib/utils'
-import { bench, describe } from 'vitest'
-
-import { encodeAbi } from './encodeAbi'
-
-describe('ABI Encode', () => {
-  bench('viem: `encodeAbi`', () => {
-    encodeAbi({
-      params: [
-        {
-          components: [
-            {
-              components: [
-                {
-                  internalType: 'uint256',
-                  name: 'x',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'bool',
-                  name: 'y',
-                  type: 'bool',
-                },
-                {
-                  internalType: 'address',
-                  name: 'z',
-                  type: 'address',
-                },
-              ],
-              internalType: 'struct ABIExample.Foo',
-              name: 'foo',
-              type: 'tuple',
-            },
-            {
-              components: [
-                {
-                  internalType: 'uint256',
-                  name: 'x',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'bool',
-                  name: 'y',
-                  type: 'bool',
-                },
-                {
-                  internalType: 'address',
-                  name: 'z',
-                  type: 'address',
-                },
-              ],
-              internalType: 'struct ABIExample.Foo',
-              name: 'baz',
-              type: 'tuple',
-            },
-            {
-              internalType: 'uint8[2]',
-              name: 'x',
-              type: 'uint8[2]',
-            },
-          ],
-          internalType: 'struct ABIExample.Bar',
-          name: 'barOut',
-          type: 'tuple',
-        },
-      ],
-      values: [
-        {
-          foo: {
-            x: 420n,
-            y: true,
-            z: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-          },
-          baz: {
-            x: 69n,
-            y: false,
-            z: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b',
-          },
-          x: [1, 2],
-        },
-      ],
-    })
-  })
-
-  bench('ethers: `AbiCoder.encode`', () => {
-    const coder = new AbiCoder()
-    coder.encode(
-      [
-        {
-          components: [
-            {
-              components: [
-                {
-                  internalType: 'uint256',
-                  name: 'x',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'bool',
-                  name: 'y',
-                  type: 'bool',
-                },
-                {
-                  internalType: 'address',
-                  name: 'z',
-                  type: 'address',
-                },
-              ],
-              internalType: 'struct ABIExample.Foo',
-              name: 'foo',
-              type: 'tuple',
-            },
-            {
-              components: [
-                {
-                  internalType: 'uint256',
-                  name: 'x',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'bool',
-                  name: 'y',
-                  type: 'bool',
-                },
-                {
-                  internalType: 'address',
-                  name: 'z',
-                  type: 'address',
-                },
-              ],
-              internalType: 'struct ABIExample.Foo',
-              name: 'baz',
-              type: 'tuple',
-            },
-            {
-              internalType: 'uint8[2]',
-              name: 'x',
-              type: 'uint8[2]',
-            },
-          ],
-          internalType: 'struct ABIExample.Bar',
-          name: 'barOut',
-          type: 'tuple',
-        },
-      ],
-      [
-        {
-          foo: {
-            x: 420n,
-            y: true,
-            z: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-          },
-          baz: {
-            x: 69n,
-            y: false,
-            z: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b',
-          },
-          x: [1, 2],
-        },
-      ],
-    )
-  })
-})