Enum SpendOutcome 

pub enum SpendOutcome {
    Pending,
    Submitted,
    Confirmed {
        height: u32,
        coin_id: String,
    },
    Failed {
        stage: SpendFailureStage,
        reason: String,
    },
    Unresolved {
        reason: String,
    },
}

Where one automated spend got to.

Internally tagged on state, so a row is {"state":"confirmed","height":…,"coin_id":"…"}.

Two shape rules, each from a measured money-lie

1. Confirmed carries its evidence inside the variant. There is no optional height field to fill in optimistically, so a row cannot hold a confirmation height without a confirmation.
2. Unresolved is NOT a kind of failure. “The node signed and does not know how it ended” is not “it did not happen”: money may well have moved, and saying failed about a spend that landed is the same class of lie as claiming an unconfirmed success. A client that maps it onto failed to keep a two-state UI has chosen the wrong UI.

Variants

Pending

Recorded, not yet handed to the network. Written before the producer may sign.

Submitted

A signed bundle was accepted by the mempool. NOT a claim that it will confirm.

Confirmed

The chain shows the coin this spend created.

Fields

height: u32

The height the created coin was confirmed at.

coin_id: String

The coin the spend CREATED — the reference a person can paste into an explorer.

Failed

The attempt ended in a failure this node observed.

This is not uniformly a claim that the money stayed put. Only SpendFailureStage::Signing carries that claim; at Broadcast and Confirmation a signed bundle already existed and the outcome is genuinely UNKNOWN. Ask SpendFailureStage::money_may_have_moved before rendering any failed row as settled.

Fields

stage: SpendFailureStage

Which step failed — and, through SpendFailureStage::money_may_have_moved, whether this row claims the money is untouched or merely records where the attempt died.

reason: String

One line a person can act on. “Insufficient funds” is the difference between a broken node and a wallet that needs topping up.

Unresolved

The node signed and does not know how it ended — a timeout, a restart mid-flight, or a producer that dropped the spend.

Fields

reason: String

Why the outcome is unknown.

Implementations

impl SpendOutcome

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

The stable lowercase token, matching the state tag and the status filter.

pub fn outcome_is_unknown(&self) -> bool

Is what happened to the money still UNKNOWN?

True for Unresolved, and true for a Failed row whose stage may have moved money. Those two are the rows a person still has to chase, and a UI grouping them with settled failures hides exactly the spends worth looking at.

Pending and Submitted are NOT unknown outcomes — they are outcomes that have not happened yet, and the node expects to learn them. Conflating “in flight” with “lost track of” would raise an alarm about every spend in progress.

Trait Implementations

impl Clone for SpendOutcome

fn clone(&self) -> SpendOutcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpendOutcome

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SpendOutcome

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SpendOutcome

impl PartialEq for SpendOutcome

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SpendOutcome

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SpendOutcome