Documentation

Documentation »API »Utilities »Errors

Errors

About Errors.

<src>CallExceptionAction⇒ "call" | "estimateGas" | "getTransactionResult" | "unknown"

The action that resulted in the error.

<src>CallExceptionTransaction⇒ { data: string , from?: string , to: null | string }

The related transaction that caused the error.

<src>CodedEthersError⇒ TODO(A1Bconditional(@TODO-000))

A conditional type that transforms the ErrorCode T into its EthersError type.

All errors emitted by ethers have an ErrorCode to help identify and coalesce errors to simplfy programatic analysis.

_property: "UNKNOWN_ERROR" This is a general puspose fallback when no other error makes sense or the error wasn't expected

_property: "NOT_IMPLEMENTED"

<src>ErrorInfo⇒ Omit< T, "code" | "name" | "message" >

<src>assert(check: unknown, message: string, code: K, info?: ErrorInfo < T >)⇒ boolean

Throws an EthersError with message, code and additional error info when check is falsish..

<src>assertArgument(check: unknown, message: string, name: string, value: unknown)⇒ boolean

A simple helper to simply ensuring provided arguments match expected constraints, throwing if not.

In TypeScript environments, the check has been asserted true, so any further code does not need additional compile-time checks.

<src>assertArgumentCount(count: number, expectedCount: number, message?: string)⇒ void

<src>assertNormalize(form: string)⇒ void

Throws if the normalization form is not supported.

<src>assertPrivate(givenGuard: any, guard: any, className?: string)⇒ void

Many classes use file-scoped values to guard the constructor, making it effectively private. This facilitates that pattern by ensuring the givenGaurd matches the file-scoped guard, throwing if not, indicating the className if provided.

<src>isCallException(error: any)⇒ boolean

Returns true if error is a CALL_EXCEPTION.

<src>isError(error: any, code: K)⇒ boolean

Returns true if the error matches an error thrown by ethers that matches the error code.

In TypeScript envornoments, this can be used to check that error matches an EthersError type, which means the expected properties will be set.

try {
  // code....
} catch (e) {
  if (isError(e, "CALL_EXCEPTION")) {
      // The Type Guard has validated this object
      console.log(e.data);
  }
}

<src>makeError(message: string, code: K, info?: ErrorInfo < T >)⇒ T

Returns a new Error configured to the format ethers emits errors, with the message, [[api:ErrorCode]] code and additioanl properties for the corresponding EthersError.

Each error in ethers includes the version of ethers, a machine-readable ErrorCode, and depneding on code, additional required properties. The error message will also include the meeage, ethers version, code and all aditional properties, serialized.

<src>interface ActionRejectedError

inherits fromEthersError

This Error indicates a request was rejected by the user.

In most clients (such as MetaMask), when an operation requires user authorization (such as signer.sendTransaction), the client presents a dialog box to the user. If the user denies the request this error is thrown.

The requested action.

<src>actionRejectedError.reason⇒ "expired" | "rejected" | "pending"

The reason the action was rejected.

If there is already a pending request, some clients may indicate there is already a "pending" action. This prevents an app from spamming the user.

<src>interface BadDataError

inherits fromEthersError

This Error indicates that a provided set of data cannot be correctly interpretted.

<src>badDataError.value⇒ any

The data.

<src>interface BufferOverrunError

inherits fromEthersError

This Error indicates an attempt was made to read outside the bounds of protected data.

Most operations in Ethers are protected by bounds checks, to mitigate exploits when parsing data.

<src>bufferOverrunError.buffer⇒ Uint8Array

The buffer that was overrun.

<src>bufferOverrunError.length⇒ number

The length of the buffer.

<src>bufferOverrunError.offset⇒ number

The offset that was requested.

<src>interface CallExceptionError

inherits fromEthersError

This Error indicates a transaction reverted.

<src>callExceptionError.action⇒ CallExceptionAction

The action being performed when the revert was encountered.

<src>callExceptionError.data⇒ null | string

The revert data returned.

<src>callExceptionError.invocation⇒ null | { args: Array< any > , method: string , signature: string }

The contract invocation details, if available.

<src>callExceptionError.reason⇒ null | string

A human-readable representation of data, if possible.

<src>callExceptionError.revert⇒ null | { args: Array< any > , name: string , signature: string }

The built-in or custom revert error, if available

<src>callExceptionError.transaction⇒ CallExceptionTransaction

The transaction that triggered the exception.

<src>interface CancelledError

inherits fromEthersError

This Error indicates that the operation was cancelled by a programmatic call, for example to cancel().

<src>interface EthersError

All errors in Ethers include properties to assist in machine-readable errors.

<src>ethersError.code⇒ ErrorCode

The string error code.

<src>ethersError.error⇒ Error

