@vechain/sdk-errors/dist/index.d.mts

This module is dedicated to managing and customizing errors within the VeChain SDK

/**
 * Function to stringify data correctly.
 * Some data types like Error, Map, Set, etc. are not stringified correctly by JSON.stringify.
 * This function handles those cases and avoids circular references.
 *
 * @param data - The data to be stringified.
 * @returns The stringified data.
 */
declare const stringifyData: (data: unknown) => string;
/**
 * Asserts that the given error is an instance of the Error class.
 * If the error is an instance of Error, it is returned.
 * If the error is not an instance of Error, a new Error object is created with a descriptive message.
 *
 * @param {unknown} error - The error to be asserted.
 * @return {Error} - The error if it is an instance of Error, or a new Error object if it is not.
 *
 * @remarks
 * **IMPORTANT: no sensitive data should be passed as any parameter.**
 */
declare function assertInnerError(error: unknown): Error;
/**
 * Function to build the error message.
 * Here, we can customize the error message format.
 *
 * @param methodName The name of the method that failed.
 * @param errorMessage The error message.
 * @param inputData The input data that caused the error.
 * @param innerError The inner error that caused the error.
 * @returns The error message as a string.
 */
declare function createErrorMessage<TErrorDataType>(methodName: string, errorMessage: string, inputData: TErrorDataType, innerError?: Error): string;

/**
 * Generic error class for SDK errors.
 *
 * Each error of SDK should extend this class.
 * And, then, error must redefine properly the TErrorDataType generic type.
 * In this way, the error will have a specific data type.
 */
declare class VechainSDKError<TErrorDataType> extends Error {
    readonly methodName: string;
    readonly errorMessage: string;
    readonly data: TErrorDataType;
    readonly innerError?: unknown | undefined;
    constructor(methodName: string, errorMessage: string, data: TErrorDataType, innerError?: unknown | undefined);
}

/**
 * Default Object error data type. it accepts any object.
 */
type ObjectErrorData = Record<string, unknown>;
type JSONRpcErrorCode =
    | -32700
    | -32600
    | -32601
    | -32602
    | -32603
    | -32000
    | -32004;

/**
 * Invalid data to encode/decode abi error
 *
 * WHEN TO USE:
 * * This error will be thrown when the data to encode or decode into abi is invalid.
 */
declare class InvalidAbiDataToEncodeOrDecode extends VechainSDKError<ObjectErrorData> {
}
/**
 * Invalid ABI item error
 *
 * WHEN TO USE:
 * * This error will be thrown when the ABI item is invalid.
 */
declare class InvalidAbiItem extends VechainSDKError<{
    type: 'function' | 'event';
    value: unknown;
}> {
}
/**
 * Invalid abi signature format error
 *
 * WHEN TO USE:
 * * This error will be thrown when the abi signature format is invalid.
 */
declare class InvalidAbiSignatureFormat extends VechainSDKError<{
    signatureFormat: string;
}> {
}

/**
 * Invalid address error
 *
 * WHEN TO USE:
 * * This error will be thrown when the address is invalid.
 */
declare class InvalidAddress extends VechainSDKError<{
    address: string;
}> {
}

/**
 * Invalid bloom error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the bloom is invalid.
 */
declare class InvalidBloom extends VechainSDKError<ObjectErrorData> {
}
/**
 * Invalid bloom params error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the bloom params are invalid.
 */
declare class InvalidBloomParams extends VechainSDKError<ObjectErrorData> {
}

/**
 * Certificate Signature error.
 *
 * WHEN TO USE:
 * * This error will be thrown when the certificate signature is invalid
 * OR the certificate is not signed, or has in general signature errors.
 */
declare class CertificateSignatureMismatch extends VechainSDKError<ObjectErrorData> {
}

/**
 * Cannot find transaction error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the transaction is not into the blockchain.
 */
declare class ContractDeploymentFailed extends VechainSDKError<ObjectErrorData> {
}
/**
 * Error when calling a read function on a contract.
 *
 * WHEN TO USE:
 * * Error will be thrown when a read (call) operation fails.
 */
declare class ContractCallError extends VechainSDKError<ObjectErrorData> {
}

