Enum ExitState 

pub enum ExitState {
    Start(ExitStartState),
    Processing(ExitProcessingState),
    AwaitingDelta(ExitAwaitingDeltaState),
    Claimable(ExitClaimableState),
    ClaimInProgress(ExitClaimInProgressState),
    Claimed(ExitClaimedState),
    VtxoAlreadySpent(ExitVtxoAlreadySpentState),
}

A utility type to wrap ExitState children so they can be easily serialized. This also helps with debugging a lot!

Variants

Start(ExitStartState)

Processing(ExitProcessingState)

AwaitingDelta(ExitAwaitingDeltaState)

Claimable(ExitClaimableState)

ClaimInProgress(ExitClaimInProgressState)

Claimed(ExitClaimedState)

Terminal state: the exit is fully complete, and the VTXO has been claimed by the user or spent by another user who owns a VTXO that is deeper in the tree than this one.

Note: The circumstances in which the latter can occur are typically when the user has stale data and is trying to exit an already-spent VTXO.

VtxoAlreadySpent(ExitVtxoAlreadySpentState)

Terminal state: the exit cannot proceed because the VTXO has already been spent offchain. A user can start a unilateral exit for a VTXO but later spend it via a refresh, arkoor, etc, in that situation an exit will enter this state.

Implementations

impl ExitState

pub fn new_start(tip: BlockHeight) -> Self

pub fn new_processing<T: IntoIterator<Item = Txid>>( tip: BlockHeight, txids: T, ) -> Self

pub fn new_processing_from_transactions( tip: BlockHeight, transactions: Vec<ExitTx>, ) -> Self

pub fn new_awaiting_delta( tip: BlockHeight, confirmed_block: BlockRef, wait_delta: BlockDelta, ) -> Self

pub fn new_claimable( tip: BlockHeight, claimable_since: BlockRef, last_scanned_block: Option<BlockRef>, ) -> Self

pub fn new_claim_in_progress( tip: BlockHeight, claimable_since: BlockRef, claim_txid: Txid, ) -> Self

pub fn new_claimed(tip: BlockHeight, txid: Txid, block: BlockRef) -> Self

pub fn new_vtxo_already_spent(tip: BlockHeight) -> Self

pub fn is_pending(&self) -> bool

Checks if the state is awaiting the confirmation of every exit transaction in the tree and the exit delta required for the VTXO to become claimable.

Note: This excludes the claimable state, use ExitState::is_claimable for that.

pub fn is_claimable(&self) -> bool

A simple helper for ExitState::Claimable, at this point an exit can be spent on-chain and redeemed into a UTXO controlled by the user.

pub fn requires_confirmations(&self) -> bool

pub fn claimable_height(&self) -> Option<BlockHeight>

pub fn warrants_exited_vtxo(&self) -> bool

True once every exit transaction has confirmed on-chain (i.e. the exit has reached at least ExitState::AwaitingDelta). At that point the VTXO can be considered crate::vtxo::VtxoStateKind::Exited: the underlying onchain outpoint is committed to the exit chain, the server can see it and will refuse to service the VTXO for any payment operations offchain, and there’s nothing left to undo client-side.

Note: we deliberately don’t flip the VTXO at Processing — even with every tx broadcast, mempool eviction is still possible until confirmation, so we hold off to keep Exited an accurate “this is gone” signal.

Trait Implementations

impl Clone for ExitState

fn clone(&self) -> ExitState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExitState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExitState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ExitState

impl Into<ExitState> for ExitStartState

fn into(self) -> ExitState

Converts this type into the (usually inferred) input type.

impl Into<ExitState> for ExitProcessingState

fn into(self) -> ExitState

Converts this type into the (usually inferred) input type.

impl Into<ExitState> for ExitAwaitingDeltaState

fn into(self) -> ExitState

Converts this type into the (usually inferred) input type.

impl Into<ExitState> for ExitClaimableState

fn into(self) -> ExitState

Converts this type into the (usually inferred) input type.

impl Into<ExitState> for ExitClaimInProgressState

fn into(self) -> ExitState

Converts this type into the (usually inferred) input type.

impl Into<ExitState> for ExitClaimedState

fn into(self) -> ExitState

Converts this type into the (usually inferred) input type.

impl Into<ExitState> for ExitVtxoAlreadySpentState

fn into(self) -> ExitState

Converts this type into the (usually inferred) input type.

impl PartialEq for ExitState

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExitState

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 ExitState