Enum Progress 

pub enum Progress {
    Start,
    SplitWithArkoor,
    ArkoorRegistrationRequired {
        offboard_vtxo_ids: Vec<VtxoId>,
        change_vtxo_ids: Vec<VtxoId>,
    },
    ReadyForOffboard {
        offboard_vtxo_ids: Vec<VtxoId>,
        prior_txid: Option<Txid>,
    },
    OffboardTxPrepared {
        offboard_vtxo_ids: Vec<VtxoId>,
        offboard_tx: Transaction,
        forfeit_cosign_nonces: Vec<PublicNonce>,
        movement_id: MovementId,
    },
    ReadyForBroadcast {
        offboard_vtxo_ids: Vec<VtxoId>,
        signed_offboard_tx: Transaction,
        movement_id: MovementId,
    },
    AwaitingConfirmations {
        offboard_vtxo_ids: Vec<VtxoId>,
        offboard_txid: Txid,
        offboard_tx: Transaction,
        movement_id: MovementId,
        created_at: DateTime<Utc>,
    },
}

The phases of offboarding.

SplitWithArkoor and ArkoorRegistrationRequired are only reached from the SendOnchain kind; the OffboardWhole kind transitions directly from Start to ReadyForOffboard.

Variants

Start

Inputs need locking, but we have selected VTXOs to offboard.

SplitWithArkoor

SendOnchain intermediate: We need to perform an arkoor to split the VTXOs so we can offboard the exact amount requested.

ArkoorRegistrationRequired

SendOnchain intermediate: arkoor done, yet to be registered with the server. Both the offboard vtxos and the change are held locked until registration succeeds; only then is the change released as spendable.

Fields

offboard_vtxo_ids: Vec<VtxoId>

change_vtxo_ids: Vec<VtxoId>

ReadyForOffboard

VTXOs are locked, (potential) split is done, now we can start the actual offboard.

Fields

offboard_vtxo_ids: Vec<VtxoId>

In the case of SendOnchain this is the arkoor VTXOs we just created, in the case of OffboardWhole this is the VTXOs we selected to offboard.

prior_txid: Option<Txid>

Set when we fell back here from Progress::OffboardTxPrepared because the server’s session disappeared before we could finish it, and its tx wasn’t visible on chain. If the fresh prepare then gets rejected because the inputs are spent, the prior tx probably did make it out after all, so we keep looking for it on chain instead of failing the action.

OffboardTxPrepared

Offboard tx built by the server and validated by us; our forfeits are not signed yet — that happens inside the finish step, with fresh nonces on every attempt, so that this checkpoint stays value-deterministic across re-drives.

Fields

offboard_vtxo_ids: Vec<VtxoId>

offboard_tx: Transaction

forfeit_cosign_nonces: Vec<PublicNonce>

The server’s forfeit cosign nonces from the prepare response; stable across prepare replays.

movement_id: MovementId

ReadyForBroadcast

Fields

offboard_vtxo_ids: Vec<VtxoId>

signed_offboard_tx: Transaction

movement_id: MovementId

AwaitingConfirmations

Offboard tx broadcast; waiting for confirmation.

Fields

offboard_vtxo_ids: Vec<VtxoId>

offboard_txid: Txid

offboard_tx: Transaction

movement_id: MovementId

created_at: DateTime<Utc>

Trait Implementations

impl Clone for Progress

fn clone(&self) -> Progress

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Progress

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Progress

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Progress

impl PartialEq for Progress

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Progress

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 Progress