/**
 * Invalid data type error.
 *
 * WHEN TO USE:
 * * This error will be thrown when the data type is invalid.
 * -e.g.- when the data type is not a string, number, boolean, or object.
 */
declare class InvalidDataType extends VechainSDKError<ObjectErrorData> {
}
/**
 * Unsupported operation error.
 *
 * WHEN TO USE:
 * * This error will be thrown when an operation is not supported.
 * -e.g.- into the ethers adapter, when the runner does not support sending transactions.
 */
declare class UnsupportedOperation extends VechainSDKError<ObjectErrorData> {
}

/**
 * Invalid HDNode mnemonic error.
 *
 * WHEN TO USE:
 * * This error will be thrown when the HDKey mnemonic is invalid.
 *
 * @note Data (mnemonic) is undefined for security reasons, the mnemonic should not be logged!
 */
declare class InvalidHDKeyMnemonic extends VechainSDKError<undefined | {
    wordlistSize: number;
}> {
}
/**
 * Invalid HDNode error.
 *
 * WHEN TO USE:
 * * This error will be thrown when the HDKey is invalid (derivation path / chainCode / public key parameters).
 */
declare class InvalidHDKey extends VechainSDKError<{
    derivationPath?: string;
    chainCode?: Uint8Array;
    publicKey?: Uint8Array;
}> {
}

/**
 * Http invalid request error
 *
 * WHEN TO USE:
 * * Error will be thrown when an invalid HTTP request fails
 */
declare class InvalidHTTPRequest extends VechainSDKError<{
    method: string;
    url: string;
}> {
}
/**
 * Http invalid params error
 *
 * WHEN TO USE:
 * * Error will be thrown when HTTP request params are invalid
 */
declare class InvalidHTTPParams extends VechainSDKError<{
    method: string;
    url: string;
}> {
}

/**
 * Invalid keystore error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the keystore is invalid.
 */
declare class InvalidKeystore extends VechainSDKError<ObjectErrorData> {
}
/**
 * Invalid keystore params error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the keystore params are invalid.
 */
declare class InvalidKeystoreParams extends VechainSDKError<ObjectErrorData> {
}

/**
 * Poll execution error.
 *
 * WHEN TO USE:
 * * Error will be thrown when a poll execution of a function throw error
 */
declare class PollExecution extends VechainSDKError<{
    functionName: string;
}> {
}

/**
 * Provider method error.
 *
 * WHEN TO USE:
 * * This error will be thrown when a provider method has failed.
 */
declare class ProviderMethodError extends VechainSDKError<ObjectErrorData> {
}
/**
 * Provider generic error.
 *
 * WHEN TO USE:
 * * It is a subclass of all provider errors
 *
 * @see{https://www.jsonrpc.org/specification#error_object}
 */
declare class JSONRPCProviderError extends VechainSDKError<{
    code: JSONRpcErrorCode;
    message: string;
    data: ObjectErrorData;
}> {
    readonly methodName: string;
    readonly innerError?: unknown | undefined;
    constructor(methodName: string, code: JSONRpcErrorCode, message: string, data: ObjectErrorData, innerError?: unknown | undefined);
}
/**
 * Parse error.
 *
 * WHEN TO USE:
 * * Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.
 */
declare class JSONRPCParseError extends JSONRPCProviderError {
    readonly methodName: string;
    readonly innerError?: unknown | undefined;
    constructor(methodName: string, message: string, data: ObjectErrorData, innerError?: unknown | undefined);
}
/**
 * Invalid request.
 *
 * WHEN TO USE:
 * * The JSON sent is not a valid Request object.
 */
declare class JSONRPCInvalidRequest extends JSONRPCProviderError {
    readonly methodName: string;
    readonly innerError?: unknown | undefined;
    constructor(methodName: string, message: string, data: ObjectErrorData, innerError?: unknown | undefined);
}
/**
 * Method not found.
 *
 * WHEN TO USE:
 * * The method does not exist / is not available.
 */
declare class JSONRPCMethodNotFound extends JSONRPCProviderError {
    readonly methodName: string;
    readonly innerError?: unknown | undefined;
    constructor(methodName: string, message: string, data: ObjectErrorData, innerError?: unknown | undefined);
}
/**
 * Invalid params.
 *
 * WHEN TO USE:
 * * Invalid method parameter(s).
 */
