viem 0.0.1-alpha.21 → 0.0.1-alpha.22

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

@@ -14,7 +14,15 @@ test('revert SoldOutError()', () => {
       ],
       data: '0x7f6df6bb',
     }),
-  ).toEqual({ errorName: 'SoldOutError', args: undefined })
+  ).toEqual({
+    abiItem: {
+      inputs: [],
+      name: 'SoldOutError',
+      type: 'error',
+    },
+    errorName: 'SoldOutError',
+    args: undefined,
+  })
   expect(
     decodeErrorResult({
       abi: [
@@ -26,7 +34,14 @@ test('revert SoldOutError()', () => {
       ],
       data: '0x7f6df6bb',
     }),
-  ).toEqual({ errorName: 'SoldOutError', args: undefined })
+  ).toEqual({
+    abiItem: {
+      name: 'SoldOutError',
+      type: 'error',
+    },
+    errorName: 'SoldOutError',
+    args: undefined,
+  })
 })
 
 test('revert AccessDeniedError(string)', () => {
@@ -48,6 +63,17 @@ test('revert AccessDeniedError(string)', () => {
       data: '0x83aa206e0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001a796f7520646f206e6f7420686176652061636365737320736572000000000000',
     }),
   ).toEqual({
+    abiItem: {
+      inputs: [
+        {
+          internalType: 'string',
+          name: 'a',
+          type: 'string',
+        },
+      ],
+      name: 'AccessDeniedError',
+      type: 'error',
+    },
     errorName: 'AccessDeniedError',
     args: ['you do not have access ser'],
   })
@@ -94,6 +120,39 @@ test('revert AccessDeniedError((uint256,bool,address,uint256))', () => {
       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: [
       {
@@ -106,6 +165,48 @@ test('revert AccessDeniedError((uint256,bool,address,uint256))', () => {
   })
 })
 
+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({
@@ -124,7 +225,6 @@ test("errors: error doesn't exist", () => {
     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,28 +1,45 @@
-import { Abi } from 'abitype'
-import { AbiErrorSignatureNotFoundError } from '../../errors'
-import { Hex } from '../../types'
+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 DecodeErrorResultArgs = { abi?: Abi; data: Hex }
 
-export function decodeErrorResult({ abi, data }: DecodeErrorResultArgs) {
+export type DecodeErrorResultResponse = {
+  abiItem: AbiItem
+  errorName: string
+  args?: readonly unknown[]
+}
+
+export function decodeErrorResult({
+  abi,
+  data,
+}: DecodeErrorResultArgs): DecodeErrorResultResponse {
   const signature = slice(data, 0, 4)
-  const description = abi.find(
-    (x) => signature === getFunctionSignature(formatAbiItem(x)),
+  if (signature === '0x') throw new AbiDecodingZeroDataError()
+
+  const abi_ = [...(abi || []), solidityError, solidityPanic]
+  const abiItem = abi_.find(
+    (x) =>
+      x.type === 'error' &&
+      signature === getFunctionSignature(formatAbiItem(x)),
   )
-  if (!description)
+  if (!abiItem)
     throw new AbiErrorSignatureNotFoundError(signature, {
       docsPath: '/docs/contract/decodeErrorResult',
     })
   return {
-    errorName: (description as { name: string }).name,
-    args: ('inputs' in description &&
-    description.inputs &&
-    description.inputs.length > 0
-      ? decodeAbi({ data: slice(data, 4), params: description.inputs })
+    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

@@ -134,7 +134,6 @@ test("errors: function doesn't exist", () => {
     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/decodeFunctionResult.test.ts

@@ -13,7 +13,7 @@ test('returns ()', () => {
           stateMutability: 'pure',
           type: 'function',
         },
-      ] as const,
+      ],
       functionName: 'foo',
       data: '0x',
     }),
@@ -28,7 +28,7 @@ test('returns ()', () => {
           stateMutability: 'pure',
           type: 'function',
         },
-      ] as const,
+      ],
       functionName: 'foo',
       // @ts-expect-error
       data: '',
@@ -53,7 +53,7 @@ test('returns (address)', () => {
           stateMutability: 'pure',
           type: 'function',
         },
-      ] as const,
+      ],
       functionName: 'foo',
       data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
     }),
@@ -111,7 +111,7 @@ test('returns (Bar)', () => {
           stateMutability: 'pure',
           type: 'function',
         },
-      ] as const,
+      ],
       functionName: 'bar',
       data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000045',
     }),
@@ -182,7 +182,7 @@ test('returns (Bar, string)', () => {
           stateMutability: 'pure',
           type: 'function',
         },
-      ] as const,
+      ],
       functionName: 'baz',
       data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000057761676d69000000000000000000000000000000000000000000000000000000',
     }),
@@ -200,6 +200,79 @@ test('returns (Bar, string)', () => {
   ])
 })
 
