Enum PaymentKind

pub enum PaymentKind {
    Onchain,
    Invoice,
    Offer,
    Spontaneous,
    WaivedChannelFee,
    WaivedLiquidityFee,
    Unknown(Box<str>),
}

A granular application-level ‘type’ of a payment.

In Lexe’s DB, payment information is encrypted, but this type is exposed. This is because without this type, the DB cannot identify which payments are relevant to a application level queries like

• “Show me my last N liquidity fee payments from this index”
• “Show me my history of channel opens and closes”
• “Show me the last N times I paid a channel fee.”

These payment kinds are also useful for accounting and analytics, allowing users to breakdown their payments history using fine-grained categories.

When implementing new kind of payment flows, err on the side of adding a new PaymentKind for it, instead of incorporating it into an existing kind. We can always add another OR in a WHERE clause, but cannot easily separate out data once it has already been unified.

Variants

Onchain

A regular on-chain send or receive. All v1 on-chain payments which had no kind are given this kind.

Invoice

A regular Lightning send or receive. All v1 invoice payments which had no kind are given this kind.

Offer

A regular Lightning offer payment. All v1 offer payments which had no kind are given this kind.

Spontaneous

A regular Lightning spontaneous payment. All v1 spontaneous payments which had no kind are given this kind.

WaivedChannelFee

A channel fee that would have been paid but was waived.

WaivedLiquidityFee

A liquidity fee that would have been paid but was waived.

Unknown(Box<str>)

Unknown kind; used for forward compatibility.

Implementations

impl PaymentKind

pub const KNOWN_VARIANTS: &'static [PaymentKind]

All non-unknown variants.

pub fn to_str(&self) -> Cow<'static, str>

pub fn rail(&self) -> PaymentRail

pub fn expect_rail(&self, expected: PaymentRail) -> Result<(), Error>

Validates this payment kind against an expected parent rail.

Trait Implementations

impl Clone for PaymentKind

fn clone(&self) -> PaymentKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PaymentKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PaymentKind

where PaymentKind: FromStr, <PaymentKind as FromStr>::Err: Display,

fn deserialize<__D>( deserializer: __D, ) -> Result<PaymentKind, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PaymentKind

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

Formats the value using the given formatter.

impl FromStr for PaymentKind

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<PaymentKind, <PaymentKind as FromStr>::Err>

Parses a string s to return a value of this type.

impl PartialEq for PaymentKind

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

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PaymentKind

impl StructuralPartialEq for PaymentKind