declare class JSONRPCInvalidParams extends JSONRPCProviderError {
    readonly methodName: string;
    readonly innerError?: unknown | undefined;
    constructor(methodName: string, message: string, data: ObjectErrorData, innerError?: unknown | undefined);
}
/**
 * Internal JSON-RPC error.
 *
 * WHEN TO USE:
 * * Internal JSON-RPC error.
 */
declare class JSONRPCInternalError extends JSONRPCProviderError {
    readonly methodName: string;
    readonly innerError?: unknown | undefined;
    constructor(methodName: string, message: string, data: ObjectErrorData, innerError?: unknown | undefined);
}
/**
 * Invalid default block.
 *
 * WHEN TO USE:
 * * When converting default block to vechain revision
 */
declare class JSONRPCInvalidDefaultBlock extends VechainSDKError<string> {
}
/**
 * Server error.
 *
 * WHEN TO USE:
 * * Reserved for implementation-defined server-errors.
 */
declare class JSONRPCServerError extends JSONRPCProviderError {
    readonly methodName: string;
    readonly innerError?: unknown | undefined;
    constructor(methodName: string, message: string, data: ObjectErrorData, innerError?: unknown | undefined);
}
/**
 * Method not implemented.
 *
 * WHEN TO USE:
 * * When a method is implemented but not yet supported by the provider.
 */
declare class JSONRPCMethodNotImplemented extends JSONRPCProviderError {
    readonly methodName: string;
    readonly innerError?: unknown | undefined;
    constructor(methodName: string, message: string, data: ObjectErrorData, innerError?: unknown | undefined);
}
/**
 * Revert error.
 *
 * WHEN TO USE:
 * * When a Transaction is reverted.
 */
declare class JSONRPCTransactionRevertError extends Error {
    code: number;
    data?: string;
    message: string;
    constructor(message: string, data?: string);
}

/**
 * Invalid RLP error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the RLP is invalid.
 */
declare class InvalidRLP extends VechainSDKError<{
    context: string;
    data: ObjectErrorData;
}> {
}

/**
 * Invalid command line arguments
 *
 * WHEN TO USE:
 * * When the RPC proxy is called with invalid command line arguments
 */
declare class InvalidCommandLineArguments extends VechainSDKError<{
    flag: string;
    value: string;
}> {
}
/**
 * Invalid configuration file path
 *
 * WHEN TO USE:
 * * When the configuration file path given as input is invalid
 */
declare class InvalidConfigurationFilePath extends VechainSDKError<{
    filePath: string;
}> {
}
/**
 * Invalid configuration file
 *
 * WHEN TO USE:
 * * When the configuration file given as input is invalid
 */
declare class InvalidConfigurationFile extends VechainSDKError<{
    filePath?: string;
    wrongField?: string;
    message?: string;
}> {
}

/**
 * Invalid secp256k1 private key error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the secp256k1 private key is invalid.
 *
 * @note Data (private key) is undefined for security reasons, the private key should not be logged!
 */
declare class InvalidSecp256k1PrivateKey extends VechainSDKError<undefined> {
}
/**
 * Invalid secp256k1 message hash error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the secp256k1 message hash is invalid.
 */
declare class InvalidSecp256k1MessageHash extends VechainSDKError<{
    messageHash: Uint8Array;
}> {
}
/**
 * Invalid secp256k1 signature error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the secp256k1 signature is invalid.
 */
declare class InvalidSecp256k1Signature extends VechainSDKError<{
    signature: Uint8Array;
    recovery?: number;
}> {
}

/**
 * Signer method error.
 *
 * WHEN TO USE:
 * * This error will be thrown when a signer method has failed.
 */
declare class SignerMethodError extends VechainSDKError<ObjectErrorData> {
}

/**
 * Unavailable transaction field (field name) error.
 *
 * WHEN TO USE:
 * * Error will be thrown when a transaction (field name) in a transaction is unavailable.
 */
declare class UnavailableTransactionField extends VechainSDKError<{
    fieldName: string;
}> {
}
/**
 * Invalid transaction field (field name) error.
 *
 * WHEN TO USE:
 * * Error will be thrown when a transaction (field name) in a transaction is invalid.
 */