+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({
@@ -217,7 +290,7 @@ test("error: function doesn't exist", () => {
           stateMutability: 'pure',
           type: 'function',
         },
-      ] as const,
+      ],
       // @ts-expect-error
       functionName: 'baz',
       data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
@@ -228,7 +301,6 @@ test("error: function doesn't exist", () => {
     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"
   `,
   )
@@ -244,7 +316,7 @@ test("error: function doesn't exist", () => {
           stateMutability: 'pure',
           type: 'function',
         },
-      ] as const,
+      ],
       functionName: 'foo',
       data: '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
     }),
@@ -255,7 +327,6 @@ test("error: function doesn't exist", () => {
     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,46 +1,50 @@
-import { Abi, ExtractAbiFunctionNames } from 'abitype'
+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 = any,
+  TFunctionName extends string = string,
 > = {
-  abi: TAbi
+  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 = any,
+  TFunctionName extends string = string,
 > = ExtractResultFromAbi<TAbi, TFunctionName>
 
 export function decodeFunctionResult<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = any,
+  TAbi extends Abi | readonly unknown[],
+  TFunctionName extends string,
 >({
   abi,
+  args,
   functionName,
   data,
 }: DecodeFunctionResultArgs<TAbi, TFunctionName>): DecodeFunctionResultResponse<
   TAbi,
   TFunctionName
 > {
-  const description = (abi as Abi).find(
-    (x) => 'name' in x && x.name === functionName,
-  )
+  const description = getAbiItem({
+    abi,
+    args,
+    name: functionName,
+  } as GetAbiItemArgs)
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, { docsPath })
   if (!('outputs' in description))

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

@@ -745,7 +745,7 @@ describe('static', () => {
             { internalType: 'uint256[2]', name: 'xOut', type: 'uint256[2]' },
             { internalType: 'bool', name: 'yOut', type: 'bool' },
             { internalType: 'string[3]', name: 'zOut', type: 'string[3]' },
-          ] as any,
+          ],
           values: [[420n, 69n], true, ['wagmi', 'viem', 'lol']],
         }),
       ).toMatchInlineSnapshot(
@@ -885,7 +885,7 @@ describe('dynamic', () => {
               name: 'zIn',
               type: 'string',
             },
-          ] as const,
+          ],
           values: [[420n, 69n], true, 'wagmi'],
         }),
       ).toMatchInlineSnapshot(
@@ -1202,7 +1202,7 @@ describe('dynamic', () => {
               name: 'wagmiIn',
               type: 'tuple',
             },
-          ] as const,
+          ],
           values: [
             {
               foo: {
@@ -1390,7 +1390,6 @@ test('invalid type', () => {
     Please provide a valid ABI type.
 
     Docs: https://viem.sh/docs/contract/encodeAbi
-
     Version: viem@1.0.2"
   `)
 })

package/src/utils/abi/encodeAbi.ts

