viem 0.3.0-main.20230411T230052 → 0.3.0-main.20230412T014743

package/src/errors/rpc.ts

@@ -1,98 +1,364 @@
-import { stringify } from '../utils/index.js'
 import { BaseError } from './base.js'
-import { getUrl } from './utils.js'
-
-export class HttpRequestError extends BaseError {
-  override name = 'HttpRequestError'
-
-  body: { [key: string]: unknown }
-  headers?: Headers
-  status?: number
-  url: string
-
-  constructor({
-    body,
-    details,
-    headers,
-    status,
-    url,
-  }: {
-    body: { [key: string]: unknown }
-    details?: string
-    headers?: Headers
-    status?: number
-    url: string
-  }) {
-    super('HTTP request failed.', {
-      details,
-      metaMessages: [
-        status && `Status: ${status}`,
-        `URL: ${getUrl(url)}`,
-        `Request body: ${stringify(body)}`,
-      ].filter(Boolean) as string[],
-    })
-    this.body = body
-    this.headers = headers
-    this.status = status
-    this.url = url
-  }
-}
-
-export class WebSocketRequestError extends BaseError {
-  override name = 'WebSocketRequestError'
-
-  constructor({
-    body,
-    details,
-    url,
-  }: {
-    body: { [key: string]: unknown }
-    details: string
-    url: string
-  }) {
-    super('WebSocket request failed.', {
-      details,
-      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
-    })
-  }
+import { RpcRequestError } from './request.js'
+
+const unknownErrorCode = -1
+
+type RpcErrorOptions = {
+  code?: number
+  docsPath?: string
+  metaMessages?: string[]
+  shortMessage: string
 }
 
+/**
+ * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors per EIP-1474.
+ *
+ * - EIP https://eips.ethereum.org/EIPS/eip-1474
+ */
 export class RpcError extends BaseError {
   code: number
 
-  override name = 'RpcError'
-
-  constructor({
-    body,
-    error,
-    url,
-  }: {
-    body: { [key: string]: unknown }
-    error: { code: number; message: string }
-    url: string
-  }) {
-    super('RPC Request failed.', {
-      cause: error as any,
-      details: error.message,
-      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
-    })
-    this.code = error.code
-  }
-}
-
-export class TimeoutError extends BaseError {
-  override name = 'TimeoutError'
-
-  constructor({
-    body,
-    url,
-  }: {
-    body: { [key: string]: unknown }
-    url: string
-  }) {
-    super('The request took too long to respond.', {
-      details: 'The request timed out.',
-      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
+  constructor(
+    cause: Error,
+    {
+      code = unknownErrorCode,
+      docsPath,
+      metaMessages,
+      shortMessage,
+    }: RpcErrorOptions,
+  ) {
+    super(shortMessage, {
+      cause,
+      docsPath,
+      metaMessages:
+        metaMessages || (cause as { metaMessages?: string[] })?.metaMessages,
+    })
+    this.name = cause.name
+    this.code = cause instanceof RpcRequestError ? cause.code : code
+  }
+}
+
+/**
+ * Error subclass implementing Ethereum Provider errors per EIP-1193.
+ *
+ * - EIP https://eips.ethereum.org/EIPS/eip-1193
+ */
+export class ProviderRpcError<T = undefined> extends RpcError {
+  override name = 'ProviderRpcError'
+
+  data?: T
+
+  constructor(
+    cause: Error,
+    options: RpcErrorOptions & {
+      data?: T
+    },
+  ) {
+    super(cause, options)
+
+    this.data = options.data
+  }
+}
+
+/**
+ * Subclass for a "Parse error" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class ParseRpcError extends RpcError {
+  override name = 'ParseRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32700,
+      shortMessage:
+        'Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.',
+    })
+  }
+}
+
+/**
+ * Subclass for a "Invalid request" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class InvalidRequestRpcError extends RpcError {
+  override name = 'InvalidRequestRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32600,
+      shortMessage: 'JSON is not a valid request object.',
+    })
+  }
+}
+
+/**
+ * Subclass for a "Method not found" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class MethodNotFoundRpcError extends RpcError {
+  override name = 'MethodNotFoundRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32601,
+      shortMessage: 'The method does not exist / is not available.',
+    })
+  }
+}
+
+/**
+ * Subclass for an "Invalid params" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class InvalidParamsRpcError extends RpcError {
+  override name = 'InvalidParamsRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32602,
+      shortMessage: [
+        'Invalid parameters were provided to the RPC method.',
+        'Double check you have provided the correct parameters.',
+      ].join('\n'),
+    })
+  }
+}
+
+/**
+ * Subclass for an "Internal error" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class InternalRpcError extends RpcError {
+  override name = 'InternalRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32603,
+      shortMessage: 'An internal error was received.',
+    })
+  }
+}
+
+/**
+ * Subclass for an "Invalid input" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class InvalidInputRpcError extends RpcError {
+  override name = 'InvalidInputRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32000,
+      shortMessage: [
+        'Missing or invalid parameters.',
+        'Double check you have provided the correct parameters.',
+      ].join('\n'),
+    })
+  }
+}
+
+/**
+ * Subclass for a "Resource not found" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class ResourceNotFoundRpcError extends RpcError {
+  override name = 'ResourceNotFoundRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32001,
+      shortMessage: 'Requested resource not found.',
+    })
+  }
+}
+
+/**
+ * Subclass for a "Resource unavailable" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class ResourceUnavailableRpcError extends RpcError {
+  override name = 'ResourceUnavailableRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32002,
+      shortMessage: 'Requested resource not available.',
+    })
+  }
+}
+
+/**
+ * Subclass for a "Transaction rejected" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class TransactionRejectedRpcError extends RpcError {
+  override name = 'TransactionRejectedRpcError'
+
+  constructor(cause: Error) {
+    super(cause, { code: -32003, shortMessage: 'Transaction creation failed.' })
+  }
+}
+
+/**
+ * Subclass for a "Method not supported" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class MethodNotSupportedRpcError extends RpcError {
+  override name = 'MethodNotSupportedRpcError'
+
+  constructor(cause: Error) {
+    super(cause, { code: -32004, shortMessage: 'Method is not implemented.' })
+  }
+}
+
+/**
+ * Subclass for a "Limit exceeded" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class LimitExceededRpcError extends RpcError {
+  override name = 'LimitExceededRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32005,
+      shortMessage: 'Request exceeds defined limit.',
+    })
+  }
+}
+
+/**
+ * Subclass for a "JSON-RPC version not supported" EIP-1474 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export class JsonRpcVersionUnsupportedError extends RpcError {
+  override name = 'JsonRpcVersionUnsupportedError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: -32006,
+      shortMessage: 'Version of JSON-RPC protocol is not supported.',
+    })
+  }
+}
+
+/**
+ * Subclass for a "User Rejected Request" EIP-1193 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+export class UserRejectedRequestError extends ProviderRpcError {
+  override name = 'UserRejectedRequestError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: 4001,
+      shortMessage: 'User rejected the request.',
+    })
+  }
+}
+
+/**
+ * Subclass for an "Unauthorized" EIP-1193 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+export class UnauthorizedProviderError extends ProviderRpcError {
+  override name = 'UnauthorizedProviderError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: 4100,
+      shortMessage:
+        'The requested method and/or account has not been authorized by the user.',
+    })
+  }
+}
+
+/**
+ * Subclass for an "Unsupported Method" EIP-1193 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+export class UnsupportedProviderMethodError extends ProviderRpcError {
+  override name = 'UnsupportedProviderMethodError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: 4200,
+      shortMessage: 'The Provider does not support the requested method.',
+    })
+  }
+}
+
+/**
+ * Subclass for an "Disconnected" EIP-1193 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+export class ProviderDisconnectedError extends ProviderRpcError {
+  override name = 'ProviderDisconnectedError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: 4900,
+      shortMessage: 'The Provider is disconnected from all chains.',
+    })
+  }
+}
+
+/**
+ * Subclass for an "Chain Disconnected" EIP-1193 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+export class ChainDisconnectedError extends ProviderRpcError {
+  override name = 'ChainDisconnectedError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: 4901,
+      shortMessage: 'The Provider is not connected to the requested chain.',
+    })
+  }
+}
+
+/**
+ * Subclass for an "Switch Chain" EIP-1193 error.
+ *
+ * EIP https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+export class SwitchChainError extends ProviderRpcError {
+  override name = 'SwitchChainError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      code: 4902,
+      shortMessage: 'An error occurred when attempting to switch chain.',
+    })
+  }
+}
+
+/**
+ * Subclass for an unknown RPC error.
+ */
+export class UnknownRpcError extends RpcError {
+  override name = 'UnknownRpcError'
+
+  constructor(cause: Error) {
+    super(cause, {
+      shortMessage: 'An unknown RPC error occurred.',
     })
   }
 }

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '0.3.0-main.20230411T230052'
+export const version = '0.3.0-main.20230412T014743'

package/src/index.ts

@@ -180,6 +180,7 @@ export {
   BaseError,
   BlockNotFoundError,
   CallExecutionError,
+  ChainDisconnectedError,
   ChainDoesNotSupportContract,
   ContractFunctionExecutionError,
   ContractFunctionRevertedError,
@@ -220,8 +221,9 @@ export {
   NonceTooLowError,
   OffsetOutOfBoundsError,
   ParseRpcError,
+  ProviderDisconnectedError,
+  ProviderRpcError,
   RawContractError,
-  RequestError,
   ResourceNotFoundRpcError,
   ResourceUnavailableRpcError,
   RpcError,
@@ -235,7 +237,9 @@ export {
   TransactionReceiptNotFoundError,
   TransactionRejectedRpcError,
   SwitchChainError,
+  UnauthorizedProviderError,
   UnknownRpcError,
+  UnsupportedProviderMethodError,
   UrlRequiredError,
   UserRejectedRequestError,
   WaitForTransactionReceiptTimeoutError,

package/src/types/filter.ts

@@ -1,6 +1,7 @@
 import type { Abi } from 'abitype'
 import type { MaybeExtractEventArgsFromAbi } from './contract.js'
 import type { Hex } from './misc.js'
+import type { Requests } from './eip1193.js'
 
 export type FilterType = 'transaction' | 'block' | 'event'
 
@@ -13,6 +14,8 @@ export type Filter<
     | undefined = MaybeExtractEventArgsFromAbi<TAbi, TEventName>,
 > = {
   id: Hex
+  // TODO: Narrow `request` to filter-based methods (ie. `eth_getFilterLogs`, etc).
+  request: Requests['request']
   type: TFilterType
 } & (TFilterType extends 'event'
   ? TAbi extends Abi

package/src/utils/buildRequest.ts

@@ -18,10 +18,23 @@ import {
   UnknownRpcError,
   UserRejectedRequestError,
 } from '../errors/index.js'
+import {
+  ChainDisconnectedError,
+  ProviderDisconnectedError,
+  UnauthorizedProviderError,
+  UnsupportedProviderMethodError,
+} from '../errors/rpc.js'
 import { withRetry } from './promise/index.js'
 
 export const isDeterministicError = (error: Error) => {
-  if ('code' in error) return error.code !== -32603 && error.code !== -32005
+  if ('code' in error)
+    return (
+      error.code !== -1 &&
+      error.code !== -32004 &&
+      error.code !== -32005 &&
+      error.code !== -32042 &&
+      error.code !== -32603
+    )
   if (error instanceof HttpRequestError && error.status)
     return (
       error.status !== 408 &&
@@ -66,7 +79,12 @@ export function buildRequest<TRequest extends (args: any) => Promise<any>>(
           if (err.code === -32004) throw new MethodNotSupportedRpcError(err)
           if (err.code === -32005) throw new LimitExceededRpcError(err)
           if (err.code === -32006) throw new JsonRpcVersionUnsupportedError(err)
+          if (err.code === -32042) throw new MethodNotSupportedRpcError(err)
           if (err.code === 4001) throw new UserRejectedRequestError(err)
+          if (err.code === 4100) throw new UnauthorizedProviderError(err)
+          if (err.code === 4200) throw new UnsupportedProviderMethodError(err)
+          if (err.code === 4900) throw new ProviderDisconnectedError(err)
+          if (err.code === 4901) throw new ChainDisconnectedError(err)
           if (err.code === 4902) throw new SwitchChainError(err)
           if (err_ instanceof BaseError) throw err_
           throw new UnknownRpcError(err as Error)

package/src/utils/errors/getNodeError.ts

@@ -1,5 +1,5 @@
 import type { SendTransactionParameters } from '../../actions/index.js'
-import type { BaseError } from '../../errors/index.js'
+import { RpcRequestError, type BaseError } from '../../errors/index.js'
 import {
   ExecutionRevertedError,
   FeeCapTooHighError,
@@ -11,7 +11,6 @@ import {
   NonceMaxValueError,
   NonceTooHighError,
   NonceTooLowError,
-  RpcError,
   TipAboveFeeCapError,
   TransactionRejectedRpcError,
   TransactionTypeNotSupportedError,
@@ -22,7 +21,7 @@ export function containsNodeError(err: BaseError) {
   return (
     err instanceof TransactionRejectedRpcError ||
     err instanceof InvalidInputRpcError ||
-    (err instanceof RpcError && err.code === ExecutionRevertedError.code)
+    (err instanceof RpcRequestError && err.code === ExecutionRevertedError.code)
   )
 }
 

package/src/utils/filters/createFilterRequestScope.ts

@@ -0,0 +1,42 @@
+import type { Chain } from '../../chains.js'
+import type { PublicClient, Transport } from '../../clients/index.js'
+import type { OnResponseFn } from '../../clients/transports/fallback.js'
+import type { Requests } from '../../types/eip1193.js'
+import type { Hex } from '../../types/index.js'
+
+type CreateFilterRequestScopeParameters = {
+  method:
+    | 'eth_newFilter'
+    | 'eth_newPendingTransactionFilter'
+    | 'eth_newBlockFilter'
+}
+// TODO: Narrow `request` to filter-based methods (ie. `eth_getFilterLogs`, etc).
+type CreateFilterRequestScopeReturnType = (id: Hex) => Requests['request']
+
+/**
+ * Scopes `request` to the filter ID. If the client is a fallback, it will
+ * listen for responses and scope the child transport `request` function
+ * to the successful filter ID.
+ */
+export function createFilterRequestScope<TChain extends Chain | undefined>(
+  client: PublicClient<Transport, TChain>,
+  { method }: CreateFilterRequestScopeParameters,
+): CreateFilterRequestScopeReturnType {
+  const requestMap: Record<Hex, PublicClient<Transport, TChain>['request']> = {}
+
+  if (client.transport.type === 'fallback')
+    client.transport.onResponse?.(
+      ({
+        method: method_,
+        response: id,
+        status,
+        transport,
+      }: Parameters<OnResponseFn>[0]) => {
+        if (status === 'success' && method === method_)
+          requestMap[id as Hex] = transport.request
+      },
+    )
+
+  return ((id) =>
+    requestMap[id] || client.request) as CreateFilterRequestScopeReturnType
+}

package/src/utils/rpc.ts

@@ -2,7 +2,7 @@ import WebSocket from 'isomorphic-ws'
 import type { MessageEvent } from 'isomorphic-ws'
 import {
   HttpRequestError,
-  RpcError,
+  RpcRequestError,
   TimeoutError,
   WebSocketRequestError,
 } from '../errors/index.js'
@@ -107,12 +107,12 @@ async function http(
     }
 
     if (data.error) {
-      throw new RpcError({ body, error: data.error, url })
+      throw new RpcRequestError({ body, error: data.error, url })
     }
     return data as RpcResponse
   } catch (err) {
     if (err instanceof HttpRequestError) throw err
-    if (err instanceof RpcError) throw err
+    if (err instanceof RpcRequestError) throw err
     if (err instanceof TimeoutError) throw err
     throw new HttpRequestError({
       body,
@@ -224,7 +224,9 @@ function webSocket(
     if (typeof message.id === 'number' && id_ !== message.id) return
 
     if (message.error) {
-      onError?.(new RpcError({ body, error: message.error, url: socket.url }))
+      onError?.(
+        new RpcRequestError({ body, error: message.error, url: socket.url }),
+      )
     } else {
       onData?.(message)
     }