declare class InvalidTransactionField extends VechainSDKError<{
    fieldName: string;
} & ObjectErrorData> {
}
/**
 * Not delegated transaction error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the transaction is not delegated.
 */
declare class NotDelegatedTransaction extends VechainSDKError<undefined | {
    gasPayerUrl: string;
}> {
}
/**
 * Cannot find transaction error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the transaction is not into the blockchain.
 */
declare class CannotFindTransaction extends VechainSDKError<{
    transactionHash?: string;
    networkUrl?: string;
}> {
}
/**
 * Invalid transaction type error.
 *
 * WHEN TO USE:
 * * Error will be thrown when the transaction type is invalid.
 */
declare class InvalidTransactionType extends VechainSDKError<{
    transactionType?: string;
    validTypes?: string;
}> {
}

/**
 * Invalid cast type error.
 *
 * WHEN TO USE:
 * * Error will be thrown when a method call or property read fails.
 */
declare class InvalidOperation extends VechainSDKError<ObjectErrorData> {
}

type errors_CannotFindTransaction = CannotFindTransaction;
declare const errors_CannotFindTransaction: typeof CannotFindTransaction;
type errors_CertificateSignatureMismatch = CertificateSignatureMismatch;
declare const errors_CertificateSignatureMismatch: typeof CertificateSignatureMismatch;
type errors_ContractCallError = ContractCallError;
declare const errors_ContractCallError: typeof ContractCallError;
type errors_ContractDeploymentFailed = ContractDeploymentFailed;
declare const errors_ContractDeploymentFailed: typeof ContractDeploymentFailed;
type errors_InvalidAbiDataToEncodeOrDecode = InvalidAbiDataToEncodeOrDecode;
declare const errors_InvalidAbiDataToEncodeOrDecode: typeof InvalidAbiDataToEncodeOrDecode;
type errors_InvalidAbiItem = InvalidAbiItem;
declare const errors_InvalidAbiItem: typeof InvalidAbiItem;
type errors_InvalidAbiSignatureFormat = InvalidAbiSignatureFormat;
declare const errors_InvalidAbiSignatureFormat: typeof InvalidAbiSignatureFormat;
type errors_InvalidAddress = InvalidAddress;
declare const errors_InvalidAddress: typeof InvalidAddress;
type errors_InvalidBloom = InvalidBloom;
declare const errors_InvalidBloom: typeof InvalidBloom;
type errors_InvalidBloomParams = InvalidBloomParams;
declare const errors_InvalidBloomParams: typeof InvalidBloomParams;
type errors_InvalidCommandLineArguments = InvalidCommandLineArguments;
declare const errors_InvalidCommandLineArguments: typeof InvalidCommandLineArguments;
type errors_InvalidConfigurationFile = InvalidConfigurationFile;
declare const errors_InvalidConfigurationFile: typeof InvalidConfigurationFile;
type errors_InvalidConfigurationFilePath = InvalidConfigurationFilePath;
declare const errors_InvalidConfigurationFilePath: typeof InvalidConfigurationFilePath;
type errors_InvalidDataType = InvalidDataType;
declare const errors_InvalidDataType: typeof InvalidDataType;
type errors_InvalidHDKey = InvalidHDKey;
declare const errors_InvalidHDKey: typeof InvalidHDKey;
type errors_InvalidHDKeyMnemonic = InvalidHDKeyMnemonic;
declare const errors_InvalidHDKeyMnemonic: typeof InvalidHDKeyMnemonic;
type errors_InvalidHTTPParams = InvalidHTTPParams;
declare const errors_InvalidHTTPParams: typeof InvalidHTTPParams;
type errors_InvalidHTTPRequest = InvalidHTTPRequest;
declare const errors_InvalidHTTPRequest: typeof InvalidHTTPRequest;
type errors_InvalidKeystore = InvalidKeystore;
declare const errors_InvalidKeystore: typeof InvalidKeystore;
type errors_InvalidKeystoreParams = InvalidKeystoreParams;
declare const errors_InvalidKeystoreParams: typeof InvalidKeystoreParams;
type errors_InvalidOperation = InvalidOperation;
declare const errors_InvalidOperation: typeof InvalidOperation;
type errors_InvalidRLP = InvalidRLP;
declare const errors_InvalidRLP: typeof InvalidRLP;
type errors_InvalidSecp256k1MessageHash = InvalidSecp256k1MessageHash;
declare const errors_InvalidSecp256k1MessageHash: typeof InvalidSecp256k1MessageHash;
type errors_InvalidSecp256k1PrivateKey = InvalidSecp256k1PrivateKey;
declare const errors_InvalidSecp256k1PrivateKey: typeof InvalidSecp256k1PrivateKey;
type errors_InvalidSecp256k1Signature = InvalidSecp256k1Signature;
declare const errors_InvalidSecp256k1Signature: typeof InvalidSecp256k1Signature;
type errors_InvalidTransactionField = InvalidTransactionField;
declare const errors_InvalidTransactionField: typeof InvalidTransactionField;
type errors_InvalidTransactionType = InvalidTransactionType;
declare const errors_InvalidTransactionType: typeof InvalidTransactionType;
type errors_JSONRPCInternalError = JSONRPCInternalError;
declare const errors_JSONRPCInternalError: typeof JSONRPCInternalError;
type errors_JSONRPCInvalidDefaultBlock = JSONRPCInvalidDefaultBlock;
declare const errors_JSONRPCInvalidDefaultBlock: typeof JSONRPCInvalidDefaultBlock;
type errors_JSONRPCInvalidParams = JSONRPCInvalidParams;
declare const errors_JSONRPCInvalidParams: typeof JSONRPCInvalidParams;
type errors_JSONRPCInvalidRequest = JSONRPCInvalidRequest;
declare const errors_JSONRPCInvalidRequest: typeof JSONRPCInvalidRequest;
type errors_JSONRPCMethodNotFound = JSONRPCMethodNotFound;
declare const errors_JSONRPCMethodNotFound: typeof JSONRPCMethodNotFound;
type errors_JSONRPCMethodNotImplemented = JSONRPCMethodNotImplemented;
declare const errors_JSONRPCMethodNotImplemented: typeof JSONRPCMethodNotImplemented;
type errors_JSONRPCParseError = JSONRPCParseError;
declare const errors_JSONRPCParseError: typeof JSONRPCParseError;
type errors_JSONRPCProviderError = JSONRPCProviderError;
declare const errors_JSONRPCProviderError: typeof JSONRPCProviderError;
type errors_JSONRPCServerError = JSONRPCServerError;
declare const errors_JSONRPCServerError: typeof JSONRPCServerError;
type errors_JSONRPCTransactionRevertError = JSONRPCTransactionRevertError;
declare const errors_JSONRPCTransactionRevertError: typeof JSONRPCTransactionRevertError;
type errors_JSONRpcErrorCode = JSONRpcErrorCode;
type errors_NotDelegatedTransaction = NotDelegatedTransaction;
declare const errors_NotDelegatedTransaction: typeof NotDelegatedTransaction;
type errors_ObjectErrorData = ObjectErrorData;
type errors_PollExecution = PollExecution;
declare const errors_PollExecution: typeof PollExecution;
type errors_ProviderMethodError = ProviderMethodError;
declare const errors_ProviderMethodError: typeof ProviderMethodError;
type errors_SignerMethodError = SignerMethodError;
declare const errors_SignerMethodError: typeof SignerMethodError;
type errors_UnavailableTransactionField = UnavailableTransactionField;
declare const errors_UnavailableTransactionField: typeof UnavailableTransactionField;
type errors_UnsupportedOperation = UnsupportedOperation;
declare const errors_UnsupportedOperation: typeof UnsupportedOperation;
type errors_VechainSDKError<TErrorDataType> = VechainSDKError<TErrorDataType>;
declare const errors_VechainSDKError: typeof VechainSDKError;
declare const errors_assertInnerError: typeof assertInnerError;
declare const errors_createErrorMessage: typeof createErrorMessage;
declare const errors_stringifyData: typeof stringifyData;
declare namespace errors {
  export { errors_CannotFindTransaction as CannotFindTransaction, errors_CertificateSignatureMismatch as CertificateSignatureMismatch, errors_ContractCallError as ContractCallError, errors_ContractDeploymentFailed as ContractDeploymentFailed, errors_InvalidAbiDataToEncodeOrDecode as InvalidAbiDataToEncodeOrDecode, errors_InvalidAbiItem as InvalidAbiItem, errors_InvalidAbiSignatureFormat as InvalidAbiSignatureFormat, errors_InvalidAddress as InvalidAddress, errors_InvalidBloom as InvalidBloom, errors_InvalidBloomParams as InvalidBloomParams, errors_InvalidCommandLineArguments as InvalidCommandLineArguments, errors_InvalidConfigurationFile as InvalidConfigurationFile, errors_InvalidConfigurationFilePath as InvalidConfigurationFilePath, errors_InvalidDataType as InvalidDataType, errors_InvalidHDKey as InvalidHDKey, errors_InvalidHDKeyMnemonic as InvalidHDKeyMnemonic, errors_InvalidHTTPParams as InvalidHTTPParams, errors_InvalidHTTPRequest as InvalidHTTPRequest, errors_InvalidKeystore as InvalidKeystore, errors_InvalidKeystoreParams as InvalidKeystoreParams, errors_InvalidOperation as InvalidOperation, errors_InvalidRLP as InvalidRLP, errors_InvalidSecp256k1MessageHash as InvalidSecp256k1MessageHash, errors_InvalidSecp256k1PrivateKey as InvalidSecp256k1PrivateKey, errors_InvalidSecp256k1Signature as InvalidSecp256k1Signature, errors_InvalidTransactionField as InvalidTransactionField, errors_InvalidTransactionType as InvalidTransactionType, errors_JSONRPCInternalError as JSONRPCInternalError, errors_JSONRPCInvalidDefaultBlock as JSONRPCInvalidDefaultBlock, errors_JSONRPCInvalidParams as JSONRPCInvalidParams, errors_JSONRPCInvalidRequest as JSONRPCInvalidRequest, errors_JSONRPCMethodNotFound as JSONRPCMethodNotFound, errors_JSONRPCMethodNotImplemented as JSONRPCMethodNotImplemented, errors_JSONRPCParseError as JSONRPCParseError, errors_JSONRPCProviderError as JSONRPCProviderError, errors_JSONRPCServerError as JSONRPCServerError, errors_JSONRPCTransactionRevertError as JSONRPCTransactionRevertError, type errors_JSONRpcErrorCode as JSONRpcErrorCode, errors_NotDelegatedTransaction as NotDelegatedTransaction, type errors_ObjectErrorData as ObjectErrorData, errors_PollExecution as PollExecution, errors_ProviderMethodError as ProviderMethodError, errors_SignerMethodError as SignerMethodError, errors_UnavailableTransactionField as UnavailableTransactionField, errors_UnsupportedOperation as UnsupportedOperation, errors_VechainSDKError as VechainSDKError, errors_assertInnerError as assertInnerError, errors_createErrorMessage as createErrorMessage, errors_stringifyData as stringifyData };
}

