Struct Balance 

pub struct Balance {
    pub spendable: Amount,
    pub pending_lightning_send: Amount,
    pub claimable_lightning_receive: Amount,
    pub pending_in_round: Amount,
    pub pending_board: Amount,
    pub pending_exit: Option<Amount>,
}

The different balances of a Bark wallet, broken down by state.

All amounts are in sats.

Fields

spendable: Amount

Sats that are immediately spendable, either in-round or out-of-round.

pending_lightning_send: Amount

Sats locked in an outgoing Lightning payment that has not yet settled.

claimable_lightning_receive: Amount

Sats from an incoming Lightning payment that can be claimed but have not yet been swept into a spendable VTXO.

pending_in_round: Amount

Sats locked in VTXOs forfeited for a round that has not yet completed.

pending_board: Amount

Sats in board transactions that are waiting for sufficient on-chain confirmations before becoming spendable.

pending_exit: Option<Amount>

Sats held in VTXOs whose unilateral exit chain is confirmed on-chain but which haven’t yet been drained to the onchain wallet. Equivalent to the sum of Exited VTXOs whose exit state hasn’t reached Claimed. null if the exit subsystem is unavailable.

Trait Implementations

impl Clone for Balance

fn clone(&self) -> Balance

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Balance

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Balance

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Balance

impl From<Balance> for Balance

fn from(v: Balance) -> Self

Converts to this type from the input type.

impl PartialEq for Balance

fn eq(&self, other: &Balance) -> 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 Balance

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 Balance