X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-invoice%2Fsrc%2Fpayment.rs;h=4fddedc0c0749e908889fcdc82db028c877c4612;hb=4a0010d7393bb32305bdb3d859735b7b563462eb;hp=e7cc43508d933bb795d02d7b8e50bdd047dd8320;hpb=00f08c910ff87fecc580750df33d3ebf5ac1fceb;p=rust-lightning diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index e7cc4350..4fddedc0 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -15,9 +15,10 @@ //! and payee using information provided by the payer and from the payee's [`Invoice`], when //! applicable. //! -//! [`InvoicePayer`] is parameterized by a [`LockableScore`], which it uses for scoring failed and -//! successful payment paths upon receiving [`Event::PaymentPathFailed`] and -//! [`Event::PaymentPathSuccessful`] events, respectively. +//! [`InvoicePayer`] uses its [`Router`] parameterization for optionally notifying scorers upon +//! receiving the [`Event::PaymentPathFailed`] and [`Event::PaymentPathSuccessful`] events. +//! It also does the same for payment probe failure and success events using [`Event::ProbeFailed`] +//! and [`Event::ProbeSuccessful`]. //! //! [`InvoicePayer`] is capable of retrying failed payments. It accomplishes this by implementing //! [`EventHandler`] which decorates a user-provided handler. It will intercept any @@ -32,29 +33,22 @@ //! # extern crate lightning_invoice; //! # extern crate secp256k1; //! # -//! # #[cfg(feature = "no-std")] -//! # extern crate core2; -//! # +//! # use lightning::io; //! # use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure}; //! # use lightning::ln::msgs::LightningError; //! # use lightning::routing::gossip::NodeId; -//! # use lightning::routing::router::{Route, RouteHop, RouteParameters}; +//! # use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router}; //! # use lightning::routing::scoring::{ChannelUsage, Score}; //! # use lightning::util::events::{Event, EventHandler, EventsProvider}; //! # use lightning::util::logger::{Logger, Record}; //! # use lightning::util::ser::{Writeable, Writer}; //! # use lightning_invoice::Invoice; -//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, Router}; +//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry}; //! # use secp256k1::PublicKey; //! # use std::cell::RefCell; //! # use std::ops::Deref; //! # -//! # #[cfg(not(feature = "std"))] -//! # use core2::io; -//! # #[cfg(feature = "std")] -//! # use std::io; -//! # //! # struct FakeEventProvider {} //! # impl EventsProvider for FakeEventProvider { //! # fn process_pending_events(&self, handler: H) where H::Target: EventHandler {} @@ -65,23 +59,29 @@ //! # fn node_id(&self) -> PublicKey { unimplemented!() } //! # fn first_hops(&self) -> Vec { unimplemented!() } //! # fn send_payment( -//! # &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option -//! # ) -> Result { unimplemented!() } +//! # &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option, +//! # payment_id: PaymentId +//! # ) -> Result<(), PaymentSendFailure> { unimplemented!() } //! # fn send_spontaneous_payment( -//! # &self, route: &Route, payment_preimage: PaymentPreimage -//! # ) -> Result { unimplemented!() } +//! # &self, route: &Route, payment_preimage: PaymentPreimage, payment_id: PaymentId, +//! # ) -> Result<(), PaymentSendFailure> { unimplemented!() } //! # fn retry_payment( //! # &self, route: &Route, payment_id: PaymentId //! # ) -> Result<(), PaymentSendFailure> { unimplemented!() } //! # fn abandon_payment(&self, payment_id: PaymentId) { unimplemented!() } +//! # fn inflight_htlcs(&self) -> InFlightHtlcs { unimplemented!() } //! # } //! # //! # struct FakeRouter {} //! # impl Router for FakeRouter { -//! # fn find_route( -//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash, -//! # first_hops: Option<&[&ChannelDetails]>, scorer: &S +//! # fn find_route( +//! # &self, payer: &PublicKey, params: &RouteParameters, +//! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs //! # ) -> Result { unimplemented!() } +//! # fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() } +//! # fn notify_payment_path_successful(&self, path: &[&RouteHop]) { unimplemented!() } +//! # fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { unimplemented!() } +//! # fn notify_payment_probe_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() } //! # } //! # //! # struct FakeScorer {} @@ -104,7 +104,7 @@ //! # } //! # //! # fn main() { -//! let event_handler = |event: &Event| { +//! let event_handler = |event: Event| { //! match event { //! Event::PaymentPathFailed { .. } => println!("payment failed after retries"), //! Event::PaymentSent { .. } => println!("payment successful"), @@ -115,7 +115,7 @@ //! # let router = FakeRouter {}; //! # let scorer = RefCell::new(FakeScorer {}); //! # let logger = FakeLogger {}; -//! let invoice_payer = InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); +//! let invoice_payer = InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); //! //! let invoice = "..."; //! if let Ok(invoice) = invoice.parse::() { @@ -144,19 +144,17 @@ use crate::prelude::*; use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure}; use lightning::ln::msgs::LightningError; -use lightning::routing::gossip::NodeId; -use lightning::routing::scoring::{ChannelUsage, LockableScore, Score}; -use lightning::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters}; -use lightning::util::errors::APIError; +use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteParameters, Router}; use lightning::util::events::{Event, EventHandler}; use lightning::util::logger::Logger; -use time_utils::Time; +use crate::time_utils::Time; use crate::sync::Mutex; use secp256k1::PublicKey; use core::fmt; use core::fmt::{Debug, Display, Formatter}; +use core::future::Future; use core::ops::Deref; use core::time::Duration; #[cfg(feature = "std")] @@ -167,91 +165,42 @@ use std::time::SystemTime; /// See [module-level documentation] for details. /// /// [module-level documentation]: crate::payment -pub type InvoicePayer = InvoicePayerUsingTime::; +pub type InvoicePayer = InvoicePayerUsingTime::; #[cfg(not(feature = "no-std"))] type ConfiguredTime = std::time::Instant; #[cfg(feature = "no-std")] -use time_utils; +use crate::time_utils; #[cfg(feature = "no-std")] type ConfiguredTime = time_utils::Eternity; +/// Sealed trait with a blanket implementation to allow both sync and async implementations of event +/// handling to exist within the InvoicePayer. +mod sealed { + pub trait BaseEventHandler {} + impl BaseEventHandler for T {} +} + /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias. -pub struct InvoicePayerUsingTime -where +pub struct InvoicePayerUsingTime< + P: Deref, + R: Router, + L: Deref, + E: sealed::BaseEventHandler, + T: Time +> where P::Target: Payer, - S::Target: for <'a> LockableScore<'a>, L::Target: Logger, { payer: P, router: R, - scorer: S, logger: L, event_handler: E, /// Caches the overall attempts at making a payment, which is updated prior to retrying. - payment_cache: Mutex>>, + payment_cache: Mutex>>, retry: Retry, } -/// Used by [`InvoicePayerUsingTime::payment_cache`] to track the payments that are either -/// currently being made, or have outstanding paths that need retrying. -struct PaymentInfo { - attempts: PaymentAttempts, - paths: Vec>, -} - -impl PaymentInfo { - fn new() -> Self { - PaymentInfo { - attempts: PaymentAttempts::new(), - paths: vec![], - } - } -} - -/// Used to store information about all the HTLCs that are inflight across all payment attempts -struct AccountForInFlightHtlcs<'a, S: Score> { - scorer: &'a mut S, - /// Maps a channel's short channel id and its direction to the liquidity used up. - inflight_htlcs: HashMap<(u64, bool), u64>, -} - -#[cfg(c_bindings)] -impl<'a, S:Score> lightning::util::ser::Writeable for AccountForInFlightHtlcs<'a, S> { - fn write(&self, writer: &mut W) -> Result<(), std::io::Error> { self.scorer.write(writer) } -} - -impl<'a, S: Score> Score for AccountForInFlightHtlcs<'a, S> { - fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage) -> u64 { - if let Some(used_liqudity) = self.inflight_htlcs.get(&(short_channel_id, source < target)) { - let usage = ChannelUsage { - inflight_htlc_msat: usage.inflight_htlc_msat + used_liqudity, - ..usage - }; - - self.scorer.channel_penalty_msat(short_channel_id, source, target, usage) - } else { - self.scorer.channel_penalty_msat(short_channel_id, source, target, usage) - } - } - - fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) { - self.scorer.payment_path_failed(path, short_channel_id) - } - - fn payment_path_successful(&mut self, path: &[&RouteHop]) { - self.scorer.payment_path_successful(path) - } - - fn probe_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) { - self.scorer.probe_failed(path, short_channel_id) - } - - fn probe_successful(&mut self, path: &[&RouteHop]) { - self.scorer.probe_successful(path) - } -} - /// Storing minimal payment attempts information required for determining if a outbound payment can /// be retried. #[derive(Clone, Copy)] @@ -287,6 +236,18 @@ impl Display for PaymentAttempts { } /// A trait defining behavior of an [`Invoice`] payer. +/// +/// While the behavior of [`InvoicePayer`] provides idempotency of duplicate `send_*payment` calls +/// with the same [`PaymentHash`], it is up to the `Payer` to provide idempotency across restarts. +/// +/// [`ChannelManager`] provides idempotency for duplicate payments with the same [`PaymentId`]. +/// +/// In order to trivially ensure idempotency for payments, the default `Payer` implementation +/// reuses the [`PaymentHash`] bytes as the [`PaymentId`]. Custom implementations wishing to +/// provide payment idempotency with a different idempotency key (i.e. [`PaymentId`]) should map +/// the [`Invoice`] or spontaneous payment target pubkey to their own idempotency key. +/// +/// [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager pub trait Payer { /// Returns the payer's node id. fn node_id(&self) -> PublicKey; @@ -296,28 +257,24 @@ pub trait Payer { /// Sends a payment over the Lightning Network using the given [`Route`]. fn send_payment( - &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option - ) -> Result; + &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option, + payment_id: PaymentId + ) -> Result<(), PaymentSendFailure>; /// Sends a spontaneous payment over the Lightning Network using the given [`Route`]. fn send_spontaneous_payment( - &self, route: &Route, payment_preimage: PaymentPreimage - ) -> Result; + &self, route: &Route, payment_preimage: PaymentPreimage, payment_id: PaymentId + ) -> Result<(), PaymentSendFailure>; /// Retries a failed payment path for the [`PaymentId`] using the given [`Route`]. fn retry_payment(&self, route: &Route, payment_id: PaymentId) -> Result<(), PaymentSendFailure>; /// Signals that no further retries for the given payment will occur. fn abandon_payment(&self, payment_id: PaymentId); -} -/// A trait defining behavior for routing an [`Invoice`] payment. -pub trait Router { - /// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. - fn find_route( - &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash, - first_hops: Option<&[&ChannelDetails]>, scorer: &S - ) -> Result; + /// Construct an [`InFlightHtlcs`] containing information about currently used up liquidity + /// across payments. + fn inflight_htlcs(&self) -> InFlightHtlcs; } /// Strategies available to retry payment path failures for an [`Invoice`]. @@ -359,10 +316,10 @@ pub enum PaymentError { Sending(PaymentSendFailure), } -impl InvoicePayerUsingTime +impl + InvoicePayerUsingTime where P::Target: Payer, - S::Target: for <'a> LockableScore<'a>, L::Target: Logger, { /// Creates an invoice payer that retries failed payment paths. @@ -370,12 +327,11 @@ where /// Will forward any [`Event::PaymentPathFailed`] events to the decorated `event_handler` once /// `retry` has been exceeded for a given [`Invoice`]. pub fn new( - payer: P, router: R, scorer: S, logger: L, event_handler: E, retry: Retry + payer: P, router: R, logger: L, event_handler: E, retry: Retry ) -> Self { Self { payer, router, - scorer, logger, event_handler, payment_cache: Mutex::new(HashMap::new()), @@ -385,42 +341,82 @@ where /// 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. + /// [`Invoice::payment_hash`] is used as the [`PaymentId`], which ensures idempotency as long + /// as the payment is still pending. Once the payment completes or fails, you must ensure that + /// a second payment with the same [`PaymentHash`] is never sent. + /// + /// If you wish to use a different payment idempotency token, see + /// [`Self::pay_invoice_with_id`]. pub fn pay_invoice(&self, invoice: &Invoice) -> Result { + let payment_id = PaymentId(invoice.payment_hash().into_inner()); + self.pay_invoice_with_id(invoice, payment_id).map(|()| payment_id) + } + + /// Pays the given [`Invoice`] with a custom idempotency key, caching the invoice for later use + /// in case a retry is needed. + /// + /// Note that idempotency is only guaranteed as long as the payment is still pending. Once the + /// payment completes or fails, no idempotency guarantees are made. + /// + /// You should ensure that the [`Invoice::payment_hash`] is unique and the same [`PaymentHash`] + /// has never been paid before. + /// + /// See [`Self::pay_invoice`] for a variant which uses the [`PaymentHash`] for the idempotency + /// token. + pub fn pay_invoice_with_id(&self, invoice: &Invoice, payment_id: PaymentId) -> Result<(), PaymentError> { if invoice.amount_milli_satoshis().is_none() { Err(PaymentError::Invoice("amount missing")) } else { - self.pay_invoice_using_amount(invoice, None) + self.pay_invoice_using_amount(invoice, None, payment_id) } } /// 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. + /// [`Invoice::payment_hash`] is used as the [`PaymentId`], which ensures idempotency as long + /// as the payment is still pending. Once the payment completes or fails, you must ensure that + /// a second payment with the same [`PaymentHash`] is never sent. + /// + /// If you wish to use a different payment idempotency token, see + /// [`Self::pay_zero_value_invoice_with_id`]. pub fn pay_zero_value_invoice( &self, invoice: &Invoice, amount_msats: u64 ) -> Result { + let payment_id = PaymentId(invoice.payment_hash().into_inner()); + self.pay_zero_value_invoice_with_id(invoice, amount_msats, payment_id).map(|()| payment_id) + } + + /// Pays the given zero-value [`Invoice`] using the given amount and custom idempotency key, + /// caching the invoice for later use in case a retry is needed. + /// + /// Note that idempotency is only guaranteed as long as the payment is still pending. Once the + /// payment completes or fails, no idempotency guarantees are made. + /// + /// You should ensure that the [`Invoice::payment_hash`] is unique and the same [`PaymentHash`] + /// has never been paid before. + /// + /// See [`Self::pay_zero_value_invoice`] for a variant which uses the [`PaymentHash`] for the + /// idempotency token. + pub fn pay_zero_value_invoice_with_id( + &self, invoice: &Invoice, amount_msats: u64, payment_id: PaymentId + ) -> Result<(), PaymentError> { if invoice.amount_milli_satoshis().is_some() { Err(PaymentError::Invoice("amount unexpected")) } else { - self.pay_invoice_using_amount(invoice, Some(amount_msats)) + self.pay_invoice_using_amount(invoice, Some(amount_msats), payment_id) } } fn pay_invoice_using_amount( - &self, invoice: &Invoice, amount_msats: Option - ) -> Result { + &self, invoice: &Invoice, amount_msats: Option, payment_id: PaymentId + ) -> Result<(), PaymentError> { debug_assert!(invoice.amount_milli_satoshis().is_some() ^ amount_msats.is_some()); let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); match self.payment_cache.lock().unwrap().entry(payment_hash) { hash_map::Entry::Occupied(_) => return Err(PaymentError::Invoice("payment pending")), - hash_map::Entry::Vacant(entry) => entry.insert(PaymentInfo::new()), + hash_map::Entry::Vacant(entry) => entry.insert(PaymentAttempts::new()), }; let payment_secret = Some(invoice.payment_secret().clone()); @@ -437,7 +433,7 @@ where }; let send_payment = |route: &Route| { - self.payer.send_payment(route, payment_hash, &payment_secret) + self.payer.send_payment(route, payment_hash, &payment_secret, payment_id) }; self.pay_internal(&route_params, payment_hash, send_payment) @@ -447,16 +443,44 @@ where /// 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. + /// The hash of the [`PaymentPreimage`] is used as the [`PaymentId`], which ensures idempotency + /// as long as the payment is still pending. Once the payment completes or fails, you must + /// ensure that a second payment with the same [`PaymentPreimage`] is never sent. pub fn pay_pubkey( &self, pubkey: PublicKey, payment_preimage: PaymentPreimage, amount_msats: u64, final_cltv_expiry_delta: u32 ) -> Result { let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner()); + let payment_id = PaymentId(payment_hash.0); + self.do_pay_pubkey(pubkey, payment_preimage, payment_hash, payment_id, amount_msats, + final_cltv_expiry_delta) + .map(|()| payment_id) + } + + /// Pays `pubkey` an amount using the hash of the given preimage and a custom idempotency key, + /// caching the invoice for later use in case a retry is needed. + /// + /// Note that idempotency is only guaranteed as long as the payment is still pending. Once the + /// payment completes or fails, no idempotency guarantees are made. + /// + /// You should ensure that the [`PaymentPreimage`] is unique and the corresponding + /// [`PaymentHash`] has never been paid before. + pub fn pay_pubkey_with_id( + &self, pubkey: PublicKey, payment_preimage: PaymentPreimage, payment_id: PaymentId, + amount_msats: u64, final_cltv_expiry_delta: u32 + ) -> Result<(), PaymentError> { + let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner()); + self.do_pay_pubkey(pubkey, payment_preimage, payment_hash, payment_id, amount_msats, + final_cltv_expiry_delta) + } + + fn do_pay_pubkey( + &self, pubkey: PublicKey, payment_preimage: PaymentPreimage, payment_hash: PaymentHash, + payment_id: PaymentId, amount_msats: u64, final_cltv_expiry_delta: u32 + ) -> Result<(), PaymentError> { match self.payment_cache.lock().unwrap().entry(payment_hash) { hash_map::Entry::Occupied(_) => return Err(PaymentError::Invoice("payment pending")), - hash_map::Entry::Vacant(entry) => entry.insert(PaymentInfo::new()), + hash_map::Entry::Vacant(entry) => entry.insert(PaymentAttempts::new()), }; let route_params = RouteParameters { @@ -466,15 +490,15 @@ where }; let send_payment = |route: &Route| { - self.payer.send_spontaneous_payment(route, payment_preimage) + self.payer.send_spontaneous_payment(route, payment_preimage, payment_id) }; self.pay_internal(&route_params, payment_hash, send_payment) .map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e }) } - fn pay_internal Result + Copy>( + fn pay_internal Result<(), PaymentSendFailure> + Copy>( &self, params: &RouteParameters, payment_hash: PaymentHash, send_payment: F, - ) -> Result { + ) -> Result<(), PaymentError> { #[cfg(feature = "std")] { if has_expired(params) { log_trace!(self.logger, "Invoice expired prior to send for payment {}", log_bytes!(payment_hash.0)); @@ -484,95 +508,58 @@ where let payer = self.payer.node_id(); let first_hops = self.payer.first_hops(); - let inflight_htlcs = self.create_inflight_map(); + let inflight_htlcs = self.payer.inflight_htlcs(); let route = self.router.find_route( - &payer, ¶ms, &payment_hash, Some(&first_hops.iter().collect::>()), - &AccountForInFlightHtlcs { scorer: &mut self.scorer.lock(), inflight_htlcs } + &payer, ¶ms, Some(&first_hops.iter().collect::>()), inflight_htlcs ).map_err(|e| PaymentError::Routing(e))?; match send_payment(&route) { - Ok(payment_id) => { - for path in route.paths { - self.process_path_inflight_htlcs(payment_hash, path); - } - Ok(payment_id) - }, + Ok(()) => Ok(()), Err(e) => match e { PaymentSendFailure::ParameterError(_) => Err(e), PaymentSendFailure::PathParameterError(_) => Err(e), - PaymentSendFailure::AllFailedRetrySafe(_) => { + PaymentSendFailure::DuplicatePayment => Err(e), + PaymentSendFailure::AllFailedResendSafe(_) => { let mut payment_cache = self.payment_cache.lock().unwrap(); - let payment_info = payment_cache.get_mut(&payment_hash).unwrap(); - payment_info.attempts.count += 1; - if self.retry.is_retryable_now(&payment_info.attempts) { + let payment_attempts = payment_cache.get_mut(&payment_hash).unwrap(); + payment_attempts.count += 1; + if self.retry.is_retryable_now(payment_attempts) { core::mem::drop(payment_cache); Ok(self.pay_internal(params, payment_hash, send_payment)?) } else { Err(e) } }, - PaymentSendFailure::PartialFailure { failed_paths_retry, payment_id, results } => { - // If a `PartialFailure` event returns a result that is an `Ok()`, it means that - // part of our payment is retried. When we receive `MonitorUpdateFailed`, it - // means that we are still waiting for our channel monitor update to be completed. - for (result, path) in results.iter().zip(route.paths.into_iter()) { - match result { - Ok(_) | Err(APIError::MonitorUpdateFailed) => { - self.process_path_inflight_htlcs(payment_hash, path); - }, - _ => {}, - } - } - + PaymentSendFailure::PartialFailure { failed_paths_retry, payment_id, .. } => { if let Some(retry_data) = failed_paths_retry { // Some paths were sent, even if we failed to send the full MPP value our // recipient may misbehave and claim the funds, at which point we have to // consider the payment sent, so return `Ok()` here, ignoring any retry // errors. let _ = self.retry_payment(payment_id, payment_hash, &retry_data); - Ok(payment_id) + Ok(()) } else { // This may happen if we send a payment and some paths fail, but // only due to a temporary monitor failure or the like, implying // they're really in-flight, but we haven't sent the initial // HTLC-Add messages yet. - Ok(payment_id) + Ok(()) } }, }, }.map_err(|e| PaymentError::Sending(e)) } - // Takes in a path to have its information stored in `payment_cache`. This is done for paths - // that are pending retry. - fn process_path_inflight_htlcs(&self, payment_hash: PaymentHash, path: Vec) { - self.payment_cache.lock().unwrap().entry(payment_hash) - .or_insert_with(|| PaymentInfo::new()) - .paths.push(path); - } - - // Find the path we want to remove in `payment_cache`. If it doesn't exist, do nothing. - fn remove_path_inflight_htlcs(&self, payment_hash: PaymentHash, path: &Vec) { - self.payment_cache.lock().unwrap().entry(payment_hash) - .and_modify(|payment_info| { - if let Some(idx) = payment_info.paths.iter().position(|p| p == path) { - payment_info.paths.swap_remove(idx); - } - }); - } - fn retry_payment( &self, payment_id: PaymentId, payment_hash: PaymentHash, params: &RouteParameters ) -> Result<(), ()> { - let attempts = self.payment_cache.lock().unwrap().entry(payment_hash) - .and_modify(|info| info.attempts.count += 1 ) - .or_insert_with(|| PaymentInfo { - attempts: PaymentAttempts { + let attempts = + *self.payment_cache.lock().unwrap().entry(payment_hash) + .and_modify(|attempts| attempts.count += 1) + .or_insert(PaymentAttempts { count: 1, - first_attempted_at: T::now(), - }, - paths: vec![], - }).attempts; + first_attempted_at: T::now() + }); if !self.retry.is_retryable_now(&attempts) { log_trace!(self.logger, "Payment {} exceeded maximum attempts; not retrying ({})", log_bytes!(payment_hash.0), attempts); @@ -588,11 +575,10 @@ where let payer = self.payer.node_id(); let first_hops = self.payer.first_hops(); - let inflight_htlcs = self.create_inflight_map(); + let inflight_htlcs = self.payer.inflight_htlcs(); let route = self.router.find_route( - &payer, ¶ms, &payment_hash, Some(&first_hops.iter().collect::>()), - &AccountForInFlightHtlcs { scorer: &mut self.scorer.lock(), inflight_htlcs } + &payer, ¶ms, Some(&first_hops.iter().collect::>()), inflight_htlcs ); if route.is_err() { @@ -601,33 +587,20 @@ where } match self.payer.retry_payment(&route.as_ref().unwrap(), payment_id) { - Ok(()) => { - for path in route.unwrap().paths.into_iter() { - self.process_path_inflight_htlcs(payment_hash, path); - } - Ok(()) - }, + Ok(()) => Ok(()), Err(PaymentSendFailure::ParameterError(_)) | Err(PaymentSendFailure::PathParameterError(_)) => { log_trace!(self.logger, "Failed to retry for payment {} due to bogus route/payment data, not retrying.", log_bytes!(payment_hash.0)); Err(()) }, - Err(PaymentSendFailure::AllFailedRetrySafe(_)) => { + Err(PaymentSendFailure::AllFailedResendSafe(_)) => { self.retry_payment(payment_id, payment_hash, params) }, - Err(PaymentSendFailure::PartialFailure { failed_paths_retry, results, .. }) => { - // If a `PartialFailure` error contains a result that is an `Ok()`, it means that - // part of our payment is retried. When we receive `MonitorUpdateFailed`, it - // means that we are still waiting for our channel monitor update to complete. - for (result, path) in results.iter().zip(route.unwrap().paths.into_iter()) { - match result { - Ok(_) | Err(APIError::MonitorUpdateFailed) => { - self.process_path_inflight_htlcs(payment_hash, path); - }, - _ => {}, - } - } - + Err(PaymentSendFailure::DuplicatePayment) => { + log_error!(self.logger, "Got a DuplicatePayment error when attempting to retry a payment, this shouldn't happen."); + Err(()) + } + Err(PaymentSendFailure::PartialFailure { failed_paths_retry, .. }) => { if let Some(retry) = failed_paths_retry { // Always return Ok for the same reason as noted in pay_internal. let _ = self.retry_payment(payment_id, payment_hash, &retry); @@ -644,47 +617,6 @@ where pub fn remove_cached_payment(&self, payment_hash: &PaymentHash) { self.payment_cache.lock().unwrap().remove(payment_hash); } - - /// Given a [`PaymentHash`], this function looks up inflight path attempts in the payment_cache. - /// Then, it uses the path information inside the cache to construct a HashMap mapping a channel's - /// short channel id and direction to the amount being sent through it. - /// - /// This function should be called whenever we need information about currently used up liquidity - /// across payments. - fn create_inflight_map(&self) -> HashMap<(u64, bool), u64> { - let mut total_inflight_map: HashMap<(u64, bool), u64> = HashMap::new(); - // Make an attempt at finding existing payment information from `payment_cache`. If it - // does not exist, it probably is a fresh payment and we can just return an empty - // HashMap. - for payment_info in self.payment_cache.lock().unwrap().values() { - for path in &payment_info.paths { - if path.is_empty() { break }; - // total_inflight_map needs to be direction-sensitive when keeping track of the HTLC value - // that is held up. However, the `hops` array, which is a path returned by `find_route` in - // the router excludes the payer node. In the following lines, the payer's information is - // hardcoded with an inflight value of 0 so that we can correctly represent the first hop - // in our sliding window of two. - let our_node_id: PublicKey = self.payer.node_id(); - let reversed_hops_with_payer = path.iter().rev().skip(1) - .map(|hop| hop.pubkey) - .chain(core::iter::once(our_node_id)); - let mut cumulative_msat = 0; - - // Taking the reversed vector from above, we zip it with just the reversed hops list to - // work "backwards" of the given path, since the last hop's `fee_msat` actually represents - // the total amount sent. - for (next_hop, prev_hop) in path.iter().rev().zip(reversed_hops_with_payer) { - cumulative_msat += next_hop.fee_msat; - total_inflight_map - .entry((next_hop.short_channel_id, NodeId::from_pubkey(&prev_hop) < NodeId::from_pubkey(&next_hop.pubkey))) - .and_modify(|used_liquidity_msat| *used_liquidity_msat += cumulative_msat) - .or_insert(cumulative_msat); - } - } - } - - total_inflight_map - } } fn expiry_time_from_unix_epoch(invoice: &Invoice) -> Duration { @@ -698,35 +630,27 @@ fn has_expired(route_params: &RouteParameters) -> bool { } else { false } } -impl EventHandler for InvoicePayerUsingTime +impl + InvoicePayerUsingTime where P::Target: Payer, - S::Target: for <'a> LockableScore<'a>, L::Target: Logger, { - fn handle_event(&self, event: &Event) { - match event { - Event::PaymentPathFailed { payment_hash, path, .. } - | Event::PaymentPathSuccessful { path, payment_hash: Some(payment_hash), .. } - | Event::ProbeSuccessful { payment_hash, path, .. } - | Event::ProbeFailed { payment_hash, path, .. } => { - self.remove_path_inflight_htlcs(*payment_hash, path); - }, - _ => {}, - } - + /// Returns a bool indicating whether the processed event should be forwarded to a user-provided + /// event handler. + fn handle_event_internal(&self, event: &Event) -> bool { match event { Event::PaymentPathFailed { - payment_id, payment_hash, rejected_by_dest, path, short_channel_id, retry, .. + payment_id, payment_hash, payment_failed_permanently, path, short_channel_id, retry, .. } => { if let Some(short_channel_id) = short_channel_id { let path = path.iter().collect::>(); - self.scorer.lock().payment_path_failed(&path, *short_channel_id); + self.router.notify_payment_path_failed(&path, *short_channel_id) } if payment_id.is_none() { log_trace!(self.logger, "Payment {} has no id; not retrying", log_bytes!(payment_hash.0)); - } else if *rejected_by_dest { + } else if *payment_failed_permanently { log_trace!(self.logger, "Payment {} rejected by destination; not retrying", log_bytes!(payment_hash.0)); self.payer.abandon_payment(payment_id.unwrap()); } else if retry.is_none() { @@ -734,7 +658,7 @@ where self.payer.abandon_payment(payment_id.unwrap()); } else if self.retry_payment(payment_id.unwrap(), *payment_hash, retry.as_ref().unwrap()).is_ok() { // We retried at least somewhat, don't provide the PaymentPathFailed event to the user. - return; + return false; } else { self.payer.abandon_payment(payment_id.unwrap()); } @@ -744,32 +668,62 @@ where }, Event::PaymentPathSuccessful { path, .. } => { let path = path.iter().collect::>(); - self.scorer.lock().payment_path_successful(&path); + self.router.notify_payment_path_successful(&path); }, Event::PaymentSent { payment_hash, .. } => { let mut payment_cache = self.payment_cache.lock().unwrap(); let attempts = payment_cache .remove(payment_hash) - .map_or(1, |payment_info| payment_info.attempts.count + 1); + .map_or(1, |attempts| attempts.count + 1); log_trace!(self.logger, "Payment {} succeeded (attempts: {})", log_bytes!(payment_hash.0), attempts); }, Event::ProbeSuccessful { payment_hash, path, .. } => { log_trace!(self.logger, "Probe payment {} of {}msat was successful", log_bytes!(payment_hash.0), path.last().unwrap().fee_msat); let path = path.iter().collect::>(); - self.scorer.lock().probe_successful(&path); + self.router.notify_payment_probe_successful(&path); }, Event::ProbeFailed { payment_hash, path, short_channel_id, .. } => { if let Some(short_channel_id) = short_channel_id { log_trace!(self.logger, "Probe payment {} of {}msat failed at channel {}", log_bytes!(payment_hash.0), path.last().unwrap().fee_msat, *short_channel_id); let path = path.iter().collect::>(); - self.scorer.lock().probe_failed(&path, *short_channel_id); + self.router.notify_payment_probe_failed(&path, *short_channel_id); } }, _ => {}, } // Delegate to the decorated event handler unless the payment is retried. - self.event_handler.handle_event(event) + true + } +} + +impl + EventHandler for InvoicePayerUsingTime +where + P::Target: Payer, + L::Target: Logger, +{ + fn handle_event(&self, event: Event) { + let should_forward = self.handle_event_internal(&event); + if should_forward { + self.event_handler.handle_event(event) + } + } +} + +impl F> + InvoicePayerUsingTime +where + P::Target: Payer, + L::Target: Logger, +{ + /// Intercepts events required by the [`InvoicePayer`] and forwards them to the underlying event + /// handler, if necessary, to handle them asynchronously. + pub async fn handle_event_async(&self, event: Event) { + let should_forward = self.handle_event_internal(&event); + if should_forward { + (self.event_handler)(event).await; + } } } @@ -777,25 +731,26 @@ where mod tests { use super::*; use crate::{InvoiceBuilder, Currency}; - use utils::create_invoice_from_channelmanager_and_duration_since_epoch; + use crate::utils::create_invoice_from_channelmanager_and_duration_since_epoch; use bitcoin_hashes::sha256::Hash as Sha256; use lightning::ln::PaymentPreimage; - use lightning::ln::features::{ChannelFeatures, NodeFeatures, InitFeatures}; + use lightning::ln::channelmanager; + use lightning::ln::features::{ChannelFeatures, NodeFeatures}; use lightning::ln::functional_test_utils::*; use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError}; use lightning::routing::gossip::{EffectiveCapacity, NodeId}; - use lightning::routing::router::{PaymentParameters, Route, RouteHop}; - use lightning::routing::scoring::ChannelUsage; + use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router, ScorerAccountingForInFlightHtlcs}; + use lightning::routing::scoring::{ChannelUsage, LockableScore, Score}; use lightning::util::test_utils::TestLogger; use lightning::util::errors::APIError; use lightning::util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider}; use secp256k1::{SecretKey, PublicKey, Secp256k1}; use std::cell::RefCell; use std::collections::VecDeque; + use std::ops::DerefMut; use std::time::{SystemTime, Duration}; - use time_utils::tests::SinceEpoch; - use DEFAULT_EXPIRY_TIME; - use lightning::util::errors::APIError::{ChannelUnavailable, MonitorUpdateFailed}; + use crate::time_utils::tests::SinceEpoch; + use crate::DEFAULT_EXPIRY_TIME; fn invoice(payment_preimage: PaymentPreimage) -> Invoice { let payment_hash = Sha256::hash(&payment_preimage.0); @@ -866,7 +821,7 @@ mod tests { #[test] fn pays_invoice_on_first_attempt() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -874,16 +829,15 @@ mod tests { let final_value_msat = invoice.amount_milli_satoshis().unwrap(); let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(0)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(0)); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); - invoice_payer.handle_event(&Event::PaymentSent { + invoice_payer.handle_event(Event::PaymentSent { payment_id, payment_preimage, payment_hash, fee_paid_msat: None }); assert_eq!(*event_handled.borrow(), true); @@ -893,7 +847,7 @@ mod tests { #[test] fn pays_invoice_on_retry() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -903,11 +857,10 @@ mod tests { let payer = TestPayer::new() .expect_send(Amount::ForInvoice(final_value_msat)) .expect_send(Amount::OnRetry(final_value_msat / 2)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -916,17 +869,17 @@ mod tests { payment_id, payment_hash, network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: TestRouter::path_for_value(final_value_msat), short_channel_id: None, retry: Some(TestRouter::retry_for_invoice(&invoice)), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); assert_eq!(*event_handled.borrow(), false); assert_eq!(*payer.attempts.borrow(), 2); - invoice_payer.handle_event(&Event::PaymentSent { + invoice_payer.handle_event(Event::PaymentSent { payment_id, payment_preimage, payment_hash, fee_paid_msat: None }); assert_eq!(*event_handled.borrow(), true); @@ -935,7 +888,7 @@ mod tests { #[test] fn pays_invoice_on_partial_failure() { - let event_handler = |_: &_| { panic!() }; + let event_handler = |_: Event| { panic!() }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -948,11 +901,10 @@ mod tests { .expect_send(Amount::ForInvoice(final_value_msat)) .expect_send(Amount::OnRetry(final_value_msat / 2)) .expect_send(Amount::OnRetry(final_value_msat / 2)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); assert!(invoice_payer.pay_invoice(&invoice).is_ok()); } @@ -960,7 +912,7 @@ mod tests { #[test] fn retries_payment_path_for_unknown_payment() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -970,32 +922,31 @@ mod tests { let payer = TestPayer::new() .expect_send(Amount::OnRetry(final_value_msat / 2)) .expect_send(Amount::OnRetry(final_value_msat / 2)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = Some(PaymentId([1; 32])); let event = Event::PaymentPathFailed { payment_id, payment_hash, network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: TestRouter::path_for_value(final_value_msat), short_channel_id: None, retry: Some(TestRouter::retry_for_invoice(&invoice)), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event.clone()); assert_eq!(*event_handled.borrow(), false); assert_eq!(*payer.attempts.borrow(), 1); - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event.clone()); assert_eq!(*event_handled.borrow(), false); assert_eq!(*payer.attempts.borrow(), 2); - invoice_payer.handle_event(&Event::PaymentSent { + invoice_payer.handle_event(Event::PaymentSent { payment_id, payment_preimage, payment_hash, fee_paid_msat: None }); assert_eq!(*event_handled.borrow(), true); @@ -1005,7 +956,7 @@ mod tests { #[test] fn fails_paying_invoice_after_max_retry_counts() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1015,11 +966,10 @@ mod tests { .expect_send(Amount::ForInvoice(final_value_msat)) .expect_send(Amount::OnRetry(final_value_msat / 2)) .expect_send(Amount::OnRetry(final_value_msat / 2)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -1028,13 +978,13 @@ mod tests { payment_id, payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()), network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: true, path: TestRouter::path_for_value(final_value_msat), short_channel_id: None, retry: Some(TestRouter::retry_for_invoice(&invoice)), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); assert_eq!(*event_handled.borrow(), false); assert_eq!(*payer.attempts.borrow(), 2); @@ -1042,7 +992,7 @@ mod tests { payment_id, payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()), network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: TestRouter::path_for_value(final_value_msat / 2), short_channel_id: None, @@ -1050,11 +1000,11 @@ mod tests { final_value_msat: final_value_msat / 2, ..TestRouter::retry_for_invoice(&invoice) }), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event.clone()); assert_eq!(*event_handled.borrow(), false); assert_eq!(*payer.attempts.borrow(), 3); - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event.clone()); assert_eq!(*event_handled.borrow(), true); assert_eq!(*payer.attempts.borrow(), 3); } @@ -1063,7 +1013,7 @@ mod tests { #[test] fn fails_paying_invoice_after_max_retry_timeout() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1073,13 +1023,12 @@ mod tests { .expect_send(Amount::ForInvoice(final_value_msat)) .expect_send(Amount::OnRetry(final_value_msat / 2)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); - type InvoicePayerUsingSinceEpoch = InvoicePayerUsingTime::; + type InvoicePayerUsingSinceEpoch = InvoicePayerUsingTime::; let invoice_payer = - InvoicePayerUsingSinceEpoch::new(&payer, router, &scorer, &logger, event_handler, Retry::Timeout(Duration::from_secs(120))); + InvoicePayerUsingSinceEpoch::new(&payer, router, &logger, event_handler, Retry::Timeout(Duration::from_secs(120))); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -1088,19 +1037,19 @@ mod tests { payment_id, payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()), network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: true, path: TestRouter::path_for_value(final_value_msat), short_channel_id: None, retry: Some(TestRouter::retry_for_invoice(&invoice)), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event.clone()); assert_eq!(*event_handled.borrow(), false); assert_eq!(*payer.attempts.borrow(), 2); SinceEpoch::advance(Duration::from_secs(121)); - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event.clone()); assert_eq!(*event_handled.borrow(), true); assert_eq!(*payer.attempts.borrow(), 2); } @@ -1108,18 +1057,17 @@ mod tests { #[test] fn fails_paying_invoice_with_missing_retry_params() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); let final_value_msat = invoice.amount_milli_satoshis().unwrap(); let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -1128,13 +1076,13 @@ mod tests { payment_id, payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()), network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: vec![], short_channel_id: None, retry: None, }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); assert_eq!(*event_handled.borrow(), true); assert_eq!(*payer.attempts.borrow(), 1); } @@ -1144,14 +1092,13 @@ mod tests { #[test] fn fails_paying_invoice_after_expiration() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payer = TestPayer::new(); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_preimage = PaymentPreimage([1; 32]); let invoice = expired_invoice(payment_preimage); @@ -1165,18 +1112,17 @@ mod tests { #[test] fn fails_retrying_invoice_after_expiration() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); let final_value_msat = invoice.amount_milli_satoshis().unwrap(); let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -1189,13 +1135,13 @@ mod tests { payment_id, payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()), network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: vec![], short_channel_id: None, retry: Some(retry_data), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); assert_eq!(*event_handled.borrow(), true); assert_eq!(*payer.attempts.borrow(), 1); } @@ -1203,7 +1149,7 @@ mod tests { #[test] fn fails_paying_invoice_after_retry_error() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1213,11 +1159,10 @@ mod tests { .fails_on_attempt(2) .expect_send(Amount::ForInvoice(final_value_msat)) .expect_send(Amount::OnRetry(final_value_msat / 2)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -1226,13 +1171,13 @@ mod tests { payment_id, payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()), network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: TestRouter::path_for_value(final_value_msat / 2), short_channel_id: None, retry: Some(TestRouter::retry_for_invoice(&invoice)), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); assert_eq!(*event_handled.borrow(), true); assert_eq!(*payer.attempts.borrow(), 2); } @@ -1240,18 +1185,17 @@ mod tests { #[test] fn fails_paying_invoice_after_rejected_by_payee() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); let final_value_msat = invoice.amount_milli_satoshis().unwrap(); let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -1260,13 +1204,13 @@ mod tests { payment_id, payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()), network_update: None, - rejected_by_dest: true, + payment_failed_permanently: true, all_paths_failed: false, path: vec![], short_channel_id: None, retry: Some(TestRouter::retry_for_invoice(&invoice)), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); assert_eq!(*event_handled.borrow(), true); assert_eq!(*payer.attempts.borrow(), 1); } @@ -1274,7 +1218,7 @@ mod tests { #[test] fn fails_repaying_invoice_with_pending_payment() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1283,11 +1227,10 @@ mod tests { let payer = TestPayer::new() .expect_send(Amount::ForInvoice(final_value_msat)) .expect_send(Amount::ForInvoice(final_value_msat)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(0)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(0)); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); @@ -1309,13 +1252,13 @@ mod tests { payment_id, payment_hash, network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: vec![], short_channel_id: None, retry: Some(TestRouter::retry_for_invoice(&invoice)), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); assert_eq!(*event_handled.borrow(), true); } @@ -1323,10 +1266,9 @@ mod tests { fn fails_paying_invoice_with_routing_errors() { let payer = TestPayer::new(); let router = FailingRouter {}; - let scorer = RefCell::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, |_: &_| {}, Retry::Attempts(0)); + InvoicePayer::new(&payer, router, &logger, |_: Event| {}, Retry::Attempts(0)); let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1346,11 +1288,10 @@ mod tests { let payer = TestPayer::new() .fails_on_attempt(1) .expect_send(Amount::ForInvoice(final_value_msat)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, |_: &_| {}, Retry::Attempts(0)); + InvoicePayer::new(&payer, router, &logger, |_: Event| {}, Retry::Attempts(0)); match invoice_payer.pay_invoice(&invoice) { Err(PaymentError::Sending(_)) => {}, @@ -1362,7 +1303,7 @@ mod tests { #[test] fn pays_zero_value_invoice_using_amount() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = zero_value_invoice(payment_preimage); @@ -1370,17 +1311,16 @@ mod tests { let final_value_msat = 100; let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(0)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(0)); let payment_id = Some(invoice_payer.pay_zero_value_invoice(&invoice, final_value_msat).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); - invoice_payer.handle_event(&Event::PaymentSent { + invoice_payer.handle_event(Event::PaymentSent { payment_id, payment_preimage, payment_hash, fee_paid_msat: None }); assert_eq!(*event_handled.borrow(), true); @@ -1390,14 +1330,13 @@ mod tests { #[test] fn fails_paying_zero_value_invoice_with_amount() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payer = TestPayer::new(); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(0)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(0)); let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1413,7 +1352,7 @@ mod tests { #[test] fn pays_pubkey_with_amount() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let pubkey = pubkey(); let payment_preimage = PaymentPreimage([1; 32]); @@ -1424,11 +1363,10 @@ mod tests { let payer = TestPayer::new() .expect_send(Amount::Spontaneous(final_value_msat)) .expect_send(Amount::OnRetry(final_value_msat)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); + let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = Some(invoice_payer.pay_pubkey( pubkey, payment_preimage, final_value_msat, final_cltv_expiry_delta @@ -1444,17 +1382,17 @@ mod tests { payment_id, payment_hash, network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: vec![], short_channel_id: None, retry: Some(retry), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); assert_eq!(*event_handled.borrow(), false); assert_eq!(*payer.attempts.borrow(), 2); - invoice_payer.handle_event(&Event::PaymentSent { + invoice_payer.handle_event(Event::PaymentSent { payment_id, payment_preimage, payment_hash, fee_paid_msat: None }); assert_eq!(*event_handled.borrow(), true); @@ -1464,7 +1402,7 @@ mod tests { #[test] fn scores_failed_channel() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1477,32 +1415,32 @@ mod tests { let payer = TestPayer::new() .expect_send(Amount::ForInvoice(final_value_msat)) .expect_send(Amount::OnRetry(final_value_msat / 2)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new().expect(TestResult::PaymentFailure { + let scorer = TestScorer::new().expect(TestResult::PaymentFailure { path: path.clone(), short_channel_id: path[0].short_channel_id, - })); + }); + let router = TestRouter::new(scorer); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); let event = Event::PaymentPathFailed { payment_id, payment_hash, network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path, short_channel_id, retry: Some(TestRouter::retry_for_invoice(&invoice)), }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); } #[test] fn scores_successful_channels() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1512,90 +1450,38 @@ mod tests { // Expect that scorer is given short_channel_id upon handling the event. let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat)); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new() + let scorer = TestScorer::new() .expect(TestResult::PaymentSuccess { path: route.paths[0].clone() }) - .expect(TestResult::PaymentSuccess { path: route.paths[1].clone() }) - ); + .expect(TestResult::PaymentSuccess { path: route.paths[1].clone() }); + let router = TestRouter::new(scorer); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); let payment_id = invoice_payer.pay_invoice(&invoice).unwrap(); let event = Event::PaymentPathSuccessful { payment_id, payment_hash, path: route.paths[0].clone() }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); let event = Event::PaymentPathSuccessful { payment_id, payment_hash, path: route.paths[1].clone() }; - invoice_payer.handle_event(&event); + invoice_payer.handle_event(event); } #[test] - fn generates_correct_inflight_map_data() { + fn considers_inflight_htlcs_between_invoice_payments() { let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; - - let payment_preimage = PaymentPreimage([1; 32]); - let invoice = invoice(payment_preimage); - let payment_hash = Some(PaymentHash(invoice.payment_hash().clone().into_inner())); - let final_value_msat = invoice.amount_milli_satoshis().unwrap(); - - let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat)); - let final_value_msat = invoice.amount_milli_satoshis().unwrap(); - let route = TestRouter::route_for_value(final_value_msat); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); - let logger = TestLogger::new(); - let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(0)); - - let payment_id = invoice_payer.pay_invoice(&invoice).unwrap(); - - let inflight_map = invoice_payer.create_inflight_map(); - // First path check - assert_eq!(inflight_map.get(&(0, false)).unwrap().clone(), 94); - assert_eq!(inflight_map.get(&(1, true)).unwrap().clone(), 84); - assert_eq!(inflight_map.get(&(2, false)).unwrap().clone(), 64); - - // Second path check - assert_eq!(inflight_map.get(&(3, false)).unwrap().clone(), 74); - assert_eq!(inflight_map.get(&(4, false)).unwrap().clone(), 64); - - invoice_payer.handle_event(&Event::PaymentPathSuccessful { - payment_id, payment_hash, path: route.paths[0].clone() - }); - - let inflight_map = invoice_payer.create_inflight_map(); - - assert_eq!(inflight_map.get(&(0, false)), None); - assert_eq!(inflight_map.get(&(1, true)), None); - assert_eq!(inflight_map.get(&(2, false)), None); - - // Second path should still be inflight - assert_eq!(inflight_map.get(&(3, false)).unwrap().clone(), 74); - assert_eq!(inflight_map.get(&(4, false)).unwrap().clone(), 64) - } - - #[test] - fn considers_inflight_htlcs_between_invoice_payments_when_path_succeeds() { - // First, let's just send a payment through, but only make sure one of the path completes - let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let payment_invoice = invoice(payment_preimage); - let payment_hash = Some(PaymentHash(payment_invoice.payment_hash().clone().into_inner())); let final_value_msat = payment_invoice.amount_milli_satoshis().unwrap(); let payer = TestPayer::new() .expect_send(Amount::ForInvoice(final_value_msat)) .expect_send(Amount::ForInvoice(final_value_msat)); - let final_value_msat = payment_invoice.amount_milli_satoshis().unwrap(); - let route = TestRouter::route_for_value(final_value_msat); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new() + let scorer = TestScorer::new() // 1st invoice, 1st path .expect_usage(ChannelUsage { amount_msat: 64, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) .expect_usage(ChannelUsage { amount_msat: 84, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) @@ -1604,27 +1490,23 @@ mod tests { .expect_usage(ChannelUsage { amount_msat: 64, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) .expect_usage(ChannelUsage { amount_msat: 74, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) // 2nd invoice, 1st path - .expect_usage(ChannelUsage { amount_msat: 64, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) - .expect_usage(ChannelUsage { amount_msat: 84, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) - .expect_usage(ChannelUsage { amount_msat: 94, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) + .expect_usage(ChannelUsage { amount_msat: 64, inflight_htlc_msat: 64, effective_capacity: EffectiveCapacity::Unknown } ) + .expect_usage(ChannelUsage { amount_msat: 84, inflight_htlc_msat: 84, effective_capacity: EffectiveCapacity::Unknown } ) + .expect_usage(ChannelUsage { amount_msat: 94, inflight_htlc_msat: 94, effective_capacity: EffectiveCapacity::Unknown } ) // 2nd invoice, 2nd path .expect_usage(ChannelUsage { amount_msat: 64, inflight_htlc_msat: 64, effective_capacity: EffectiveCapacity::Unknown } ) - .expect_usage(ChannelUsage { amount_msat: 74, inflight_htlc_msat: 74, effective_capacity: EffectiveCapacity::Unknown } ) - ); + .expect_usage(ChannelUsage { amount_msat: 74, inflight_htlc_msat: 74, effective_capacity: EffectiveCapacity::Unknown } ); + let router = TestRouter::new(scorer); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(0)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(0)); - // Succeed 1st path, leave 2nd path inflight - let payment_id = invoice_payer.pay_invoice(&payment_invoice).unwrap(); - invoice_payer.handle_event(&Event::PaymentPathSuccessful { - payment_id, payment_hash, path: route.paths[0].clone() - }); + // Make first invoice payment. + invoice_payer.pay_invoice(&payment_invoice).unwrap(); // Let's pay a second invoice that will be using the same path. This should trigger the - // assertions that expect the last 4 ChannelUsage values above where TestScorer is initialized. - // Particularly, the 2nd path of the 1st payment, since it is not yet complete, should still - // have 64 msats inflight for paths considering the channel with scid of 1. + // assertions that expect `ChannelUsage` values of the first invoice payment that is still + // in-flight. let payment_preimage_2 = PaymentPreimage([2; 32]); let payment_invoice_2 = invoice(payment_preimage_2); invoice_payer.pay_invoice(&payment_invoice_2).unwrap(); @@ -1634,7 +1516,7 @@ mod tests { fn considers_inflight_htlcs_between_retries() { // First, let's just send a payment through, but only make sure one of the path completes let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; + let event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let payment_invoice = invoice(payment_preimage); @@ -1646,8 +1528,7 @@ mod tests { .expect_send(Amount::OnRetry(final_value_msat / 2)) .expect_send(Amount::OnRetry(final_value_msat / 4)); let final_value_msat = payment_invoice.amount_milli_satoshis().unwrap(); - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new() + let scorer = TestScorer::new() // 1st invoice, 1st path .expect_usage(ChannelUsage { amount_msat: 64, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) .expect_usage(ChannelUsage { amount_msat: 84, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) @@ -1668,19 +1549,20 @@ mod tests { .expect_usage(ChannelUsage { amount_msat: 46, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown } ) // Retry 2, 2nd path .expect_usage(ChannelUsage { amount_msat: 16, inflight_htlc_msat: 64 + 32, effective_capacity: EffectiveCapacity::Unknown } ) - .expect_usage(ChannelUsage { amount_msat: 26, inflight_htlc_msat: 74 + 32 + 10, effective_capacity: EffectiveCapacity::Unknown } ) - ); + .expect_usage(ChannelUsage { amount_msat: 26, inflight_htlc_msat: 74 + 32 + 10, effective_capacity: EffectiveCapacity::Unknown } ); + let router = TestRouter::new(scorer); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); // Fail 1st path, leave 2nd path inflight let payment_id = Some(invoice_payer.pay_invoice(&payment_invoice).unwrap()); - invoice_payer.handle_event(&Event::PaymentPathFailed { + invoice_payer.payer.fail_path(&TestRouter::path_for_value(final_value_msat)); + invoice_payer.handle_event(Event::PaymentPathFailed { payment_id, payment_hash, network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: TestRouter::path_for_value(final_value_msat), short_channel_id: None, @@ -1688,11 +1570,12 @@ mod tests { }); // Fails again the 1st path of our retry - invoice_payer.handle_event(&Event::PaymentPathFailed { + invoice_payer.payer.fail_path(&TestRouter::path_for_value(final_value_msat / 2)); + invoice_payer.handle_event(Event::PaymentPathFailed { payment_id, payment_hash, network_update: None, - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: false, path: TestRouter::path_for_value(final_value_msat / 2), short_channel_id: None, @@ -1703,72 +1586,15 @@ mod tests { }); } - #[test] - fn accounts_for_some_inflight_htlcs_sent_during_partial_failure() { - let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; - - let payment_preimage = PaymentPreimage([1; 32]); - let invoice_to_pay = invoice(payment_preimage); - let final_value_msat = invoice_to_pay.amount_milli_satoshis().unwrap(); - - let retry = TestRouter::retry_for_invoice(&invoice_to_pay); - let payer = TestPayer::new() - .fails_with_partial_failure( - retry.clone(), OnAttempt(1), - Some(vec![ - Err(ChannelUnavailable { err: "abc".to_string() }), Err(MonitorUpdateFailed) - ])) - .expect_send(Amount::ForInvoice(final_value_msat)); - - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); - let logger = TestLogger::new(); - let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(0)); - - invoice_payer.pay_invoice(&invoice_to_pay).unwrap(); - let inflight_map = invoice_payer.create_inflight_map(); - - // Only the second path, which failed with `MonitorUpdateFailed` should be added to our - // inflight map because retries are disabled. - assert_eq!(inflight_map.len(), 2); - } - - #[test] - fn accounts_for_all_inflight_htlcs_sent_during_partial_failure() { - let event_handled = core::cell::RefCell::new(false); - let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; - - let payment_preimage = PaymentPreimage([1; 32]); - let invoice_to_pay = invoice(payment_preimage); - let final_value_msat = invoice_to_pay.amount_milli_satoshis().unwrap(); - - let retry = TestRouter::retry_for_invoice(&invoice_to_pay); - let payer = TestPayer::new() - .fails_with_partial_failure( - retry.clone(), OnAttempt(1), - Some(vec![ - Ok(()), Err(MonitorUpdateFailed) - ])) - .expect_send(Amount::ForInvoice(final_value_msat)); - - let router = TestRouter {}; - let scorer = RefCell::new(TestScorer::new()); - let logger = TestLogger::new(); - let invoice_payer = - InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, Retry::Attempts(0)); - - invoice_payer.pay_invoice(&invoice_to_pay).unwrap(); - let inflight_map = invoice_payer.create_inflight_map(); - - // All paths successful, hence we check of the existence of all 5 hops. - assert_eq!(inflight_map.len(), 5); + struct TestRouter { + scorer: RefCell, } - struct TestRouter; - impl TestRouter { + fn new(scorer: TestScorer) -> Self { + TestRouter { scorer: RefCell::new(scorer) } + } + fn route_for_value(final_value_msat: u64) -> Route { Route { paths: vec![ @@ -1842,12 +1668,14 @@ mod tests { } impl Router for TestRouter { - fn find_route( - &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash, - _first_hops: Option<&[&ChannelDetails]>, scorer: &S + fn find_route( + &self, payer: &PublicKey, route_params: &RouteParameters, + _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs ) -> Result { // Simulate calling the Scorer just as you would in find_route let route = Self::route_for_value(route_params.final_value_msat); + let mut locked_scorer = self.scorer.lock(); + let scorer = ScorerAccountingForInFlightHtlcs::new(locked_scorer.deref_mut(), inflight_htlcs); for path in route.paths { let mut aggregate_msat = 0u64; for (idx, hop) in path.iter().rev().enumerate() { @@ -1872,17 +1700,41 @@ mod tests { payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat) }) } + + fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { + self.scorer.lock().payment_path_failed(path, short_channel_id); + } + + fn notify_payment_path_successful(&self, path: &[&RouteHop]) { + self.scorer.lock().payment_path_successful(path); + } + + fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { + self.scorer.lock().probe_successful(path); + } + + fn notify_payment_probe_failed(&self, path: &[&RouteHop], short_channel_id: u64) { + self.scorer.lock().probe_failed(path, short_channel_id); + } } struct FailingRouter; impl Router for FailingRouter { - fn find_route( - &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash, - _first_hops: Option<&[&ChannelDetails]>, _scorer: &S + fn find_route( + &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, + _inflight_htlcs: InFlightHtlcs, ) -> Result { Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError }) } + + fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {} + + fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {} + + fn notify_payment_probe_successful(&self, _path: &[&RouteHop]) {} + + fn notify_payment_probe_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {} } struct TestScorer { @@ -1917,7 +1769,7 @@ mod tests { #[cfg(c_bindings)] impl lightning::util::ser::Writeable for TestScorer { - fn write(&self, _: &mut W) -> Result<(), std::io::Error> { unreachable!(); } + fn write(&self, _: &mut W) -> Result<(), lightning::io::Error> { unreachable!(); } } impl Score for TestScorer { @@ -1946,7 +1798,7 @@ mod tests { Some(TestResult::PaymentSuccess { path }) => { panic!("Unexpected successful payment path: {:?}", path) }, - None => panic!("Unexpected payment_path_failed call: {:?}", actual_path), + None => panic!("Unexpected notify_payment_path_failed call: {:?}", actual_path), } } } @@ -1960,7 +1812,7 @@ mod tests { Some(TestResult::PaymentSuccess { path }) => { assert_eq!(actual_path, &path.iter().collect::>()[..]); }, - None => panic!("Unexpected payment_path_successful call: {:?}", actual_path), + None => panic!("Unexpected notify_payment_path_successful call: {:?}", actual_path), } } } @@ -1974,7 +1826,7 @@ mod tests { Some(TestResult::PaymentSuccess { path }) => { panic!("Unexpected successful payment path: {:?}", path) }, - None => panic!("Unexpected payment_path_failed call: {:?}", actual_path), + None => panic!("Unexpected notify_payment_path_failed call: {:?}", actual_path), } } } @@ -1987,7 +1839,7 @@ mod tests { Some(TestResult::PaymentSuccess { path }) => { panic!("Unexpected successful payment path: {:?}", path) }, - None => panic!("Unexpected payment_path_successful call: {:?}", actual_path), + None => panic!("Unexpected notify_payment_path_successful call: {:?}", actual_path), } } } @@ -2017,6 +1869,7 @@ mod tests { expectations: core::cell::RefCell>, attempts: core::cell::RefCell, failing_on_attempt: core::cell::RefCell>, + inflight_htlcs_paths: core::cell::RefCell>>, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -2034,6 +1887,7 @@ mod tests { expectations: core::cell::RefCell::new(VecDeque::new()), attempts: core::cell::RefCell::new(0), failing_on_attempt: core::cell::RefCell::new(HashMap::new()), + inflight_htlcs_paths: core::cell::RefCell::new(Vec::new()), } } @@ -2043,7 +1897,7 @@ mod tests { } fn fails_on_attempt(self, attempt: usize) -> Self { - let failure = PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed); + let failure = PaymentSendFailure::ParameterError(APIError::MonitorUpdateInProgress); self.fails_with(failure, OnAttempt(attempt)) } @@ -2060,13 +1914,13 @@ mod tests { self } - fn check_attempts(&self) -> Result { + fn check_attempts(&self) -> Result<(), PaymentSendFailure> { let mut attempts = self.attempts.borrow_mut(); *attempts += 1; match self.failing_on_attempt.borrow_mut().remove(&*attempts) { Some(failure) => Err(failure), - None => Ok(PaymentId([1; 32])), + None => Ok(()) } } @@ -2078,6 +1932,20 @@ mod tests { panic!("Unexpected amount: {:?}", actual_value_msats); } } + + fn track_inflight_htlcs(&self, route: &Route) { + for path in &route.paths { + self.inflight_htlcs_paths.borrow_mut().push(path.clone()); + } + } + + fn fail_path(&self, path: &Vec) { + let path_idx = self.inflight_htlcs_paths.borrow().iter().position(|p| p == path); + + if let Some(idx) = path_idx { + self.inflight_htlcs_paths.borrow_mut().swap_remove(idx); + } + } } impl Drop for TestPayer { @@ -2104,15 +1972,16 @@ mod tests { fn send_payment( &self, route: &Route, _payment_hash: PaymentHash, - _payment_secret: &Option - ) -> Result { + _payment_secret: &Option, _payment_id: PaymentId, + ) -> Result<(), PaymentSendFailure> { self.check_value_msats(Amount::ForInvoice(route.get_total_amount())); + self.track_inflight_htlcs(route); self.check_attempts() } fn send_spontaneous_payment( - &self, route: &Route, _payment_preimage: PaymentPreimage, - ) -> Result { + &self, route: &Route, _payment_preimage: PaymentPreimage, _payment_id: PaymentId, + ) -> Result<(), PaymentSendFailure> { self.check_value_msats(Amount::Spontaneous(route.get_total_amount())); self.check_attempts() } @@ -2121,22 +1990,39 @@ mod tests { &self, route: &Route, _payment_id: PaymentId ) -> Result<(), PaymentSendFailure> { self.check_value_msats(Amount::OnRetry(route.get_total_amount())); - self.check_attempts().map(|_| ()) + self.track_inflight_htlcs(route); + self.check_attempts() } fn abandon_payment(&self, _payment_id: PaymentId) { } + + fn inflight_htlcs(&self) -> InFlightHtlcs { + let mut inflight_htlcs = InFlightHtlcs::new(); + for path in self.inflight_htlcs_paths.clone().into_inner() { + inflight_htlcs.process_path(&path, self.node_id()); + } + inflight_htlcs + } } // *** Full Featured Functional Tests with a Real ChannelManager *** struct ManualRouter(RefCell>>); impl Router for ManualRouter { - fn find_route( - &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash, - _first_hops: Option<&[&ChannelDetails]>, _scorer: &S + fn find_route( + &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, + _inflight_htlcs: InFlightHtlcs ) -> Result { self.0.borrow_mut().pop_front().unwrap() } + + fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {} + + fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {} + + fn notify_payment_probe_successful(&self, _path: &[&RouteHop]) {} + + fn notify_payment_probe_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {} } impl ManualRouter { fn expect_find_route(&self, result: Result) { @@ -2160,24 +2046,24 @@ mod tests { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known()); - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known()); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let chans = nodes[0].node.list_usable_channels(); let mut route = Route { paths: vec![ vec![RouteHop { pubkey: nodes[1].node.get_our_node_id(), - node_features: NodeFeatures::known(), + node_features: channelmanager::provided_node_features(), short_channel_id: chans[0].short_channel_id.unwrap(), - channel_features: ChannelFeatures::known(), + channel_features: channelmanager::provided_channel_features(), fee_msat: 10_000, cltv_expiry_delta: 100, }], vec![RouteHop { pubkey: nodes[1].node.get_our_node_id(), - node_features: NodeFeatures::known(), + node_features: channelmanager::provided_node_features(), short_channel_id: chans[1].short_channel_id.unwrap(), - channel_features: ChannelFeatures::known(), + channel_features: channelmanager::provided_channel_features(), fee_msat: 100_000_001, // Our default max-HTLC-value is 10% of the channel value, which this is one more than cltv_expiry_delta: 100, }], @@ -2191,13 +2077,12 @@ mod tests { route.paths[1][0].fee_msat = 50_000_000; router.expect_find_route(Ok(route.clone())); - let event_handler = |_: &_| { panic!(); }; - let scorer = RefCell::new(TestScorer::new()); - let invoice_payer = InvoicePayer::new(nodes[0].node, router, &scorer, nodes[0].logger, event_handler, Retry::Attempts(1)); + let event_handler = |_: Event| { panic!(); }; + let invoice_payer = InvoicePayer::new(nodes[0].node, router, nodes[0].logger, event_handler, Retry::Attempts(1)); assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager_and_duration_since_epoch( - &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string(), - duration_since_epoch(), 3600).unwrap()) + &nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::Bitcoin, + Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600).unwrap()) .is_ok()); let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(htlc_msgs.len(), 2); @@ -2212,16 +2097,16 @@ mod tests { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known()); - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known()); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let chans = nodes[0].node.list_usable_channels(); let mut route = Route { paths: vec![ vec![RouteHop { pubkey: nodes[1].node.get_our_node_id(), - node_features: NodeFeatures::known(), + node_features: channelmanager::provided_node_features(), short_channel_id: chans[0].short_channel_id.unwrap(), - channel_features: ChannelFeatures::known(), + channel_features: channelmanager::provided_channel_features(), fee_msat: 100_000_001, // Our default max-HTLC-value is 10% of the channel value, which this is one more than cltv_expiry_delta: 100, }], @@ -2237,13 +2122,12 @@ mod tests { route.paths[1][0].fee_msat = 50_000_001; router.expect_find_route(Ok(route.clone())); - let event_handler = |_: &_| { panic!(); }; - let scorer = RefCell::new(TestScorer::new()); - let invoice_payer = InvoicePayer::new(nodes[0].node, router, &scorer, nodes[0].logger, event_handler, Retry::Attempts(1)); + let event_handler = |_: Event| { panic!(); }; + let invoice_payer = InvoicePayer::new(nodes[0].node, router, nodes[0].logger, event_handler, Retry::Attempts(1)); assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager_and_duration_since_epoch( - &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string(), - duration_since_epoch(), 3600).unwrap()) + &nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::Bitcoin, + Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600).unwrap()) .is_ok()); let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(htlc_msgs.len(), 2); @@ -2271,38 +2155,38 @@ mod tests { let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - let chan_1_scid = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id; - let chan_2_scid = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 10_000_000, 0, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id; + let chan_1_scid = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()).0.contents.short_channel_id; + let chan_2_scid = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 10_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()).0.contents.short_channel_id; let mut route = Route { paths: vec![ vec![RouteHop { pubkey: nodes[1].node.get_our_node_id(), - node_features: NodeFeatures::known(), + node_features: channelmanager::provided_node_features(), short_channel_id: chan_1_scid, - channel_features: ChannelFeatures::known(), + channel_features: channelmanager::provided_channel_features(), fee_msat: 0, cltv_expiry_delta: 100, }, RouteHop { pubkey: nodes[2].node.get_our_node_id(), - node_features: NodeFeatures::known(), + node_features: channelmanager::provided_node_features(), short_channel_id: chan_2_scid, - channel_features: ChannelFeatures::known(), + channel_features: channelmanager::provided_channel_features(), fee_msat: 100_000_000, cltv_expiry_delta: 100, }], vec![RouteHop { pubkey: nodes[1].node.get_our_node_id(), - node_features: NodeFeatures::known(), + node_features: channelmanager::provided_node_features(), short_channel_id: chan_1_scid, - channel_features: ChannelFeatures::known(), + channel_features: channelmanager::provided_channel_features(), fee_msat: 0, cltv_expiry_delta: 100, }, RouteHop { pubkey: nodes[2].node.get_our_node_id(), - node_features: NodeFeatures::known(), + node_features: channelmanager::provided_node_features(), short_channel_id: chan_2_scid, - channel_features: ChannelFeatures::known(), + channel_features: channelmanager::provided_channel_features(), fee_msat: 100_000_000, cltv_expiry_delta: 100, }] @@ -2315,17 +2199,16 @@ mod tests { route.paths.remove(1); router.expect_find_route(Ok(route.clone())); - let expected_events: RefCell> = RefCell::new(VecDeque::new()); - let event_handler = |event: &Event| { + let expected_events: RefCell> = RefCell::new(VecDeque::new()); + let event_handler = |event: Event| { let event_checker = expected_events.borrow_mut().pop_front().unwrap(); event_checker(event); }; - let scorer = RefCell::new(TestScorer::new()); - let invoice_payer = InvoicePayer::new(nodes[0].node, router, &scorer, nodes[0].logger, event_handler, Retry::Attempts(1)); + let invoice_payer = InvoicePayer::new(nodes[0].node, router, nodes[0].logger, event_handler, Retry::Attempts(1)); assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager_and_duration_since_epoch( - &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string(), - duration_since_epoch(), 3600).unwrap()) + &nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::Bitcoin, + Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600).unwrap()) .is_ok()); let htlc_updates = SendEvent::from_node(&nodes[0]); check_added_monitors!(nodes[0], 1); @@ -2392,9 +2275,9 @@ mod tests { // `PaymentPathFailed` being passed up to the user (us, in this case). Previously, we'd // treated this as "HTLC complete" and dropped the retry counter, causing us to retry again // if the final HTLC failed. - expected_events.borrow_mut().push_back(&|ev: &Event| { - if let Event::PaymentPathFailed { rejected_by_dest, all_paths_failed, .. } = ev { - assert!(!rejected_by_dest); + expected_events.borrow_mut().push_back(&|ev: Event| { + if let Event::PaymentPathFailed { payment_failed_permanently, all_paths_failed, .. } = ev { + assert!(!payment_failed_permanently); assert!(all_paths_failed); } else { panic!("Unexpected event"); } }); @@ -2410,13 +2293,13 @@ mod tests { nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_fail_update.update_fail_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], &bs_fail_update.commitment_signed, false, true); - expected_events.borrow_mut().push_back(&|ev: &Event| { - if let Event::PaymentPathFailed { rejected_by_dest, all_paths_failed, .. } = ev { - assert!(!rejected_by_dest); + expected_events.borrow_mut().push_back(&|ev: Event| { + if let Event::PaymentPathFailed { payment_failed_permanently, all_paths_failed, .. } = ev { + assert!(!payment_failed_permanently); assert!(all_paths_failed); } else { panic!("Unexpected event"); } }); - expected_events.borrow_mut().push_back(&|ev: &Event| { + expected_events.borrow_mut().push_back(&|ev: Event| { if let Event::PaymentFailed { .. } = ev { } else { panic!("Unexpected event"); } });