viem 0.0.1-sushi.26 → 0.1.0

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

@@ -1,138 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { decodeFunctionData } from './decodeFunctionData'
-
-test('foo()', () => {
-  expect(
-    decodeFunctionData({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [],
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ] as const,
-      data: '0xc2985578',
-    }),
-  ).toEqual({ args: undefined, functionName: 'foo' })
-  expect(
-    decodeFunctionData({
-      abi: [
-        {
-          name: 'foo',
-          outputs: [],
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ] as const,
-      data: '0xc2985578',
-    }),
-  ).toEqual({ args: undefined, functionName: 'foo' })
-})
-
-test('bar(uint256)', () => {
-  expect(
-    decodeFunctionData({
-      abi: [
-        {
-          inputs: [
-            {
-              internalType: 'uint256',
-              name: 'a',
-              type: 'uint256',
-            },
-          ],
-          name: 'bar',
-          outputs: [],
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ] as const,
-      data: '0x0423a1320000000000000000000000000000000000000000000000000000000000000001',
-    }),
-  ).toEqual({
-    args: [1n],
-    functionName: 'bar',
-  })
-})
-
-test('getVoter((uint256,bool,address,uint256))', () => {
-  expect(
-    decodeFunctionData({
-      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',
-        },
-      ] as const,
-      data: '0xf37414670000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
-    }),
-  ).toEqual({
-    args: [
-      {
-        delegate: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-        vote: 41n,
-        voted: true,
-        weight: 69420n,
-      },
-    ],
-    functionName: 'getVoter',
-  })
-})
-
-test("errors: function doesn't exist", () => {
-  expect(() =>
-    decodeFunctionData({
-      abi: [
-        {
-          inputs: [],
-          name: 'foo',
-          outputs: [],
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ] as const,
-      data: '0xa37414670000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(`
-    "Encoded function signature \\"0xa3741467\\" not found on ABI.
-    Make sure you are using the correct ABI and that the function exists on it.
-    You can look up the signature here: https://openchain.xyz/signatures?query=0xa3741467.
-
-    Docs: https://viem.sh/docs/contract/decodeFunctionData
-    Version: viem@1.0.2"
-  `)
-})

package/src/utils/abi/decodeFunctionData.ts

@@ -1,32 +0,0 @@
-import { Abi } from 'abitype'
-
-import { AbiFunctionSignatureNotFoundError } from '../../errors'
-import { Hex } from '../../types'
-import { slice } from '../data'
-import { getFunctionSignature } from '../hash'
-import { decodeAbi } from './decodeAbi'
-import { formatAbiItem } from './formatAbiItem'
-
-export type DecodeFunctionDataArgs = {
-  abi: Abi | readonly unknown[]
-  data: Hex
-}
-
-export function decodeFunctionData({ abi, data }: DecodeFunctionDataArgs) {
-  const signature = slice(data, 0, 4)
-  const description = (abi as Abi).find(
-    (x) => signature === getFunctionSignature(formatAbiItem(x)),
-  )
-  if (!description)
-    throw new AbiFunctionSignatureNotFoundError(signature, {
-      docsPath: '/docs/contract/decodeFunctionData',
-    })
-  return {
-    functionName: (description as { name: string }).name,
-    args: ('inputs' in description &&
-    description.inputs &&
-    description.inputs.length > 0
-      ? decodeAbi({ data: slice(data, 4), params: description.inputs })
-      : undefined) as readonly unknown[] | undefined,
-  }
-}

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
-}