viem 0.0.1-alpha.20 → 0.0.1-alpha.22

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]
   `)

package/src/errors/request.ts

@@ -4,9 +4,9 @@ import { RpcError } from './rpc'
 export class RequestError extends BaseError {
   constructor(
     err: Error,
-    { docsPath, humanMessage }: { docsPath?: string; humanMessage: string },
+    { docsPath, shortMessage }: { docsPath?: string; shortMessage: string },
   ) {
-    super(humanMessage, {
+    super(shortMessage, {
       cause: err,
       docsPath,
     })
@@ -19,9 +19,9 @@ export class RpcRequestError extends RequestError {
 
   constructor(
     err: RpcError,
-    { docsPath, humanMessage }: { docsPath?: string; humanMessage: string },
+    { docsPath, shortMessage }: { docsPath?: string; shortMessage: string },
   ) {
-    super(err, { docsPath, humanMessage })
+    super(err, { docsPath, shortMessage })
     this.code = err.code
     this.name = err.name
   }
@@ -33,7 +33,7 @@ export class ParseRpcError extends RpcRequestError {
 
   constructor(err: RpcError) {
     super(err, {
-      humanMessage:
+      shortMessage:
         'Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.',
     })
   }
@@ -44,7 +44,7 @@ export class InvalidRequestRpcError extends RpcRequestError {
   code = -32600
 
   constructor(err: RpcError) {
-    super(err, { humanMessage: 'JSON is not a valid request object.' })
+    super(err, { shortMessage: 'JSON is not a valid request object.' })
   }
 }
 
@@ -54,7 +54,7 @@ export class MethodNotFoundRpcError extends RpcRequestError {
 
   constructor(err: RpcError) {
     super(err, {
-      humanMessage: 'The method does not exist / is not available.',
+      shortMessage: 'The method does not exist / is not available.',
     })
   }
 }
@@ -65,7 +65,7 @@ export class InvalidParamsRpcError extends RpcRequestError {
 
   constructor(err: RpcError) {
     super(err, {
-      humanMessage: [
+      shortMessage: [
         'Invalid parameters were provided to the RPC method.',
         'Double check you have provided the correct parameters.',
       ].join('\n'),
@@ -78,7 +78,7 @@ export class InternalRpcError extends RpcRequestError {
   code = -32603
 
   constructor(err: RpcError) {
-    super(err, { humanMessage: 'An internal error was received.' })
+    super(err, { shortMessage: 'An internal error was received.' })
   }
 }
 
@@ -88,7 +88,7 @@ export class InvalidInputRpcError extends RpcRequestError {
 
   constructor(err: RpcError) {
     super(err, {
-      humanMessage: [
+      shortMessage: [
         'Missing or invalid parameters.',
         'Double check you have provided the correct parameters.',
       ].join('\n'),
@@ -101,7 +101,7 @@ export class ResourceNotFoundRpcError extends RpcRequestError {
   code = -32001
 
   constructor(err: RpcError) {
-    super(err, { humanMessage: 'Requested resource not found.' })
+    super(err, { shortMessage: 'Requested resource not found.' })
   }
 }
 
@@ -110,7 +110,7 @@ export class ResourceUnavailableRpcError extends RpcRequestError {
   code = -32002
 
   constructor(err: RpcError) {
-    super(err, { humanMessage: 'Requested resource not available.' })
+    super(err, { shortMessage: 'Requested resource not available.' })
   }
 }
 
@@ -119,7 +119,7 @@ export class TransactionRejectedRpcError extends RpcRequestError {
   code = -32003
 
   constructor(err: RpcError) {
-    super(err, { humanMessage: 'Transaction creation failed.' })
+    super(err, { shortMessage: 'Transaction creation failed.' })
   }
 }
 
@@ -128,7 +128,7 @@ export class MethodNotSupportedRpcError extends RpcRequestError {
   code = -32004
 
   constructor(err: RpcError) {
-    super(err, { humanMessage: 'Method is not implemented.' })
+    super(err, { shortMessage: 'Method is not implemented.' })
   }
 }
 
@@ -137,7 +137,7 @@ export class LimitExceededRpcError extends RpcRequestError {
   code = -32005
 
   constructor(err: RpcError) {
-    super(err, { humanMessage: 'Request exceeds defined limit.' })
+    super(err, { shortMessage: 'Request exceeds defined limit.' })
   }
 }
 
@@ -147,7 +147,7 @@ export class JsonRpcVersionUnsupportedError extends RpcRequestError {
 
   constructor(err: RpcError) {
     super(err, {
-      humanMessage: 'Version of JSON-RPC protocol is not supported.',
+      shortMessage: 'Version of JSON-RPC protocol is not supported.',
     })
   }
 }
@@ -157,7 +157,7 @@ export class UnknownRpcError extends RequestError {
 
   constructor(err: Error) {
     super(err, {
-      humanMessage: 'An unknown RPC error occurred.',
+      shortMessage: 'An unknown RPC error occurred.',
     })
   }
 }

package/src/errors/rpc.test.ts

@@ -21,8 +21,7 @@ test('RpcError', () => {
     Request body: {"foo":"bar"}
 
     Details: Error
-    Version: viem@1.0.2
-    Internal Error: {"code":420,"message":"Error"}]
+    Version: viem@1.0.2]
   `)
 })