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

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

@@ -1,230 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { decodeErrorResult } from './decodeErrorResult'
-
-test('revert SoldOutError()', () => {
-  expect(
-    decodeErrorResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'SoldOutError',
-          type: 'error',
-        },
-      ],
-      data: '0x7f6df6bb',
-    }),
-  ).toEqual({
-    abiItem: {
-      inputs: [],
-      name: 'SoldOutError',
-      type: 'error',
-    },
-    errorName: 'SoldOutError',
-    args: undefined,
-  })
-  expect(
-    decodeErrorResult({
-      abi: [
-        // @ts-expect-error
-        {
-          name: 'SoldOutError',
-          type: 'error',
-        },
-      ],
-      data: '0x7f6df6bb',
-    }),
-  ).toEqual({
-    abiItem: {
-      name: 'SoldOutError',
-      type: 'error',
-    },
-    errorName: 'SoldOutError',
-    args: undefined,
-  })
-})
-
-test('revert AccessDeniedError(string)', () => {
-  expect(
-    decodeErrorResult({
-      abi: [
-        {
-          inputs: [
-            {
-              internalType: 'string',
-              name: 'a',
-              type: 'string',
-            },
-          ],
-          name: 'AccessDeniedError',
-          type: 'error',
-        },
-      ],
-      data: '0x83aa206e0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001a796f7520646f206e6f7420686176652061636365737320736572000000000000',
-    }),
-  ).toEqual({
-    abiItem: {
-      inputs: [
-        {
-          internalType: 'string',
-          name: 'a',
-          type: 'string',
-        },
-      ],
-      name: 'AccessDeniedError',
-      type: 'error',
-    },
-    errorName: 'AccessDeniedError',
-    args: ['you do not have access ser'],
-  })
-})
-
-test('revert AccessDeniedError((uint256,bool,address,uint256))', () => {
-  expect(
-    decodeErrorResult({
-      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: 'AccessDeniedError',
-          type: 'error',
-        },
-      ],
-      data: '0x0a1895610000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
-    }),
-  ).toEqual({
-    abiItem: {
-      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: 'AccessDeniedError',
-      type: 'error',
-    },
-    errorName: 'AccessDeniedError',
-    args: [
-      {
-        delegate: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
-        vote: 41n,
-        voted: true,
-        weight: 69420n,
-      },
-    ],
-  })
-})
-
-test('Error(string)', () => {
-  expect(
-    decodeErrorResult({
-      data: '0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000047465737400000000000000000000000000000000000000000000000000000000',
-    }),
-  ).toEqual({
-    abiItem: {
-      inputs: [
-        {
-          name: 'message',
-          type: 'string',
-        },
-      ],
-      name: 'Error',
-      type: 'error',
-    },
-    errorName: 'Error',
-    args: ['test'],
-  })
-})
-
-test.todo('Panic(uint256)')
-
-test('zero data', () => {
-  expect(() =>
-    decodeErrorResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'SoldOutError',
-          type: 'error',
-        },
-      ],
-      data: '0x',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(`
-    "Cannot decode zero data (\\"0x\\") with ABI parameters.
-
-    Version: viem@1.0.2"
-  `)
-})
-
-test("errors: error doesn't exist", () => {
-  expect(() =>
-    decodeErrorResult({
-      abi: [
-        {
-          inputs: [],
-          name: 'SoldOutError',
-          type: 'error',
-        },
-      ],
-      data: '0xa37414670000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(`
-    "Encoded error signature \\"0xa3741467\\" not found on ABI.
-    Make sure you are using the correct ABI and that the error exists on it.
-    You can look up the signature \\"0xa3741467\\" here: https://sig.eth.samczsun.com/.
-
-    Docs: https://viem.sh/docs/contract/decodeErrorResult
-    Version: viem@1.0.2"
-  `)
-})

package/src/utils/abi/decodeErrorResult.ts

@@ -1,45 +0,0 @@
-import { Abi, AbiError } from 'abitype'
-import { solidityError, solidityPanic } from '../../constants'
-import {
-  AbiDecodingZeroDataError,
-  AbiErrorSignatureNotFoundError,
-} from '../../errors'
-import { AbiItem, Hex } from '../../types'
-import { slice } from '../data'
-import { getFunctionSignature } from '../hash'
-import { decodeAbi } from './decodeAbi'
-import { formatAbiItem } from './formatAbiItem'
-
-export type DecodeErrorResultArgs = { abi?: Abi; data: Hex }
-
-export type DecodeErrorResultResponse = {
-  abiItem: AbiItem
-  errorName: string
-  args?: readonly unknown[]
-}
-
-export function decodeErrorResult({
-  abi,
-  data,
-}: DecodeErrorResultArgs): DecodeErrorResultResponse {
-  const signature = slice(data, 0, 4)
-  if (signature === '0x') throw new AbiDecodingZeroDataError()
-
-  const abi_ = [...(abi || []), solidityError, solidityPanic]
-  const abiItem = abi_.find(
-    (x) =>
-      x.type === 'error' &&
-      signature === getFunctionSignature(formatAbiItem(x)),
-  )
-  if (!abiItem)
-    throw new AbiErrorSignatureNotFoundError(signature, {
-      docsPath: '/docs/contract/decodeErrorResult',
-    })
-  return {
-    abiItem,
-    args: ('inputs' in abiItem && abiItem.inputs && abiItem.inputs.length > 0
-      ? decodeAbi({ data: slice(data, 4), params: abiItem.inputs })
-      : undefined) as readonly unknown[] | undefined,
-    errorName: (abiItem as { name: string }).name,
-  }
-}

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

@@ -1,139 +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({
-      // @ts-expect-error
-      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 \\"0xa3741467\\" here: https://sig.eth.samczsun.com/.
-
-    Docs: https://viem.sh/docs/contract/decodeFunctionData
-    Version: viem@1.0.2"
-  `)
-})

package/src/utils/abi/decodeFunctionData.ts

@@ -1,29 +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; data: Hex }
-
-export function decodeFunctionData({ abi, data }: DecodeFunctionDataArgs) {
-  const signature = slice(data, 0, 4)
-  const description = 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,
-  }
-}