@@ -2,6 +2,7 @@ import {
   AbiParameter,
   AbiParametersToPrimitiveTypes,
   AbiParameterToPrimitiveType,
+  Narrow,
 } from 'abitype'
 
 import {
@@ -14,25 +15,33 @@ import { Hex } from '../../types'
 import { concat, padHex, size, slice } from '../data'
 import { boolToHex, numberToHex, stringToHex } from '../encoding'
 
-export type EncodeAbiArgs<TParams extends readonly AbiParameter[]> = {
-  params: TParams
-  values: AbiParametersToPrimitiveTypes<TParams>
+export type EncodeAbiArgs<
+  TParams extends
+    | readonly AbiParameter[]
+    | readonly unknown[] = readonly AbiParameter[],
+> = {
+  params: Narrow<TParams>
+  values: TParams extends readonly AbiParameter[]
+    ? AbiParametersToPrimitiveTypes<TParams>
+    : never
 }
 
 /**
  * @description Encodes a list of primitive values into an ABI-encoded hex value.
  */
-export function encodeAbi<TParams extends readonly AbiParameter[]>({
-  params,
-  values,
-}: EncodeAbiArgs<TParams>) {
+export function encodeAbi<
+  TParams extends readonly AbiParameter[] | readonly unknown[],
+>({ params, values }: EncodeAbiArgs<TParams>) {
   if (params.length !== values.length)
     throw new AbiEncodingLengthMismatchError({
-      expectedLength: params.length,
+      expectedLength: params.length as number,
       givenLength: values.length,
     })
   // Prepare the parameters to determine dynamic types to encode.
-  const preparedParams = prepareParams({ params, values })
+  const preparedParams = prepareParams({
+    params: params as readonly AbiParameter[],
+    values,
+  })
   const data = encodeParams(preparedParams)
   if (data.length === 0) return '0x'
   return data
@@ -49,7 +58,7 @@ function prepareParams<TParams extends readonly AbiParameter[]>({
   params,
   values,
 }: {
-  params: TParams
+  params: Narrow<TParams>
   values: AbiParametersToPrimitiveTypes<TParams>
 }) {
   let preparedParams: PreparedParam[] = []

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

@@ -11,7 +11,7 @@ test('constructor()', () => {
           stateMutability: 'nonpayable',
           type: 'constructor',
         },
-      ] as const,
+      ],
       bytecode:
         '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
     }),
@@ -20,13 +20,12 @@ test('constructor()', () => {
   )
   expect(
     encodeDeployData({
-      // @ts-expect-error
       abi: [
         {
           stateMutability: 'nonpayable',
           type: 'constructor',
         },
-      ] as const,
+      ],
       bytecode:
         '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
     }),
@@ -50,7 +49,7 @@ test('constructor(uint256)', () => {
           stateMutability: 'nonpayable',
           type: 'constructor',
         },
-      ] as const,
+      ],
       bytecode:
         '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
       args: [69420n],
@@ -63,8 +62,7 @@ test('constructor(uint256)', () => {
 test('error: constructor not found', () => {
   expect(() =>
     encodeDeployData({
-      // @ts-expect-error
-      abi: [{}] as const,
+      abi: [{}],
       bytecode:
         '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
       args: [69420n],
@@ -74,7 +72,6 @@ test('error: constructor not found', () => {
     Make sure you are using the correct ABI and that the constructor exists on it.
 
     Docs: https://viem.sh/docs/contract/encodeDeployData
-
     Version: viem@1.0.2"
   `)
 })
@@ -82,13 +79,12 @@ test('error: constructor not found', () => {
 test('error: no inputs', () => {
   expect(() =>
     encodeDeployData({
-      // @ts-expect-error
       abi: [
         {
           stateMutability: 'nonpayable',
           type: 'constructor',
         },
-      ] as const,
+      ],
       bytecode:
         '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
       args: [69420n],
@@ -99,21 +95,19 @@ test('error: no inputs', () => {
     Make sure you are using the correct ABI, and that the \`inputs\` attribute on the constructor exists.
 
     Docs: https://viem.sh/docs/contract/encodeDeployData
-
     Version: viem@1.0.2"
   `,
   )
 
   expect(() =>
     encodeDeployData({
-      // @ts-expect-error
       abi: [
         {
           inputs: undefined,
           stateMutability: 'nonpayable',
           type: 'constructor',
         },
-      ] as const,
+      ],
       bytecode:
         '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
       args: [69420n],
@@ -124,7 +118,6 @@ test('error: no inputs', () => {
     Make sure you are using the correct ABI, and that the \`inputs\` attribute on the constructor exists.
 
     Docs: https://viem.sh/docs/contract/encodeDeployData
-
     Version: viem@1.0.2"
   `,
   )

package/src/utils/abi/encodeDeployData.ts

@@ -1,4 +1,4 @@
-import { Abi } from 'abitype'
+import { Abi, Narrow } from 'abitype'
 
 import {
   AbiConstructorNotFoundError,
@@ -10,19 +10,22 @@ import { encodeAbi } from './encodeAbi'
 
 const docsPath = '/docs/contract/encodeDeployData'
 
-export type EncodeDeployDataArgs<TAbi extends Abi = Abi> = {
-  abi: TAbi
-  bytecode: Hex
-} & ExtractConstructorArgsFromAbi<TAbi>
+export type EncodeDeployDataArgs<TAbi extends Abi | readonly unknown[] = Abi> =
+  {
+    abi: Narrow<TAbi>
+    bytecode: Hex
+  } & ExtractConstructorArgsFromAbi<TAbi>
 
-export function encodeDeployData<TAbi extends Abi = Abi>({
+export function encodeDeployData<TAbi extends Abi | readonly unknown[]>({
   abi,
   args,
   bytecode,
 }: EncodeDeployDataArgs<TAbi>) {
   if (!args || args.length === 0) return bytecode
 
-  const description = abi.find((x) => 'type' in x && x.type === 'constructor')
+  const description = (abi as Abi).find(
+    (x) => 'type' in x && x.type === 'constructor',
+  )
   if (!description) throw new AbiConstructorNotFoundError({ docsPath })
   if (!('inputs' in description))
     throw new AbiConstructorParamsNotFoundError({ docsPath })