Enum ClientModuleError 

#[non_exhaustive]
pub enum ClientModuleError {
    InsufficientBalance(InsufficientBalanceError),
    Unsupported {
        kind: ModuleKind,
        operation: &'static str,
    },
    Other(Box<dyn Error + Send + Sync>),
}

A failure a client module reports to the client.

The methods a module implements for the client in ClientModule, ClientModuleInit and RecoveryFromHistory report this type, and so do the type-erased wrappers the client calls them through. The client wraps it in the error of the operation that needed the module; the JSON command handlers handle_cli_command and handle_rpc hand it to the command-line or RPC caller as it is.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

InsufficientBalance(InsufficientBalanceError)

The primary module’s balance cannot fund the transaction it was asked to balance.

A primary module reports this from create_final_inputs_and_outputs, and the client passes it on as TransactionSubmitError::InsufficientFunds.

Unsupported

The module does not implement the operation.

The default bodies of backup, create_final_inputs_and_outputs, await_primary_module_output, leave and ClientModuleInit::recover report this. The client only asks a module for an operation the module declares support for, through supports_backup, supports_being_primary or recovery_mode, so the client sees this only from a module that declares support it does not implement. Calling the operation on a module directly can see it too. The default bodies of handle_cli_command and handle_rpc report it as well, to a caller that sends a command or a request to a module that has none.

Fields

kind: ModuleKind

The kind of the module.

operation: &'static str

The name of the trait method the module does not implement.

Other(Box<dyn Error + Send + Sync>)

Any other failure, kept whole: the module’s own error or the error of a library it builds on, such as a federation, database or Bitcoin backend failure. Its Display and source() are those of the error it carries.

Implementations

impl ClientModuleError

pub fn other<E>(error: E) -> Self

where E: Into<Box<dyn Error + Send + Sync>>,

Wraps a failure the other variants do not describe. Accepts anything convertible into a boxed error, which includes an anyhow::Error and a plain message.

A primary module’s shortfall must be Self::InsufficientBalance instead: the client does not look inside the error this carries.

Trait Implementations

impl Debug for ClientModuleError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ClientModuleError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for ClientModuleError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<ClientModuleError> for TransactionSubmitError

A primary module’s failure to balance a transaction, as the failure of that transaction: a balance too low to fund it becomes TransactionSubmitError::InsufficientFunds, so callers can tell it apart from any other failure of the module, which becomes TransactionSubmitError::PrimaryModule.

fn from(error: ClientModuleError) -> Self

Converts to this type from the input type.

impl From<InsufficientBalanceError> for ClientModuleError

fn from(source: InsufficientBalanceError) -> Self

Converts to this type from the input type.