Any related error.

<src>ethersError.info⇒ Record< string, any >

Additional info regarding the error that may be useful.

This is generally helpful mostly for human-based debugging.

<src>interface InsufficientFundsError

inherits fromEthersError

The sending account has insufficient funds to cover the entire transaction cost.

<src>insufficientFundsError.transaction⇒ TransactionRequest

The transaction.

<src>interface InvalidArgumentError

inherits fromEthersError

This Error indicates an incorrect type or value was passed to a function or method.

<src>invalidArgumentError.argument⇒ string

The name of the argument.

<src>invalidArgumentError.value⇒ any

The value that was provided.

<src>interface MissingArgumentError

inherits fromEthersError

This Error indicates there were too few arguments were provided.

<src>missingArgumentError.count⇒ number

The number of arguments received.

<src>missingArgumentError.expectedCount⇒ number

The number of arguments expected.

<src>interface NetworkError

inherits fromEthersError

<src>networkError.event⇒ string

<src>interface NonceExpiredError

inherits fromEthersError

The sending account has already used this nonce in a transaction that has been included.

<src>nonceExpiredError.transaction⇒ TransactionRequest

The transaction.

<src>interface NotImplementedError

inherits fromEthersError

This Error is mostly used as a stub for functionality that is intended for the future, but is currently not implemented.

<src>notImplementedError.operation⇒ string

The attempted operation.

<src>interface NumericFaultError

inherits fromEthersError

This Error indicates an operation which would result in incorrect arithmetic output has occurred.

For example, trying to divide by zero or using a uint8 to store a negative value.

<src>numericFaultError.fault⇒ string

The fault reported.

<src>numericFaultError.operation⇒ string

The attempted operation.

<src>numericFaultError.value⇒ any

The value the operation was attempted against.

<src>interface OffchainFaultError

inherits fromEthersError

A CCIP-read exception, which cannot be recovered from or be further processed.

<src>offchainFaultError.reason⇒ string

The reason the CCIP-read failed.

<src>offchainFaultError.transaction⇒ TransactionRequest

The transaction.

<src>interface ReplacementUnderpricedError

inherits fromEthersError

An attempt was made to replace a transaction, but with an insufficient additional fee to afford evicting the old transaction from the memory pool.

<src>replacementUnderpricedError.transaction⇒ TransactionRequest

The transaction.

<src>interface ServerError

inherits fromEthersError

This Error indicates there was a problem fetching a resource from a server.

<src>serverError.request⇒ FetchRequest | string

The requested resource.

<src>serverError.response⇒ FetchResponse

The response received from the server, if available.

<src>interface TimeoutError

inherits fromEthersError

This Error indicates that the timeout duration has expired and that the operation has been implicitly cancelled.

The side-effect of the operation may still occur, as this generally means a request has been sent and there has simply been no response to indicate whether it was processed or not.

<src>timeoutError.operation⇒ string

The attempted operation.

<src>timeoutError.reason⇒ string

The reason.

<src>timeoutError.request⇒ FetchRequest

The resource request, if available.

<src>interface TransactionReplacedError

inherits fromEthersError

A pending transaction was replaced by another.

<src>transactionReplacedError.cancelled⇒ boolean

If the transaction was cancelled, such that the original effects of the transaction cannot be assured.

<src>transactionReplacedError.hash⇒ string

The hash of the replaced transaction.

<src>transactionReplacedError.reason⇒ "repriced" | "cancelled" | "replaced"

The reason the transaction was replaced.

<src>transactionReplacedError.receipt⇒ TransactionReceipt

The receipt of the transaction that replace the transaction.

<src>transactionReplacedError.replacement⇒ TransactionResponse

The transaction that replaced the transaction.

<src>interface UnconfiguredNameError

inherits fromEthersError

This Error indicates an ENS name was used, but the name has not been configured.

This could indicate an ENS name is unowned or that the current address being pointed to is the Zero.

<src>unconfiguredNameError.value⇒ string

The ENS name that was requested

<src>interface UnexpectedArgumentError

inherits fromEthersError

This Error indicates too many arguments were provided.

<src>unexpectedArgumentError.count⇒ number

The number of arguments received.

<src>unexpectedArgumentError.expectedCount⇒ number

The number of arguments expected.

<src>interface UnknownError

inherits fromEthersError

This Error is a catch-all for when there is no way for Ethers to know what the underlying problem is.

<src>interface UnsupportedOperationError

inherits fromEthersError

This Error indicates that the attempted operation is not supported.

This could range from a specifc JSON-RPC end-point not supporting a feature to a specific configuration of an object prohibiting the operation.

For example, a Wallet with no connected Provider is unable to send a transaction.

<src>unsupportedOperationError.operation⇒ string

The attempted operation.