viem 0.0.1-alpha.20 → 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(
@@ -897,7 +897,39 @@ describe('dynamic', () => {
   describe('(bytes)', () => {
     test('default', () => {
       expect(
-        // cast abi-encode "a(bytes)" "0x042069"
+        // cast abi-encode "a(bytes)" "0x42069"
+        encodeAbi({
+          params: [
+            {
+              internalType: 'bytes',
+              name: 'xIn',
+              type: 'bytes',
+            },
+          ],
+          values: ['0x42069'],
+        }),
+      ).toMatchInlineSnapshot(
+        '"0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000034206900000000000000000000000000000000000000000000000000000000000"',
+      )
+      expect(
+        // cast abi-encode "a(bytes)" "0x70a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045"
+        encodeAbi({
+          params: [
+            {
+              internalType: 'bytes',
+              name: 'xIn',
+              type: 'bytes',
+            },
+          ],
+          values: [
+            '0x70a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045',
+          ],
+        }),
+      ).toMatchInlineSnapshot(
+        '"0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002470a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa9604500000000000000000000000000000000000000000000000000000000"',
+      )
+      expect(
+        // cast abi-encode "a(bytes)" "0x70a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa9604570a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045"
         encodeAbi({
           params: [
             {
@@ -906,10 +938,12 @@ describe('dynamic', () => {
               type: 'bytes',
             },
           ],
-          values: ['0x042069'],
+          values: [
+            '0x70a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa9604570a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045',
+          ],
         }),
       ).toMatchInlineSnapshot(
-        '"0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000030420690000000000000000000000000000000000000000000000000000000000"',
+        '"0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000004870a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa9604570a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045000000000000000000000000000000000000000000000000"',
       )
     })
   })
@@ -1168,7 +1202,7 @@ describe('dynamic', () => {
               name: 'wagmiIn',
               type: 'tuple',
             },
-          ] as const,
+          ],
           values: [
             {
               foo: {
@@ -1356,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 {
@@ -11,28 +12,36 @@ import {
   InvalidArrayError,
 } from '../../errors'
 import { Hex } from '../../types'
-import { concat, padHex, size } from '../data'
+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[] = []
@@ -183,14 +192,20 @@ function encodeBytes<TParam extends AbiParameter>(
   { param }: { param: TParam },
 ): PreparedParam {
   const [_, size_] = param.type.split('bytes')
-  if (!size_)
+  if (!size_) {
+    const partsLength = Math.floor(size(value) / 32)
+    const parts: Hex[] = []
+    for (let i = 0; i < partsLength + 1; i++) {
+      parts.push(padHex(slice(value, i * 32, (i + 1) * 32), { dir: 'right' }))
+    }
     return {
       dynamic: true,
       encoded: concat([
         padHex(numberToHex(size(value), { size: 32 })),
-        padHex(value, { dir: 'right' }),
+        ...parts,
       ]),
     }
+  }
   return { dynamic: false, encoded: padHex(value, { dir: 'right' }) }
 }