Enum ControlErrorCode 

#[non_exhaustive]
pub enum ControlErrorCode {
    ParseError,
    InvalidRequest,
    MethodNotFound,
    InvalidParams,
    DispatchFailed,
    Unauthorized,
    NotSupported,
    ControlError,
    WalletNoChainSource,
    WalletNotSynced,
    WalletReadFailed,
    WalletRateLimited,
    WalletNodeSpendDisabled,
    WalletCoinsReserved,
    WalletReservationsUnavailable,
    SpendAuditUnreadable,
}

A canonical control-plane error code.

#[non_exhaustive] so adding a code in a minor release is additive; downstream matches must use a _ => … arm.

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.

ParseError

-32700 — request body was not valid JSON.

InvalidRequest

-32600 — the request was not a single JSON-RPC object (batches are unsupported).

MethodNotFound

-32601 — the control method is not resolved by the node.

InvalidParams

-32602 — invalid or missing method parameters.

DispatchFailed

-32000 — the node failed to dispatch a well-formed control call.

Unauthorized

-32030 — a control.* method was called without a valid local control token.

NotSupported

-32031 — the control operation is not supported on this node build (e.g. §21 sync with no identity loaded, or a capability the running engine does not expose).

ControlError

-32032 — a control operation failed at runtime (e.g. a config write or cache op errored).

WalletNoChainSource

-32040 — a wallet chain read had NO live chain source able to answer. Reported instead of a fabricated empty answer: nothing was consulted, so nothing is known.

WalletNotSynced

-32041 — a wallet chain read of the wallet’s OWN address while its local replica is still syncing and no fallback is attached: nothing can answer YET.

WalletReadFailed

-32042 — a wallet chain read failed at the underlying DB / chain-source layer.

WalletRateLimited

-32043 — a wallet chain read was refused because the global fallback rate bound is spent. The caller should back off and retry; the answer is unknown, not empty.

WalletNodeSpendDisabled

-32044 — control.wallet.broadcast refused: the bundle requires a signature from one of the NODE’s OWN custodied keys while DIG_WALLET_ENABLE_LIVE_BROADCAST is off (dig-node SPEC §18.12).

The node relays bundles somebody else signed on every install; sending its own money is a separate, default-OFF custody decision, and a caller could otherwise sign through the node and hand the bundle straight back. Retrying cannot help: the remedy is a bundle that does not spend the node’s coins, or the flag.

The exact opposite disposition to WalletCoinsReserved, which is a wait. Keeping the two on distinct numbers is the whole point of this code being catalogued here.

WalletCoinsReserved

-32046 — one or more named coins are already committed to a live in-flight spend, so NOTHING was reserved by the failed call.

Deliberately distinct from any shortfall code. The user has the money; it is briefly committed elsewhere and comes back when that spend settles or its reservation lapses. Reporting a shortfall here sends someone to an exchange to solve a wait, which is the money-lie this taxonomy exists to prevent.

WalletReservationsUnavailable

-32047 — the node’s coin-reservation set could not be read or written, so what is in flight is UNKNOWN.

Never collapsed into an empty answer. “Nothing is reserved” and “I cannot tell you what is reserved” demand opposite actions from a caller: the first permits a spend, the second must refuse one. A guard that fails open is not a guard.

SpendAuditUnreadable

-32048 — the automated-spend audit record could not be read at all, so what this node spent unattended is UNKNOWN.

Never collapsed into an empty page. “This node has moved no money unattended” and “I cannot tell you what this node moved” are opposite answers, and the first is the one a person stops investigating on. A partial read is a different thing again and is NOT an error: entries the node could parse are returned, and the ones it could not are counted in SpendsListResult::unreadable_lines. This code is for the case where nothing at all could be read.

An audit record that has never been written is likewise NOT an error — a node that has never spent automatically is the ordinary case, and it answers with an empty page.

Implementations

impl ControlErrorCode

pub const ALL: &'static [ControlErrorCode]

Every catalogued code, for the error-catalogue document + drift tests.

pub const fn code(self) -> i64

The numeric JSON-RPC error code.

pub const fn name(self) -> &'static str

The stable UPPER_SNAKE symbolic name a client branches on. Never derived from the message.

pub const fn origin(self) -> &'static str

Where the error originates, mirroring dig-node’s classification.

pub const fn description(self) -> &'static str

A one-line description for the error catalogue.

pub fn from_code(code: i64) -> Option<ControlErrorCode>

Resolve a numeric wire code back to its variant, or None for an uncatalogued code.

Trait Implementations

impl Clone for ControlErrorCode

fn clone(&self) -> ControlErrorCode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ControlErrorCode

impl Debug for ControlErrorCode

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

Formats the value using the given formatter.

impl Eq for ControlErrorCode

impl Hash for ControlErrorCode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ControlErrorCode

fn eq(&self, other: &ControlErrorCode) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ControlErrorCode