Struct lightning_invoice::payment::InvoicePayerUsingTime

pub struct InvoicePayerUsingTime<P: Deref, R: Router, S: Deref, L: Deref, E: EventHandler, T: Time>where
    P::Target: Payer,
    S::Target: for<'a> LockableScore<'a>,
    L::Target: Logger,{ /* private fields */ }

(C-not exported) generally all users should use the InvoicePayer type alias.

Implementations

impl<P: Deref, R: Router, S: Deref, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, S, L, E, T>where
    P::Target: Payer,
    S::Target: for<'a> LockableScore<'a>,
    L::Target: Logger,

pub fn new(
    payer: P,
    router: R,
    scorer: S,
    logger: L,
    event_handler: E,
    retry: Retry
) -> Self

Creates an invoice payer that retries failed payment paths.

Will forward any Event::PaymentPathFailed events to the decorated event_handler once retry has been exceeded for a given Invoice.

pub fn pay_invoice(&self, invoice: &Invoice) -> Result<PaymentId, PaymentError>

Pays the given Invoice, caching it for later use in case a retry is needed.

You should ensure that the invoice.payment_hash() is unique and the same payment_hash has never been paid before. Because InvoicePayer is stateless no effort is made to do so for you.

pub fn pay_zero_value_invoice(
    &self,
    invoice: &Invoice,
    amount_msats: u64
) -> Result<PaymentId, PaymentError>

Pays the given zero-value Invoice using the given amount, caching it for later use in case a retry is needed.

You should ensure that the invoice.payment_hash() is unique and the same payment_hash has never been paid before. Because InvoicePayer is stateless no effort is made to do so for you.

pub fn pay_pubkey(
    &self,
    pubkey: PublicKey,
    payment_preimage: PaymentPreimage,
    amount_msats: u64,
    final_cltv_expiry_delta: u32
) -> Result<PaymentId, PaymentError>

Pays pubkey an amount using the hash of the given preimage, caching it for later use in case a retry is needed.

You should ensure that payment_preimage is unique and that its payment_hash has never been paid before. Because InvoicePayer is stateless no effort is made to do so for you.

pub fn remove_cached_payment(&self, payment_hash: &PaymentHash)

Removes the payment cached by the given payment hash.

Should be called once a payment has failed or succeeded if not using InvoicePayer as an EventHandler. Otherwise, calling this method is unnecessary.

Trait Implementations

impl<P: Deref, R: Router, S: Deref, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, S, L, E, T>where
    P::Target: Payer,
    S::Target: for<'a> LockableScore<'a>,
    L::Target: Logger,

fn handle_event(&self, event: &Event)

Handles the given Event.