viem 0.0.1-alpha.21 → 0.0.1-alpha.23

package/src/errors/base.test.ts

@@ -17,6 +17,13 @@ test('BaseError', () => {
     Details: details
     Version: viem@1.0.2]
   `)
+
+  expect(new BaseError('', { details: 'details' })).toMatchInlineSnapshot(`
+    [ViemError: An error occurred.
+
+    Details: details
+    Version: viem@1.0.2]
+  `)
 })
 
 test('BaseError (w/ docsPath)', () => {
@@ -29,6 +36,43 @@ test('BaseError (w/ docsPath)', () => {
     [ViemError: An error occurred.
 
     Docs: https://viem.sh/lol
+    Details: details
+    Version: viem@1.0.2]
+  `)
+  expect(
+    new BaseError('An error occurred.', {
+      cause: new BaseError('error', { docsPath: '/docs' }),
+    }),
+  ).toMatchInlineSnapshot(`
+    [ViemError: An error occurred.
+
+    Docs: https://viem.sh/docs
+    Version: viem@1.0.2]
+  `)
+  expect(
+    new BaseError('An error occurred.', {
+      cause: new BaseError('error'),
+      docsPath: '/lol',
+    }),
+  ).toMatchInlineSnapshot(`
+    [ViemError: An error occurred.
+
+    Docs: https://viem.sh/lol
+    Version: viem@1.0.2]
+  `)
+})
+
+test('BaseError (w/ metaMessages)', () => {
+  expect(
+    new BaseError('An error occurred.', {
+      details: 'details',
+      metaMessages: ['Reason: idk', 'Cause: lol'],
+    }),
+  ).toMatchInlineSnapshot(`
+    [ViemError: An error occurred.
+
+    Reason: idk
+    Cause: lol
 
     Details: details
     Version: viem@1.0.2]
@@ -48,7 +92,6 @@ test('inherited BaseError', () => {
     [ViemError: An internal error occurred.
 
     Docs: https://viem.sh/lol
-
     Details: details
     Version: viem@1.0.2]
   `)
@@ -65,7 +108,6 @@ test('inherited Error', () => {
     [ViemError: An internal error occurred.
 
     Docs: https://viem.sh/lol
-
     Details: details
     Version: viem@1.0.2]
   `)

package/src/errors/base.ts

@@ -1,11 +1,13 @@
 // @ts-ignore
 import pkg from '../../package.json'
-import { stringify } from '../utils/stringify'
 
 /* c8 ignore next */
 const version = process.env.TEST ? '1.0.2' : pkg.version
 
-type BaseErrorArgs = { docsPath?: string } & (
+type BaseErrorArgs = {
+  docsPath?: string
+  metaMessages?: string[]
+} & (
   | {
       cause?: never
       details?: string
@@ -17,13 +19,14 @@ type BaseErrorArgs = { docsPath?: string } & (
 )
 
 export class BaseError extends Error {
-  humanMessage: string
   details: string
   docsPath?: string
+  metaMessages?: string[]
+  shortMessage: string
 
   name = 'ViemError'
 
-  constructor(humanMessage: string, args: BaseErrorArgs = {}) {
+  constructor(shortMessage: string, args: BaseErrorArgs = {}) {
     const details =
       args.cause instanceof BaseError
         ? args.cause.details
@@ -35,16 +38,12 @@ export class BaseError extends Error {
         ? args.cause.docsPath || args.docsPath
         : args.docsPath
     const message = [
-      humanMessage,
-      ...(docsPath ? ['', `Docs: https://viem.sh${docsPath}`] : []),
+      shortMessage || 'An error occurred.',
       '',
+      ...(args.metaMessages ? [...args.metaMessages, ''] : []),
+      ...(docsPath ? [`Docs: https://viem.sh${docsPath}`] : []),
       ...(details ? [`Details: ${details}`] : []),
       `Version: viem@${version}`,
-      ...(args.cause &&
-      !(args.cause instanceof BaseError) &&
-      Object.keys(args.cause).length > 0
-        ? [`Internal Error: ${stringify(args.cause)}`]
-        : []),
     ].join('\n')
 
     super(message)
@@ -52,6 +51,7 @@ export class BaseError extends Error {
     if (args.cause) this.cause = args.cause
     this.details = details
     this.docsPath = docsPath
-    this.humanMessage = humanMessage
+    this.metaMessages = args.metaMessages
+    this.shortMessage = shortMessage
   }
 }

package/src/errors/block.test.ts

@@ -5,17 +5,17 @@ test('BlockNotFoundError', () => {
   expect(
     new BlockNotFoundError({ blockNumber: 69420n }),
   ).toMatchInlineSnapshot(`
-      [BlockNotFoundError: Block at number "69420" could not be found.
+    [BlockNotFoundError: Block at number "69420" could not be found.
 
-      Version: viem@1.0.2]
-    `)
+    Version: viem@1.0.2]
+  `)
   expect(
     new BlockNotFoundError({ blockHash: '0x69420' }),
   ).toMatchInlineSnapshot(`
-      [BlockNotFoundError: Block at hash "0x69420" could not be found.
+    [BlockNotFoundError: Block at hash "0x69420" could not be found.
 
-      Version: viem@1.0.2]
-    `)
+    Version: viem@1.0.2]
+  `)
   expect(new BlockNotFoundError({})).toMatchInlineSnapshot(`
     [BlockNotFoundError: Block could not be found.
 

package/src/errors/contract.test.ts

@@ -0,0 +1,233 @@
+import { describe, expect, test } from 'vitest'
+import { baycContractConfig } from '../_test/abis'
+import { errorsExampleABI } from '../_test/generated'
+import { BaseError } from './base'
+import {
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  RawContractError,
+} from './contract'
+
+describe('ContractFunctionExecutionError', () => {
+  test('default', () => {
+    expect(
+      new ContractFunctionExecutionError(new BaseError('Internal error.'), {
+        abi: baycContractConfig.abi,
+        functionName: 'totalSupply',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: Internal error.
+
+      Function:  totalSupply()
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('args: contractAddress', () => {
+    expect(
+      new ContractFunctionExecutionError(new BaseError('Internal error.'), {
+        abi: baycContractConfig.abi,
+        functionName: 'totalSupply',
+        contractAddress: '0x0000000000000000000000000000000000000000',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: Internal error.
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  totalSupply()
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('args: args', () => {
+    expect(
+      new ContractFunctionExecutionError(new BaseError('Internal error.'), {
+        abi: baycContractConfig.abi,
+        functionName: 'mintApe',
+        args: [1n],
+        contractAddress: '0x0000000000000000000000000000000000000000',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: Internal error.
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  mintApe(uint256 numberOfTokens)
+      Arguments:        (1)
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('args: docsPath', () => {
+    expect(
+      new ContractFunctionExecutionError(new BaseError('Internal error.'), {
+        abi: baycContractConfig.abi,
+        functionName: 'mintApe',
+        args: [1n],
+        contractAddress: '0x0000000000000000000000000000000000000000',
+        docsPath: '/docs',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: Internal error.
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  mintApe(uint256 numberOfTokens)
+      Arguments:        (1)
+
+      Docs: https://viem.sh/docs
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('args: sender', () => {
+    expect(
+      new ContractFunctionExecutionError(new BaseError('Internal error.'), {
+        abi: baycContractConfig.abi,
+        functionName: 'mintApe',
+        args: [1n],
+        contractAddress: '0x0000000000000000000000000000000000000000',
+        sender: '0x0000000000000000000000000000000000000000',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: Internal error.
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  mintApe(uint256 numberOfTokens)
+      Arguments:        (1)
+      Sender:    0x0000000000000000000000000000000000000000
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('cause: metaMessages', () => {
+    expect(
+      new ContractFunctionExecutionError(
+        new BaseError('Internal error.', { metaMessages: ['foo', 'bar'] }),
+        {
+          abi: baycContractConfig.abi,
+          functionName: 'totalSupply',
+          contractAddress: '0x0000000000000000000000000000000000000000',
+        },
+      ),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: Internal error.
+
+      foo
+      bar
+       
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  totalSupply()
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('no message', () => {
+    expect(
+      new ContractFunctionExecutionError(new BaseError(''), {
+        abi: baycContractConfig.abi,
+        functionName: 'foo',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: An unknown error occurred while executing the contract function "foo".
+
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('function does not exist', () => {
+    expect(
+      new ContractFunctionExecutionError(new BaseError('Internal error.'), {
+        abi: baycContractConfig.abi,
+        functionName: 'foo',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: Internal error.
+
+
+      Version: viem@1.0.2]
+    `)
+  })
+})
+
+describe('ContractFunctionRevertedError', () => {
+  test('default', () => {
+    expect(
+      new ContractFunctionRevertedError({
+        abi: errorsExampleABI,
+        message: 'oh no',
+        functionName: 'totalSupply',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionRevertedError: The contract function "totalSupply" reverted with the following reason:
+      oh no
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('data: Error(string)', () => {
+    expect(
+      new ContractFunctionRevertedError({
+        abi: errorsExampleABI,
+        data: '0x08c379a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000022456e756d657261626c655365743a20696e646578206f7574206f6620626f756e6473000000000000000000000000000000000000000000000000000000000000',
+        functionName: 'totalSupply',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionRevertedError: The contract function "totalSupply" reverted with the following reason:
+      EnumerableSet: index out of bounds
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('data: Panic(uint256)', () => {
+    expect(
+      new ContractFunctionRevertedError({
+        abi: errorsExampleABI,
+        data: '0x4e487b710000000000000000000000000000000000000000000000000000000000000001',
+        functionName: 'totalSupply',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionRevertedError: The contract function "totalSupply" reverted with the following reason:
+      An \`assert\` condition failed.
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('data: custom error', () => {
+    expect(
+      new ContractFunctionRevertedError({
+        abi: errorsExampleABI,
+        data: '0xdb731cf4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000000000066275676765720000000000000000000000000000000000000000000000000000',
+        functionName: 'customComplexError',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionRevertedError: The contract function "customComplexError" reverted.
+
+      Error:     ComplexError((address sender, uint256 bar), string message, uint256 number)
+      Arguments:             ({"sender":"0x0000000000000000000000000000000000000000","bar":"69"}, bugger, 69)
+
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('data: zero data', () => {
+    expect(
+      new ContractFunctionRevertedError({
+        abi: errorsExampleABI,
+        data: '0x',
+        functionName: 'customComplexError',
+      }),
+    ).toMatchInlineSnapshot(`
+      [ContractFunctionRevertedError: The contract function "customComplexError" reverted.
+
+      Version: viem@1.0.2]
+    `)
+  })
+})

package/src/errors/contract.ts

@@ -1,125 +1,178 @@
 import { Abi } from 'abitype'
-import { Address } from '../types'
+import { panicReasons } from '../constants'
+import { Address, Hex } from '../types'
+import {
+  DecodeErrorResultResponse,
+  decodeErrorResult,
+  getAbiItem,
+  formatAbiItemWithArgs,
+  formatAbiItem,
+} from '../utils'
 import { BaseError } from './base'
 
-export class ContractMethodExecutionError extends BaseError {
-  abi?: Abi
+export class ContractFunctionExecutionError extends BaseError {
+  abi: Abi
   args?: unknown[]
+  cause: BaseError
   contractAddress?: Address
   formattedArgs?: string
-  functionName?: string
-  reason?: string
+  functionName: string
   sender?: Address
 
-  name = 'ContractMethodExecutionError'
+  name = 'ContractFunctionExecutionError'
 
   constructor(
-    message?: string,
+    cause: BaseError,
     {
       abi,
       args,
-      cause,
       contractAddress,
-      formattedArgs,
+      docsPath,
       functionName,
-      functionWithParams,
       sender,
     }: {
-      abi?: Abi
+      abi: Abi
       args?: any
-      cause?: Error
       contractAddress?: Address
-      formattedArgs?: string
-      functionName?: string
-      functionWithParams?: string
+      docsPath?: string
+      functionName: string
       sender?: Address
-    } = {},
+    },
   ) {
+    const abiItem = getAbiItem({ abi, args, name: functionName })
+    const formattedArgs = abiItem
+      ? formatAbiItemWithArgs({
+          abiItem,
+          args,
+          includeFunctionName: false,
+          includeName: false,
+        })
+      : undefined
+    const functionWithParams = abiItem
+      ? formatAbiItem(abiItem, { includeName: true })
+      : undefined
+
     super(
-      [
-        message,
-        ' ',
-        sender && `Sender:    ${sender}`,
-        contractAddress &&
-          `Contract:  ${
-            /* c8 ignore start */
-            process.env.TEST
-              ? '0x0000000000000000000000000000000000000000'
-              : contractAddress
-            /* c8 ignore end */
-          }`,
-        functionWithParams && `Function:  ${functionWithParams}`,
-        formattedArgs &&
-          `Arguments: ${[...Array(functionName?.length ?? 0).keys()]
-            .map(() => ' ')
-            .join('')}${formattedArgs}`,
-      ]
-        .filter(Boolean)
-        .join('\n'),
+      cause.shortMessage ||
+        `An unknown error occurred while executing the contract function "${functionName}".`,
       {
         cause,
+        docsPath,
+        metaMessages: [
+          ...(cause.metaMessages ? [...cause.metaMessages, ' '] : []),
+          contractAddress &&
+            `Contract:  ${
+              /* c8 ignore start */
+              process.env.TEST
+                ? '0x0000000000000000000000000000000000000000'
+                : contractAddress
+              /* c8 ignore end */
+            }`,
+          functionWithParams && `Function:  ${functionWithParams}`,
+          formattedArgs &&
+            formattedArgs !== '()' &&
+            `Arguments: ${[...Array(functionName?.length ?? 0).keys()]
+              .map(() => ' ')
+              .join('')}${formattedArgs}`,
+          sender && `Sender:    ${sender}`,
+        ].filter(Boolean) as string[],
       },
     )
-    if (message) this.reason = message
     this.abi = abi
     this.args = args
+    this.cause = cause
     this.contractAddress = contractAddress
     this.functionName = functionName
     this.sender = sender
   }
 }
 
-export class ContractMethodZeroDataError extends BaseError {
-  abi?: Abi
-  args?: unknown[]
-  contractAddress?: Address
-  functionName?: string
-  functionWithParams?: string
+export class ContractFunctionRevertedError extends BaseError {
+  name = 'ContractFunctionRevertedError'
 
-  name = 'ContractMethodZeroDataError'
+  data?: DecodeErrorResultResponse
+  reason?: string
 
   constructor({
     abi,
-    args,
-    cause,
-    contractAddress,
+    data,
     functionName,
-    functionWithParams,
-  }: {
-    abi?: Abi
-    args?: any
-    cause?: Error
-    contractAddress?: Address
-    functionName?: string
-    functionWithParams?: string
-  } = {}) {
+    message,
+  }: { abi: Abi; data?: Hex; functionName: string; message?: string }) {
+    let decodedData: DecodeErrorResultResponse | undefined = undefined
+    let metaMessages
+    let reason
+    if (data && data !== '0x') {
+      decodedData = decodeErrorResult({ abi, data })
+      const { abiItem, errorName, args: errorArgs } = decodedData
+      if (errorName === 'Error') {
+        reason = (errorArgs as [string])[0]
+      } else if (errorName === 'Panic') {
+        const [firstArg] = errorArgs as [number]
+        reason = panicReasons[firstArg as keyof typeof panicReasons]
+      } else if (errorArgs) {
+        const errorWithParams = abiItem
+          ? formatAbiItem(abiItem, { includeName: true })
+          : undefined
+        const formattedArgs = abiItem
+          ? formatAbiItemWithArgs({
+              abiItem,
+              args: errorArgs,
+              includeFunctionName: false,
+              includeName: false,
+            })
+          : undefined
+
+        metaMessages = [
+          errorWithParams ? `Error:     ${errorWithParams}` : '',
+          formattedArgs && formattedArgs !== '()'
+            ? `Arguments: ${[...Array(errorName?.length ?? 0).keys()]
+                .map(() => ' ')
+                .join('')}${formattedArgs}`
+            : '',
+        ]
+      }
+    } else if (message) reason = message
+
     super(
-      [
-        `The contract method "${functionName}" returned no data ("0x"). This could be due to any of the following:`,
-        `- The contract does not have the function "${functionName}",`,
-        '- The parameters passed to the contract function may be invalid, or',
-        '- The address is not a contract.',
-        ' ',
-        contractAddress &&
-          `Contract: ${
-            /* c8 ignore start */
-            process.env.TEST
-              ? '0x0000000000000000000000000000000000000000'
-              : contractAddress
-            /* c8 ignore end */
-          }`,
-        functionWithParams && `Function: ${functionWithParams}`,
-        functionWithParams && `        > "0x"`,
-      ]
-        .filter(Boolean)
-        .join('\n'),
+      reason
+        ? [
+            `The contract function "${functionName}" reverted with the following reason:`,
+            reason,
+          ].join('\n')
+        : `The contract function "${functionName}" reverted.`,
       {
-        cause,
+        metaMessages,
       },
     )
-    this.abi = abi
-    this.args = args
-    this.contractAddress = contractAddress
-    this.functionName = functionName
+
+    this.reason = reason
+    this.data = decodedData
+  }
+}
+
+export class ContractFunctionZeroDataError extends BaseError {
+  name = 'ContractFunctionZeroDataError'
+  constructor({ functionName }: { functionName: string }) {
+    super(`The contract function "${functionName}" returned no data ("0x").`, {
+      metaMessages: [
+        'This could be due to any of the following:',
+        `- The contract does not have the function "${functionName}",`,
+        '- The parameters passed to the contract function may be invalid, or',
+        '- The address is not a contract.',
+      ],
+    })
+  }
+}
+
+export class RawContractError extends BaseError {
+  code = 3
+  name = 'RawContractError'
+
+  data?: Hex
+
+  constructor({ data, message }: { data?: Hex; message?: string }) {
+    super(message || '')
+    this.data = data
   }
 }

package/src/errors/index.ts

@@ -25,8 +25,10 @@ export { BaseError } from './base'
 export { BlockNotFoundError } from './block'
 
 export {
-  ContractMethodExecutionError,
-  ContractMethodZeroDataError,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  RawContractError,
 } from './contract'
 
 export { SizeExceedsPaddingSizeError } from './data'

package/src/errors/request.test.ts

@@ -27,7 +27,7 @@ test('RequestError', () => {
         error: { code: 1337, message: 'error details' },
       }),
       {
-        humanMessage: 'An internal error was received.',
+        shortMessage: 'An internal error was received.',
       },
     ),
   ).toMatchInlineSnapshot(`
@@ -46,7 +46,7 @@ test('RpcRequestError', () => {
         url: 'https://viem.sh',
         error: { code: 1337, message: 'error details' },
       }),
-      { humanMessage: 'An internal error was received.' },
+      { shortMessage: 'An internal error was received.' },
     ),
   ).toMatchInlineSnapshot(`
     [RpcError: An internal error was received.
@@ -65,7 +65,7 @@ test('RpcRequestError', () => {
         error: { code: 1337, message: 'error details' },
       }),
       {
-        humanMessage: 'An internal error was received.',
+        shortMessage: 'An internal error was received.',
         docsPath: '/lol',
       },
     ),
@@ -73,7 +73,6 @@ test('RpcRequestError', () => {
     [RpcError: An internal error was received.
 
     Docs: https://viem.sh/lol
-
     Details: error details
     Version: viem@1.0.2]
   `)