viem 0.3.0-tsc-nodenext-2.20230407T050527 → 0.3.1

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 {
-  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 {
-  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
 
-  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 {
-  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/transaction.ts

@@ -26,7 +26,7 @@ export function prettyPrint(
 }
 
 export class FeeConflictError extends BaseError {
-  name = 'FeeConflictError'
+  override name = 'FeeConflictError'
   constructor() {
     super(
       [
@@ -38,7 +38,7 @@ export class FeeConflictError extends BaseError {
 }
 
 export class InvalidLegacyVError extends BaseError {
-  name = 'InvalidLegacyVError'
+  override name = 'InvalidLegacyVError'
 
   constructor({ v }: { v: bigint }) {
     super(`Invalid \`v\` value "${v}". Expected 27 or 28.`)
@@ -46,7 +46,7 @@ export class InvalidLegacyVError extends BaseError {
 }
 
 export class InvalidSerializableTransactionError extends BaseError {
-  name = 'InvalidSerializableTransactionError'
+  override name = 'InvalidSerializableTransactionError'
 
   constructor({ transaction }: { transaction: Record<string, unknown> }) {
     super('Cannot infer a transaction type from provided transaction.', {
@@ -67,7 +67,7 @@ export class InvalidSerializableTransactionError extends BaseError {
 }
 
 export class InvalidSerializedTransactionTypeError extends BaseError {
-  name = 'InvalidSerializedTransactionType'
+  override name = 'InvalidSerializedTransactionType'
 
   serializedType: Hex
 
@@ -79,7 +79,7 @@ export class InvalidSerializedTransactionTypeError extends BaseError {
 }
 
 export class InvalidSerializedTransactionError extends BaseError {
-  name = 'InvalidSerializedTransactionError'
+  override name = 'InvalidSerializedTransactionError'
 
   serializedTransaction: Hex
   type: TransactionType
@@ -109,7 +109,7 @@ export class InvalidSerializedTransactionError extends BaseError {
 }
 
 export class InvalidStorageKeySizeError extends BaseError {
-  name = 'InvalidStorageKeySizeError'
+  override name = 'InvalidStorageKeySizeError'
 
   constructor({ storageKey }: { storageKey: Hex }) {
     super(
@@ -121,9 +121,9 @@ export class InvalidStorageKeySizeError extends BaseError {
 }
 
 export class TransactionExecutionError extends BaseError {
-  cause: BaseError
+  override cause: BaseError
 
-  name = 'TransactionExecutionError'
+  override name = 'TransactionExecutionError'
 
   constructor(
     cause: BaseError,
@@ -179,7 +179,7 @@ export class TransactionExecutionError extends BaseError {
 }
 
 export class TransactionNotFoundError extends BaseError {
-  name = 'TransactionNotFoundError'
+  override name = 'TransactionNotFoundError'
   constructor({
     blockHash,
     blockNumber,
@@ -206,7 +206,7 @@ export class TransactionNotFoundError extends BaseError {
 }
 
 export class TransactionReceiptNotFoundError extends BaseError {
-  name = 'TransactionReceiptNotFoundError'
+  override name = 'TransactionReceiptNotFoundError'
   constructor({ hash }: { hash: Hash }) {
     super(
       `Transaction receipt with hash "${hash}" could not be found. The Transaction may not be processed on a block yet.`,
@@ -215,7 +215,7 @@ export class TransactionReceiptNotFoundError extends BaseError {
 }
 
 export class WaitForTransactionReceiptTimeoutError extends BaseError {
-  name = 'WaitForTransactionReceiptTimeoutError'
+  override name = 'WaitForTransactionReceiptTimeoutError'
   constructor({ hash }: { hash: Hash }) {
     super(
       `Timed out while waiting for transaction with hash "${hash}" to be confirmed.`,

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '0.3.0-tsc-nodenext-2.20230407T050527'
+export const version = '0.3.1'

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,
@@ -260,6 +264,7 @@ export type {
   ContractFunctionConfig,
   ContractFunctionResult,
   CustomSource,
+  EIP1193Provider,
   FeeHistory,
   FeeValues,
   FeeValuesEIP1559,
@@ -367,6 +372,8 @@ export type {
   RecoverAddressReturnType,
   RecoverMessageAddressParameters,
   RecoverMessageAddressReturnType,
+  RecoverPublicKeyParameters,
+  RecoverPublicKeyReturnType,
   RecoverTypedDataAddressParameters,
   RecoverTypedDataAddressReturnType,
   ToRlpReturnType,
@@ -458,6 +465,7 @@ export {
   prepareRequest,
   recoverAddress,
   recoverMessageAddress,
+  recoverPublicKey,
   recoverTypedDataAddress,
   serializeTransaction,
   size,

package/src/types/eip1193.ts

@@ -14,6 +14,11 @@ import type {
   RpcUncle as Uncle,
 } from './rpc.js'
 
+//////////////////////////////////////////////////
+// Provider
+
+export type EIP1193Provider = Requests & Events
+
 //////////////////////////////////////////////////
 // Errors
 
@@ -985,7 +990,7 @@ export type WalletRequests = {
      * @description Requests that the user provides an Ethereum address to be identified by. Typically causes a browser extension popup to appear.
      * @link https://eips.ethereum.org/EIPS/eip-1102
      * @example
-     * provider.request({ method: 'eth_requestAccounts' }] })
+     * provider.request({ method: 'eth_requestAccounts' })
      * // => ['0x...', '0x...']
      * */
     method: 'eth_requestAccounts'

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/types/index.ts

@@ -44,6 +44,8 @@ export type {
   MaybeExtractEventArgsFromAbi,
 } from './contract.js'
 
+export type { EIP1193Provider } from './eip1193.js'
+
 export type { AssetGateway, AssetGatewayUrls } from './ens.js'
 
 export type {

package/src/types/window.ts

@@ -1,9 +1,7 @@
-import type { Events, Requests } from './eip1193.js'
-
-type WindowProvider = Requests & Events
+import type { EIP1193Provider } from './eip1193.js'
 
 declare global {
   interface Window {
-    ethereum?: WindowProvider
+    ethereum?: EIP1193Provider
   }
 }

package/src/utils/abi/getAbiItem.ts

@@ -23,22 +23,23 @@ export type GetAbiItemReturnType<
 export function getAbiItem<
   TAbi extends Abi | readonly unknown[],
   TItemName extends string,
-  TReturnType = GetAbiItemReturnType<TAbi, TItemName>,
 >({
   abi,
   args = [],
   name,
-}: GetAbiItemParameters<TAbi, TItemName>): TReturnType {
+}: GetAbiItemParameters<TAbi, TItemName>): GetAbiItemReturnType<
+  TAbi,
+  TItemName
+> {
   const abiItems = (abi as Abi).filter((x) => 'name' in x && x.name === name)
 
-  if (abiItems.length === 0) return undefined as unknown as TReturnType
-  if (abiItems.length === 1) return abiItems[0] as unknown as TReturnType
+  if (abiItems.length === 0) return undefined as any
+  if (abiItems.length === 1) return abiItems[0] as any
 
   for (const abiItem of abiItems) {
     if (!('inputs' in abiItem)) continue
     if (!args || args.length === 0) {
-      if (!abiItem.inputs || abiItem.inputs.length === 0)
-        return abiItem as unknown as TReturnType
+      if (!abiItem.inputs || abiItem.inputs.length === 0) return abiItem as any
       continue
     }
     if (!abiItem.inputs) continue
@@ -48,9 +49,9 @@ export function getAbiItem<
       if (!abiParameter) return false
       return isArgOfType(arg, abiParameter as AbiParameter)
     })
-    if (matched) return abiItem as unknown as TReturnType
+    if (matched) return abiItem as any
   }
-  return abiItems[0] as unknown as TReturnType
+  return abiItems[0] as any
 }
 
 export function isArgOfType(arg: unknown, abiParameter: AbiParameter): boolean {