viem 0.0.1-sushi.27 → 0.1.1

package/src/errors/contract.test.ts

@@ -1,233 +0,0 @@
-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,178 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

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