Enum PaymentKind

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

A fine-grained category for a payment. Useful for filtering payment history and analytics (e.g. regular Lightning payments vs. waived channel fees).

Each PaymentKind maps to exactly one parent PaymentRail via PaymentKind::rail().

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.

BuyCashApp

A buy funded via Cash App, where the app mints a BOLT11 invoice to receive the bought funds.

LightningAddress

A payment to or from a Lightning Address.

HumanBitcoinAddress

A payment to or from a BIP353 Human Bitcoin Address.

Unknown(Box<str>)

Unknown kind; used for forward compatibility.

Implementations

impl PaymentKind

pub const MAX_UNKNOWN_LEN: usize = 32usize

Max byte length of an Unknown kind string. Limits what a client can inject via an unrecognized kind field.

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.

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

Like expect_rail, but also accepts Unknown kinds (from a newer client). Lets a rail-specific request endpoint reject a recognized kind on the wrong rail while still accepting forward-compatible kinds.

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 = Error

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