export { CannotFindTransaction, CertificateSignatureMismatch, ContractCallError, ContractDeploymentFailed, InvalidAbiDataToEncodeOrDecode, InvalidAbiItem, InvalidAbiSignatureFormat, InvalidAddress, InvalidBloom, InvalidBloomParams, InvalidCommandLineArguments, InvalidConfigurationFile, InvalidConfigurationFilePath, InvalidDataType, InvalidHDKey, InvalidHDKeyMnemonic, InvalidHTTPParams, InvalidHTTPRequest, InvalidKeystore, InvalidKeystoreParams, InvalidOperation, InvalidRLP, InvalidSecp256k1MessageHash, InvalidSecp256k1PrivateKey, InvalidSecp256k1Signature, InvalidTransactionField, InvalidTransactionType, JSONRPCInternalError, JSONRPCInvalidDefaultBlock, JSONRPCInvalidParams, JSONRPCInvalidRequest, JSONRPCMethodNotFound, JSONRPCMethodNotImplemented, JSONRPCParseError, JSONRPCProviderError, JSONRPCServerError, JSONRPCTransactionRevertError, type JSONRpcErrorCode, NotDelegatedTransaction, type ObjectErrorData, PollExecution, ProviderMethodError, SignerMethodError, UnavailableTransactionField, UnsupportedOperation, VechainSDKError, assertInnerError, createErrorMessage, errors, stringifyData };