viem 0.0.1-alpha.14 → 0.0.1-alpha.16

package/src/errors/contract.ts

@@ -0,0 +1,125 @@
+import { Abi } from 'abitype'
+import { Address } from '../types'
+import { BaseError } from './base'
+
+export class ContractMethodExecutionError extends BaseError {
+  abi?: Abi
+  args?: unknown[]
+  contractAddress?: Address
+  formattedArgs?: string
+  functionName?: string
+  reason?: string
+  sender?: Address
+
+  name = 'ContractMethodExecutionError'
+
+  constructor(
+    message?: string,
+    {
+      abi,
+      args,
+      cause,
+      contractAddress,
+      formattedArgs,
+      functionName,
+      functionWithParams,
+      sender,
+    }: {
+      abi?: Abi
+      args?: any
+      cause?: Error
+      contractAddress?: Address
+      formattedArgs?: string
+      functionName?: string
+      functionWithParams?: string
+      sender?: Address
+    } = {},
+  ) {
+    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,
+      },
+    )
+    if (message) this.reason = message
+    this.abi = abi
+    this.args = args
+    this.contractAddress = contractAddress
+    this.functionName = functionName
+    this.sender = sender
+  }
+}
+
+export class ContractMethodZeroDataError extends BaseError {
+  abi?: Abi
+  args?: unknown[]
+  contractAddress?: Address
+  functionName?: string
+  functionWithParams?: string
+
+  name = 'ContractMethodZeroDataError'
+
+  constructor({
+    abi,
+    args,
+    cause,
+    contractAddress,
+    functionName,
+    functionWithParams,
+  }: {
+    abi?: Abi
+    args?: any
+    cause?: Error
+    contractAddress?: Address
+    functionName?: string
+    functionWithParams?: string
+  } = {}) {
+    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'),
+      {
+        cause,
+      },
+    )
+    this.abi = abi
+    this.args = args
+    this.contractAddress = contractAddress
+    this.functionName = functionName
+  }
+}

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,77 @@
+export {
+  AbiConstructorNotFoundError,
+  AbiConstructorParamsNotFoundError,
+  AbiDecodingDataSizeInvalidError,
+  AbiDecodingZeroDataError,
+  AbiEncodingArrayLengthMismatchError,
+  AbiEncodingLengthMismatchError,
+  AbiErrorInputsNotFoundError,
+  AbiErrorNotFoundError,
+  AbiErrorSignatureNotFoundError,
+  AbiEventNotFoundError,
+  AbiFunctionNotFoundError,
+  AbiFunctionOutputsNotFoundError,
+  AbiFunctionSignatureNotFoundError,
+  InvalidAbiDecodingTypeError,
+  InvalidAbiEncodingTypeError,
+  InvalidArrayError,
+  InvalidDefinitionTypeError,
+} from './abi'
+
+export { InvalidAddressError } from './address'
+
+export { BaseError } from './base'
+
+export { BlockNotFoundError } from './block'
+
+export {
+  ContractMethodExecutionError,
+  ContractMethodZeroDataError,
+} 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.`)
+  }
+}

package/src/errors/request.test.ts

@@ -0,0 +1,331 @@
+import { expect, test } from 'vitest'
+import {
+  InternalRpcError,
+  InvalidInputRpcError,
+  InvalidParamsRpcError,
+  InvalidRequestRpcError,
+  JsonRpcVersionUnsupportedError,
+  LimitExceededRpcError,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+  ParseRpcError,
+  RequestError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  RpcRequestError,
+  TransactionRejectedRpcError,
+  UnknownRpcError,
+} from './request'
+import { RpcError } from './rpc'
+
+test('RequestError', () => {
+  expect(
+    new RequestError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: { code: 1337, message: 'error details' },
+      }),
+      {
+        humanMessage: 'An internal error was received.',
+      },
+    ),
+  ).toMatchInlineSnapshot(`
+    [RpcError: An internal error was received.
+
+    Details: error details
+    Version: viem@1.0.2]
+  `)
+})
+
+test('RpcRequestError', () => {
+  expect(
+    new RpcRequestError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: { code: 1337, message: 'error details' },
+      }),
+      { humanMessage: 'An internal error was received.' },
+    ),
+  ).toMatchInlineSnapshot(`
+    [RpcError: An internal error was received.
+
+    Details: error details
+    Version: viem@1.0.2]
+  `)
+})
+
+test('RpcRequestError', () => {
+  expect(
+    new RpcRequestError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: { code: 1337, message: 'error details' },
+      }),
+      {
+        humanMessage: 'An internal error was received.',
+        docsPath: '/lol',
+      },
+    ),
+  ).toMatchInlineSnapshot(`
+    [RpcError: An internal error was received.
+
+    Docs: https://viem.sh/lol
+
+    Details: error details
+    Version: viem@1.0.2]
+  `)
+})
+
+test('ParseRpcError', () => {
+  expect(
+    new ParseRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32700,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [ParseRpcError: Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('InvalidRequestRpcError', () => {
+  expect(
+    new InvalidRequestRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32600,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [InvalidRequestRpcError: JSON is not a valid request object.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('MethodNotFoundRpcError', () => {
+  expect(
+    new MethodNotFoundRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32601,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [MethodNotFoundRpcError: The method does not exist / is not available.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('InvalidParamsRpcError', () => {
+  expect(
+    new InvalidParamsRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32602,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [InvalidParamsRpcError: Invalid parameters were provided to the RPC method.
+    Double check you have provided the correct parameters.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('InternalRpcError', () => {
+  expect(
+    new InternalRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32603,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [InternalRpcError: An internal error was received.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('InvalidInputRpcError', () => {
+  expect(
+    new InvalidInputRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32000,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [InvalidInputRpcError: Missing or invalid parameters.
+    Double check you have provided the correct parameters.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('ResourceNotFoundRpcError', () => {
+  expect(
+    new ResourceNotFoundRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32001,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [ResourceNotFoundRpcError: Requested resource not found.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('ResourceUnavailableRpcError', () => {
+  expect(
+    new ResourceUnavailableRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32002,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [ResourceUnavailableRpcError: Requested resource not available.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('TransactionRejectedRpcError', () => {
+  expect(
+    new TransactionRejectedRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32003,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [TransactionRejectedRpcError: Transaction creation failed.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('MethodNotSupportedRpcError', () => {
+  expect(
+    new MethodNotSupportedRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32004,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [MethodNotSupportedRpcError: Method is not implemented.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('LimitExceededRpcError', () => {
+  expect(
+    new LimitExceededRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32005,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [LimitExceededRpcError: Request exceeds defined limit.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('JsonRpcVersionUnsupportedError', () => {
+  expect(
+    new JsonRpcVersionUnsupportedError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32006,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [JsonRpcVersionUnsupportedError: Version of JSON-RPC protocol is not supported.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('UnknownRpcError', async () => {
+  expect(new UnknownRpcError(new Error('oh no'))).toMatchInlineSnapshot(`
+    [UnknownRpcError: An unknown RPC error occurred.
+
+    Details: oh no
+    Version: viem@1.0.2]
+  `)
+})