viem 0.0.1-cjs.10 → 0.0.1-sushi.26

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

@@ -0,0 +1,178 @@
+import { Abi } from 'abitype'
+import { panicReasons } from '../constants'
+import { Address, Chain, Hex } from '../types'
+import {
+  DecodeErrorResultResponse,
+  decodeErrorResult,
+  getAbiItem,
+  formatAbiItem,
+  formatAbiItemWithArgs,
+} from '../utils'
+import { BaseError } from './base'
+
+export class ContractFunctionExecutionError extends BaseError {
+  abi: Abi
+  args?: unknown[]
+  cause: BaseError
+  contractAddress?: Address
+  formattedArgs?: string
+  functionName: string
+  sender?: Address
+
+  name = 'ContractFunctionExecutionError'
+
+  constructor(
+    cause: BaseError,
+    {
+      abi,
+      args,
+      contractAddress,
+      docsPath,
+      functionName,
+      sender,
+    }: {
+      abi: Abi
+      args?: any
+      contractAddress?: Address
+      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(
+      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[],
+      },
+    )
+    this.abi = abi
+    this.args = args
+    this.cause = cause
+    this.contractAddress = contractAddress
+    this.functionName = functionName
+    this.sender = sender
+  }
+}
+
+export class ContractFunctionRevertedError extends BaseError {
+  name = 'ContractFunctionRevertedError'
+
+  data?: DecodeErrorResultResponse
+  reason?: string
+
+  constructor({
+    abi,
+    data,
+    functionName,
+    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(
+      reason
+        ? [
+            `The contract function "${functionName}" reverted with the following reason:`,
+            reason,
+          ].join('\n')
+        : `The contract function "${functionName}" reverted.`,
+      {
+        metaMessages,
+      },
+    )
+
+    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/data.ts

@@ -0,0 +1,20 @@
+import { BaseError } from './base'
+
+export class SizeExceedsPaddingSizeError extends BaseError {
+  name = 'SizeExceedsPaddingSizeError'
+  constructor({
+    size,
+    targetSize,
+    type,
+  }: {
+    size: number
+    targetSize: number
+    type: 'hex' | 'bytes'
+  }) {
+    super(
+      `${type.charAt(0).toUpperCase()}${type
+        .slice(1)
+        .toLowerCase()} size (${size}) exceeds padding size (${targetSize}).`,
+    )
+  }
+}

package/src/errors/encoding.ts

@@ -0,0 +1,60 @@
+import { ByteArray, Hex } from '../types'
+import { BaseError } from './base'
+
+export class DataLengthTooLongError extends BaseError {
+  name = 'DataLengthTooLongError'
+  constructor({ consumed, length }: { consumed: number; length: number }) {
+    super(
+      `Consumed bytes (${consumed}) is shorter than data length (${
+        length - 1
+      }).`,
+    )
+  }
+}
+
+export class DataLengthTooShortError extends BaseError {
+  name = 'DataLengthTooShortError'
+  constructor({ length, dataLength }: { length: number; dataLength: number }) {
+    super(
+      `Data length (${dataLength - 1}) is shorter than prefix length (${
+        length - 1
+      }).`,
+    )
+  }
+}
+
+export class InvalidBytesBooleanError extends BaseError {
+  name = 'InvalidBytesBooleanError'
+  constructor(bytes: ByteArray) {
+    super(
+      `Bytes value "${bytes}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`,
+    )
+  }
+}
+
+export class InvalidHexBooleanError extends BaseError {
+  name = 'InvalidHexBooleanError'
+  constructor(hex: Hex) {
+    super(
+      `Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`,
+    )
+  }
+}
+
+export class InvalidHexValueError extends BaseError {
+  name = 'InvalidHexValueError'
+  constructor(value: Hex) {
+    super(
+      `Hex value "${value}" is an odd length (${value.length}). It must be an even length.`,
+    )
+  }
+}
+
+export class OffsetOutOfBoundsError extends BaseError {
+  name = 'OffsetOutOfBoundsError'
+  constructor({ nextOffset, offset }: { nextOffset: number; offset: number }) {
+    super(
+      `Next offset (${nextOffset}) is greater than previous offset + consumed bytes (${offset})`,
+    )
+  }
+}

package/src/errors/index.ts

@@ -0,0 +1,82 @@
+export {
+  AbiConstructorNotFoundError,
+  AbiConstructorParamsNotFoundError,
+  AbiDecodingDataSizeInvalidError,
+  AbiDecodingZeroDataError,
+  AbiEncodingArrayLengthMismatchError,
+  AbiEncodingLengthMismatchError,
+  AbiErrorInputsNotFoundError,
+  AbiErrorNotFoundError,
+  AbiErrorSignatureNotFoundError,
+  AbiEventSignatureNotFoundError,
+  AbiEventNotFoundError,
+  AbiFunctionNotFoundError,
+  AbiFunctionOutputsNotFoundError,
+  AbiFunctionSignatureNotFoundError,
+  InvalidAbiDecodingTypeError,
+  InvalidAbiEncodingTypeError,
+  InvalidArrayError,
+  InvalidDefinitionTypeError,
+} from './abi'
+
+export { InvalidAddressError } from './address'
+
+export { BaseError } from './base'
+
+export { BlockNotFoundError } from './block'
+
+export { ChainDoesNotSupportContract } from './chain'
+
+export {
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  RawContractError,
+} from './contract'
+
+export { SizeExceedsPaddingSizeError } from './data'
+
+export {
+  DataLengthTooLongError,
+  DataLengthTooShortError,
+  InvalidBytesBooleanError,
+  InvalidHexBooleanError,
+  InvalidHexValueError,
+  OffsetOutOfBoundsError,
+} from './encoding'
+
+export { FilterTypeNotSupportedError } from './log'
+
+export {
+  InternalRpcError,
+  InvalidInputRpcError,
+  InvalidParamsRpcError,
+  InvalidRequestRpcError,
+  JsonRpcVersionUnsupportedError,
+  LimitExceededRpcError,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+  ParseRpcError,
+  RequestError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  RpcRequestError,
+  TransactionRejectedRpcError,
+  UnknownRpcError,
+} from './request'
+
+export {
+  HttpRequestError,
+  RpcError,
+  TimeoutError,
+  WebSocketRequestError,
+} from './rpc'
+
+export {
+  InvalidGasArgumentsError,
+  TransactionNotFoundError,
+  TransactionReceiptNotFoundError,
+  WaitForTransactionReceiptTimeoutError,
+} from './transaction'
+
+export { UrlRequiredError } from './transport'

package/src/errors/log.ts

@@ -0,0 +1,8 @@
+import { BaseError } from './base'
+
+export class FilterTypeNotSupportedError extends BaseError {
+  name = 'FilterTypeNotSupportedError'
+  constructor(type: string) {
+    super(`Filter type "${type}" is not supported.`)
+  }
+}