Struct LightningBalance 

pub struct LightningBalance {
    pub usable: Amount,
    pub sendable: Amount,
    pub max_sendable: Amount,
    pub pending: Amount,
}

Classify the lightning channel balances into different categories.

Fields

usable: Amount

The sum channel value that is usable.

For example, if we have an open channel with a disconnected node, then we can’t send over it; it would not be counted here.

sendable: Amount

Our most accurate estimation of how much we can currently send if we made a MPP over all usable channels to an unspecified recipient.

It’s the sum of next_outbound_htlc_limit over all channels adjusted to account for an estimate of the total fees paid to Lexe’s LSP and the broader Lightning Network.

It’s intended to be a conservative estimate, so the user should usually be able to send this amount. A precise sendable upper bound is not computable without knowledge of the recipient because routing fees vary by path.

This value is bounded above by Self::max_sendable.

max_sendable: Amount

The maximum amount that we could possibly send in a ‘typical’ payment, i.e. a multi-hop payment to anyone who is not a direct counterparty.

This is computed as the sum of next_outbound_htlc_limit over all usable channels, then adjusted to account for the minimum fees Lexe’s LSP could charge us.

• It should not be possible to send more than this amount over any multi-hop payment.
• Exactly this amount may be sendable only in very specific scenarios, such as paying another Lexe user.
• Technically, it is possible to send [sum(next_outbound_htlc_limit)] to our direct channel counterparties, but since User <-> LSP payments are a special case, we’ll handle those flows differently.

pending: Amount

The sum channel value that isn’t currently usable.

The channel may be (1) opening and await confirmation, (2) shutting down, or (3) confirmed but the peer is disconnected.

Implementations

impl LightningBalance

pub const ZERO: Self

pub fn total(&self) -> Amount

Get the sum total of all our known channel balances.

Trait Implementations

impl Clone for LightningBalance

fn clone(&self) -> LightningBalance

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LightningBalance

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

Formats the value using the given formatter.

impl Default for LightningBalance

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LightningBalance

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LightningBalance

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for LightningBalance

impl StructuralPartialEq for LightningBalance