From c9ce344d56991ffa49c1867d5041bc136cedbece Mon Sep 17 00:00:00 2001 From: Jeffrey Czyz Date: Tue, 9 Nov 2021 09:37:34 -0600 Subject: [PATCH 1/5] Refactor InvoicePayer for spontaneous payments To support spontaneous payments, InvoicePayer's sending logic must be invoice-agnostic. Refactor InvoicePayer::pay_invoice_internal such that invoice-specific code is in pay_invoice_using_amount and the remaining logic is in pay_internal. Further refactor the code's payment_cache locking such that it is accessed consistently when needed, and tidy up the code a bit. --- lightning-invoice/src/payment.rs | 234 +++++++++++++++---------------- 1 file changed, 115 insertions(+), 119 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index 075559bfd8e..1a7242b8ef6 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -144,6 +144,7 @@ where scorer: S, logger: L, event_handler: E, + /// Caches the overall attempts at making a payment, which is updated prior to retrying. payment_cache: Mutex>, retry_attempts: RetryAttempts, } @@ -228,7 +229,7 @@ where if invoice.amount_milli_satoshis().is_none() { Err(PaymentError::Invoice("amount missing")) } else { - self.pay_invoice_internal(invoice, None, 0) + self.pay_invoice_using_amount(invoice, None) } } @@ -244,140 +245,135 @@ where if invoice.amount_milli_satoshis().is_some() { Err(PaymentError::Invoice("amount unexpected")) } else { - self.pay_invoice_internal(invoice, Some(amount_msats), 0) + self.pay_invoice_using_amount(invoice, Some(amount_msats)) } } - fn pay_invoice_internal( - &self, invoice: &Invoice, amount_msats: Option, retry_count: usize + fn pay_invoice_using_amount( + &self, invoice: &Invoice, amount_msats: Option ) -> Result { debug_assert!(invoice.amount_milli_satoshis().is_some() ^ amount_msats.is_some()); + let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); - if invoice.is_expired() { - log_trace!(self.logger, "Invoice expired prior to first send for payment {}", log_bytes!(payment_hash.0)); + 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(0), + }; + + let payment_secret = Some(invoice.payment_secret().clone()); + let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key()) + .with_expiry_time(expiry_time_from_unix_epoch(&invoice).as_secs()) + .with_route_hints(invoice.route_hints()); + if let Some(features) = invoice.features() { + payee = payee.with_features(features.clone()); + } + let params = RouteParameters { + payee, + final_value_msat: invoice.amount_milli_satoshis().or(amount_msats).unwrap(), + final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32, + }; + + self.pay_internal(¶ms, payment_hash, &payment_secret) + .map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e }) + } + + fn pay_internal( + &self, params: &RouteParameters, payment_hash: PaymentHash, + payment_secret: &Option, + ) -> Result { + if has_expired(params) { + log_trace!(self.logger, "Invoice expired prior to send for payment {}", log_bytes!(payment_hash.0)); return Err(PaymentError::Invoice("Invoice expired prior to send")); } - let retry_data_payment_id = loop { - let mut payment_cache = self.payment_cache.lock().unwrap(); - match payment_cache.entry(payment_hash) { - hash_map::Entry::Vacant(entry) => { - let payer = self.payer.node_id(); - let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key()) - .with_expiry_time(expiry_time_from_unix_epoch(&invoice).as_secs()) - .with_route_hints(invoice.route_hints()); - if let Some(features) = invoice.features() { - payee = payee.with_features(features.clone()); + + let payer = self.payer.node_id(); + let first_hops = self.payer.first_hops(); + let route = self.router.find_route( + &payer, + params, + Some(&first_hops.iter().collect::>()), + &self.scorer.lock(), + ).map_err(|e| PaymentError::Routing(e))?; + + match self.payer.send_payment(&route, payment_hash, payment_secret) { + Ok(payment_id) => Ok(payment_id), + Err(e) => match e { + PaymentSendFailure::ParameterError(_) => Err(e), + PaymentSendFailure::PathParameterError(_) => Err(e), + PaymentSendFailure::AllFailedRetrySafe(_) => { + let mut payment_cache = self.payment_cache.lock().unwrap(); + let retry_count = payment_cache.get_mut(&payment_hash).unwrap(); + if *retry_count >= self.retry_attempts.0 { + Err(e) + } else { + *retry_count += 1; + std::mem::drop(payment_cache); + Ok(self.pay_internal(params, payment_hash, payment_secret)?) } - let params = RouteParameters { - payee, - final_value_msat: invoice.amount_milli_satoshis().or(amount_msats).unwrap(), - final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32, - }; - let first_hops = self.payer.first_hops(); - let route = self.router.find_route( - &payer, - ¶ms, - Some(&first_hops.iter().collect::>()), - &self.scorer.lock(), - ).map_err(|e| PaymentError::Routing(e))?; - - let payment_secret = Some(invoice.payment_secret().clone()); - let payment_id = match self.payer.send_payment(&route, payment_hash, &payment_secret) { - Ok(payment_id) => payment_id, - Err(PaymentSendFailure::ParameterError(e)) => - return Err(PaymentError::Sending(PaymentSendFailure::ParameterError(e))), - Err(PaymentSendFailure::PathParameterError(e)) => - return Err(PaymentError::Sending(PaymentSendFailure::PathParameterError(e))), - Err(PaymentSendFailure::AllFailedRetrySafe(e)) => { - if retry_count >= self.retry_attempts.0 { - return Err(PaymentError::Sending(PaymentSendFailure::AllFailedRetrySafe(e))) - } - break None; - }, - Err(PaymentSendFailure::PartialFailure { results: _, failed_paths_retry, payment_id }) => { - if let Some(retry_data) = failed_paths_retry { - entry.insert(retry_count); - break Some((retry_data, payment_id)); - } 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. - payment_id - } - }, - }; - entry.insert(retry_count); - return Ok(payment_id); }, - hash_map::Entry::Occupied(_) => return Err(PaymentError::Invoice("payment pending")), - } - }; - if let Some((retry_data, payment_id)) = retry_data_payment_id { - // 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) - } else { - self.pay_invoice_internal(invoice, amount_msats, retry_count + 1) - } + 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) + } 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) + } + }, + }, + }.map_err(|e| PaymentError::Sending(e)) } - fn retry_payment(&self, payment_id: PaymentId, payment_hash: PaymentHash, params: &RouteParameters) - -> Result<(), ()> { - let route; - { - let mut payment_cache = self.payment_cache.lock().unwrap(); - let entry = loop { - let entry = payment_cache.entry(payment_hash); - match entry { - hash_map::Entry::Occupied(_) => break entry, - hash_map::Entry::Vacant(entry) => entry.insert(0), - }; - }; - if let hash_map::Entry::Occupied(mut entry) = entry { - let max_payment_attempts = self.retry_attempts.0 + 1; - let attempts = entry.get_mut(); - *attempts += 1; - - if *attempts >= max_payment_attempts { - log_trace!(self.logger, "Payment {} exceeded maximum attempts; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts); - return Err(()); - } else if has_expired(params) { - log_trace!(self.logger, "Invoice expired for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts); - return Err(()); - } + fn retry_payment( + &self, payment_id: PaymentId, payment_hash: PaymentHash, params: &RouteParameters + ) -> Result<(), ()> { + let max_payment_attempts = self.retry_attempts.0 + 1; + let attempts = *self.payment_cache.lock().unwrap() + .entry(payment_hash) + .and_modify(|attempts| *attempts += 1) + .or_insert(1); + + if attempts >= max_payment_attempts { + log_trace!(self.logger, "Payment {} exceeded maximum attempts; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts); + return Err(()); + } - let payer = self.payer.node_id(); - let first_hops = self.payer.first_hops(); - route = self.router.find_route(&payer, ¶ms, Some(&first_hops.iter().collect::>()), &self.scorer.lock()); - if route.is_err() { - log_trace!(self.logger, "Failed to find a route for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts); - return Err(()); - } - } else { - unreachable!(); - } + if has_expired(params) { + log_trace!(self.logger, "Invoice expired for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts); + return Err(()); + } + + let payer = self.payer.node_id(); + let first_hops = self.payer.first_hops(); + let route = self.router.find_route(&payer, ¶ms, Some(&first_hops.iter().collect::>()), &self.scorer.lock()); + if route.is_err() { + log_trace!(self.logger, "Failed to find a route for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts); + return Err(()); } - let retry_res = self.payer.retry_payment(&route.unwrap(), payment_id); - match retry_res { + match self.payer.retry_payment(&route.unwrap(), payment_id) { 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)); - return Err(()); + Err(()) }, Err(PaymentSendFailure::AllFailedRetrySafe(_)) => { self.retry_payment(payment_id, payment_hash, params) }, - Err(PaymentSendFailure::PartialFailure { results: _, failed_paths_retry, .. }) => { + Err(PaymentSendFailure::PartialFailure { failed_paths_retry, .. }) => { if let Some(retry) = failed_paths_retry { - self.retry_payment(payment_id, payment_hash, &retry) - } else { - Ok(()) + // Always return Ok for the same reason as noted in pay_internal. + let _ = self.retry_payment(payment_id, payment_hash, &retry); } + Ok(()) }, } } @@ -412,25 +408,25 @@ where fn handle_event(&self, event: &Event) { match event { Event::PaymentPathFailed { - all_paths_failed, payment_id, payment_hash, rejected_by_dest, path, short_channel_id, retry, .. + all_paths_failed, payment_id, payment_hash, rejected_by_dest, path, + short_channel_id, retry, .. } => { if let Some(short_channel_id) = short_channel_id { - let t = path.iter().collect::>(); - self.scorer.lock().payment_path_failed(&t, *short_channel_id); + let path = path.iter().collect::>(); + self.scorer.lock().payment_path_failed(&path, *short_channel_id); } if *rejected_by_dest { log_trace!(self.logger, "Payment {} rejected by destination; not retrying", log_bytes!(payment_hash.0)); } else if payment_id.is_none() { log_trace!(self.logger, "Payment {} has no id; not retrying", log_bytes!(payment_hash.0)); - } else if let Some(params) = retry { - if self.retry_payment(payment_id.unwrap(), *payment_hash, params).is_ok() { - // We retried at least somewhat, don't provide the PaymentPathFailed event to the user. - return; - } - } else { + } else if retry.is_none() { log_trace!(self.logger, "Payment {} missing retry params; not retrying", log_bytes!(payment_hash.0)); + } 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; } + if *all_paths_failed { self.payment_cache.lock().unwrap().remove(payment_hash); } }, Event::PaymentSent { payment_hash, .. } => { From b4c7370d26a23ccf044b3d0e8b4c344c743433c9 Mon Sep 17 00:00:00 2001 From: Jeffrey Czyz Date: Tue, 9 Nov 2021 17:32:37 -0600 Subject: [PATCH 2/5] Support spontaneous payments in InvoicePayer InvoicePayer handles retries not only when handling PaymentPathFailed events but also for some types of PaymentSendFailure on the initial send. Expand InvoicePayer's interface with a pay_pubkey function for spontaneous (keysend) payments. Add a send_spontaneous_payment function to the Payer trait to support this and implement it for ChannelManager. --- lightning-invoice/src/payment.rs | 152 +++++++++++++++++++++++++++---- lightning-invoice/src/utils.rs | 9 +- 2 files changed, 143 insertions(+), 18 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index 1a7242b8ef6..b3b84e351b7 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -7,12 +7,13 @@ // You may not use this file except in accordance with one or both of these // licenses. -//! A module for paying Lightning invoices. +//! A module for paying Lightning invoices and sending spontaneous payments. //! -//! Defines an [`InvoicePayer`] utility for paying invoices, parameterized by [`Payer`] and +//! Defines an [`InvoicePayer`] utility for sending payments, parameterized by [`Payer`] and //! [`Router`] traits. Implementations of [`Payer`] provide the payer's node id, channels, and means //! to send a payment over a [`Route`]. Implementations of [`Router`] find a [`Route`] between payer -//! and payee using information provided by the payer and from the payee's [`Invoice`]. +//! and payee using information provided by the payer and from the payee's [`Invoice`], when +//! applicable. //! //! [`InvoicePayer`] is capable of retrying failed payments. It accomplishes this by implementing //! [`EventHandler`] which decorates a user-provided handler. It will intercept any @@ -27,7 +28,7 @@ //! # extern crate lightning_invoice; //! # extern crate secp256k1; //! # -//! # use lightning::ln::{PaymentHash, PaymentSecret}; +//! # use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure}; //! # use lightning::ln::msgs::LightningError; //! # use lightning::routing; @@ -53,6 +54,9 @@ //! # fn send_payment( //! # &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option //! # ) -> Result { unimplemented!() } +//! # fn send_spontaneous_payment( +//! # &self, route: &Route, payment_preimage: PaymentPreimage +//! # ) -> Result { unimplemented!() } //! # fn retry_payment( //! # &self, route: &Route, payment_id: PaymentId //! # ) -> Result<(), PaymentSendFailure> { unimplemented!() } @@ -113,8 +117,9 @@ use crate::Invoice; use bitcoin_hashes::Hash; +use bitcoin_hashes::sha256::Hash as Sha256; -use lightning::ln::{PaymentHash, PaymentSecret}; +use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure}; use lightning::ln::msgs::LightningError; use lightning::routing; @@ -130,7 +135,7 @@ use std::ops::Deref; use std::sync::Mutex; use std::time::{Duration, SystemTime}; -/// A utility for paying [`Invoice]`s. +/// A utility for paying [`Invoice`]s and sending spontaneous payments. pub struct InvoicePayer where P::Target: Payer, @@ -162,6 +167,11 @@ pub trait Payer { &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option ) -> Result; + /// Sends a spontaneous payment over the Lightning Network using the given [`Route`]. + fn send_spontaneous_payment( + &self, route: &Route, payment_preimage: PaymentPreimage + ) -> Result; + /// Retries a failed payment path for the [`PaymentId`] using the given [`Route`]. fn retry_payment(&self, route: &Route, payment_id: PaymentId) -> Result<(), PaymentSendFailure>; } @@ -273,13 +283,43 @@ where final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32, }; - self.pay_internal(¶ms, payment_hash, &payment_secret) + let send_payment = |route: &Route| { + self.payer.send_payment(route, payment_hash, &payment_secret) + }; + self.pay_internal(¶ms, payment_hash, send_payment) + .map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e }) + } + + /// 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 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()); + 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(0), + }; + + let params = RouteParameters { + payee: Payee::for_keysend(pubkey), + final_value_msat: amount_msats, + final_cltv_expiry_delta, + }; + + let send_payment = |route: &Route| { + self.payer.send_spontaneous_payment(route, payment_preimage) + }; + self.pay_internal(¶ms, payment_hash, send_payment) .map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e }) } - fn pay_internal( - &self, params: &RouteParameters, payment_hash: PaymentHash, - payment_secret: &Option, + fn pay_internal Result + Copy>( + &self, params: &RouteParameters, payment_hash: PaymentHash, send_payment: F, ) -> Result { if has_expired(params) { log_trace!(self.logger, "Invoice expired prior to send for payment {}", log_bytes!(payment_hash.0)); @@ -295,7 +335,7 @@ where &self.scorer.lock(), ).map_err(|e| PaymentError::Routing(e))?; - match self.payer.send_payment(&route, payment_hash, payment_secret) { + match send_payment(&route) { Ok(payment_id) => Ok(payment_id), Err(e) => match e { PaymentSendFailure::ParameterError(_) => Err(e), @@ -308,7 +348,7 @@ where } else { *retry_count += 1; std::mem::drop(payment_cache); - Ok(self.pay_internal(params, payment_hash, payment_secret)?) + Ok(self.pay_internal(params, payment_hash, send_payment)?) } }, PaymentSendFailure::PartialFailure { failed_paths_retry, payment_id, .. } => { @@ -514,6 +554,10 @@ mod tests { .unwrap() } + fn pubkey() -> PublicKey { + PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap() + } + #[test] fn pays_invoice_on_first_attempt() { let event_handled = core::cell::RefCell::new(false); @@ -969,6 +1013,57 @@ 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 pubkey = pubkey(); + let payment_preimage = PaymentPreimage([1; 32]); + let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner()); + let final_value_msat = 100; + let final_cltv_expiry_delta = 42; + + let payer = TestPayer::new() + .expect_send(Amount::Spontaneous(final_value_msat)) + .expect_send(Amount::ForInvoiceOrRetry(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, RetryAttempts(2)); + + let payment_id = Some(invoice_payer.pay_pubkey( + pubkey, payment_preimage, final_value_msat, final_cltv_expiry_delta + ).unwrap()); + assert_eq!(*payer.attempts.borrow(), 1); + + let retry = RouteParameters { + payee: Payee::for_keysend(pubkey), + final_value_msat, + final_cltv_expiry_delta, + }; + let event = Event::PaymentPathFailed { + payment_id, + payment_hash, + network_update: None, + rejected_by_dest: false, + all_paths_failed: false, + path: vec![], + short_channel_id: None, + retry: Some(retry), + }; + invoice_payer.handle_event(&event); + assert_eq!(*event_handled.borrow(), false); + assert_eq!(*payer.attempts.borrow(), 2); + + invoice_payer.handle_event(&Event::PaymentSent { + payment_id, payment_preimage, payment_hash, fee_paid_msat: None + }); + assert_eq!(*event_handled.borrow(), true); + assert_eq!(*payer.attempts.borrow(), 2); + } + #[test] fn scores_failed_channel() { let event_handled = core::cell::RefCell::new(false); @@ -1116,11 +1211,17 @@ mod tests { } struct TestPayer { - expectations: core::cell::RefCell>, + expectations: core::cell::RefCell>, attempts: core::cell::RefCell, failing_on_attempt: Option, } + #[derive(Clone, Debug, PartialEq, Eq)] + enum Amount { + ForInvoiceOrRetry(u64), + Spontaneous(u64), + } + impl TestPayer { fn new() -> Self { Self { @@ -1131,6 +1232,11 @@ mod tests { } fn expect_value_msat(self, value_msat: u64) -> Self { + self.expectations.borrow_mut().push_back(Amount::ForInvoiceOrRetry(value_msat)); + self + } + + fn expect_send(self, value_msat: Amount) -> Self { self.expectations.borrow_mut().push_back(value_msat); self } @@ -1153,10 +1259,9 @@ mod tests { } } - fn check_value_msats(&self, route: &Route) { + fn check_value_msats(&self, actual_value_msats: Amount) { let expected_value_msats = self.expectations.borrow_mut().pop_front(); if let Some(expected_value_msats) = expected_value_msats { - let actual_value_msats = route.get_total_amount(); assert_eq!(actual_value_msats, expected_value_msats); } } @@ -1191,7 +1296,20 @@ mod tests { _payment_secret: &Option ) -> Result { if self.check_attempts() { - self.check_value_msats(route); + self.check_value_msats(Amount::ForInvoiceOrRetry(route.get_total_amount())); + Ok(PaymentId([1; 32])) + } else { + Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed)) + } + } + + fn send_spontaneous_payment( + &self, + route: &Route, + _payment_preimage: PaymentPreimage, + ) -> Result { + if self.check_attempts() { + self.check_value_msats(Amount::Spontaneous(route.get_total_amount())); Ok(PaymentId([1; 32])) } else { Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed)) @@ -1202,7 +1320,7 @@ mod tests { &self, route: &Route, _payment_id: PaymentId ) -> Result<(), PaymentSendFailure> { if self.check_attempts() { - self.check_value_msats(route); + self.check_value_msats(Amount::ForInvoiceOrRetry(route.get_total_amount())); Ok(()) } else { Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed)) diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 35a74b6a5ac..641a09ad746 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -8,7 +8,7 @@ use bitcoin_hashes::Hash; use lightning::chain; use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; use lightning::chain::keysinterface::{Sign, KeysInterface}; -use lightning::ln::{PaymentHash, PaymentSecret}; +use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, PaymentSendFailure, MIN_FINAL_CLTV_EXPIRY}; use lightning::ln::msgs::LightningError; use lightning::routing; @@ -141,6 +141,13 @@ where self.send_payment(route, payment_hash, payment_secret) } + fn send_spontaneous_payment( + &self, route: &Route, payment_preimage: PaymentPreimage, + ) -> Result { + self.send_spontaneous_payment(route, Some(payment_preimage)) + .map(|(_, payment_id)| payment_id) + } + fn retry_payment( &self, route: &Route, payment_id: PaymentId ) -> Result<(), PaymentSendFailure> { From ab9576201d358881583a0327104d798b7f3e4fb0 Mon Sep 17 00:00:00 2001 From: Jeffrey Czyz Date: Tue, 9 Nov 2021 18:07:23 -0600 Subject: [PATCH 3/5] Replace expect_value_msat with expect_send Modify all InvoicePayer unit tests to use expect_send instead of expect_value_msat, since the former can discern whether the send was for an invoice, spontaneous payment, or a retry. Updates tests to set payer expectations if they weren't already and assert these before returning a failure. --- lightning-invoice/src/payment.rs | 120 +++++++++++++++---------------- 1 file changed, 60 insertions(+), 60 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index b3b84e351b7..55d877d415e 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -566,8 +566,9 @@ mod tests { let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); + let final_value_msat = invoice.amount_milli_satoshis().unwrap(); - let payer = TestPayer::new(); + let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat)); let router = TestRouter {}; let scorer = RefCell::new(TestScorer::new()); let logger = TestLogger::new(); @@ -595,8 +596,8 @@ mod tests { let final_value_msat = invoice.amount_milli_satoshis().unwrap(); let payer = TestPayer::new() - .expect_value_msat(final_value_msat) - .expect_value_msat(final_value_msat / 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 logger = TestLogger::new(); @@ -637,7 +638,9 @@ mod tests { let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); let final_value_msat = invoice.amount_milli_satoshis().unwrap(); - let payer = TestPayer::new(); + 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 logger = TestLogger::new(); @@ -680,9 +683,9 @@ mod tests { let final_value_msat = invoice.amount_milli_satoshis().unwrap(); let payer = TestPayer::new() - .expect_value_msat(final_value_msat) - .expect_value_msat(final_value_msat / 2) - .expect_value_msat(final_value_msat / 2); + .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 logger = TestLogger::new(); @@ -732,15 +735,17 @@ mod tests { let event_handled = core::cell::RefCell::new(false); let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; - let payer = TestPayer::new(); + 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 logger = TestLogger::new(); let invoice_payer = InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2)); - let payment_preimage = PaymentPreimage([1; 32]); - let invoice = invoice(payment_preimage); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -783,15 +788,17 @@ mod tests { let event_handled = core::cell::RefCell::new(false); let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; - let payer = TestPayer::new(); + 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 logger = TestLogger::new(); let invoice_payer = InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2)); - let payment_preimage = PaymentPreimage([1; 32]); - let invoice = invoice(payment_preimage); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -825,7 +832,8 @@ mod tests { let payer = TestPayer::new() .fails_on_attempt(2) - .expect_value_msat(final_value_msat); + .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 logger = TestLogger::new(); @@ -855,15 +863,17 @@ mod tests { let event_handled = core::cell::RefCell::new(false); let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; - let payer = TestPayer::new(); + 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 logger = TestLogger::new(); let invoice_payer = InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2)); - let payment_preimage = PaymentPreimage([1; 32]); - let invoice = invoice(payment_preimage); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); assert_eq!(*payer.attempts.borrow(), 1); @@ -887,15 +897,19 @@ mod tests { let event_handled = core::cell::RefCell::new(false); let event_handler = |_: &_| { *event_handled.borrow_mut() = true; }; - let payer = TestPayer::new(); + 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)) + .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, RetryAttempts(0)); - let payment_preimage = PaymentPreimage([1; 32]); - let invoice = invoice(payment_preimage); let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap()); // Cannot repay an invoice pending payment. @@ -946,15 +960,19 @@ mod tests { #[test] fn fails_paying_invoice_with_sending_errors() { - let payer = TestPayer::new().fails_on_attempt(1); + let payment_preimage = PaymentPreimage([1; 32]); + let invoice = invoice(payment_preimage); + let final_value_msat = invoice.amount_milli_satoshis().unwrap(); + + 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 logger = TestLogger::new(); let invoice_payer = InvoicePayer::new(&payer, router, &scorer, &logger, |_: &_| {}, RetryAttempts(0)); - let payment_preimage = PaymentPreimage([1; 32]); - let invoice = invoice(payment_preimage); match invoice_payer.pay_invoice(&invoice) { Err(PaymentError::Sending(_)) => {}, Err(_) => panic!("unexpected error"), @@ -972,7 +990,7 @@ mod tests { let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); let final_value_msat = 100; - let payer = TestPayer::new().expect_value_msat(final_value_msat); + let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat)); let router = TestRouter {}; let scorer = RefCell::new(TestScorer::new()); let logger = TestLogger::new(); @@ -1026,7 +1044,7 @@ mod tests { let payer = TestPayer::new() .expect_send(Amount::Spontaneous(final_value_msat)) - .expect_send(Amount::ForInvoiceOrRetry(final_value_msat)); + .expect_send(Amount::OnRetry(final_value_msat)); let router = TestRouter {}; let scorer = RefCell::new(TestScorer::new()); let logger = TestLogger::new(); @@ -1077,7 +1095,9 @@ mod tests { let short_channel_id = Some(path[0].short_channel_id); // Expect that scorer is given short_channel_id upon handling the event. - let payer = TestPayer::new(); + 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_channel_failure(short_channel_id.unwrap())); let logger = TestLogger::new(); @@ -1218,8 +1238,9 @@ mod tests { #[derive(Clone, Debug, PartialEq, Eq)] enum Amount { - ForInvoiceOrRetry(u64), + ForInvoice(u64), Spontaneous(u64), + OnRetry(u64), } impl TestPayer { @@ -1231,11 +1252,6 @@ mod tests { } } - fn expect_value_msat(self, value_msat: u64) -> Self { - self.expectations.borrow_mut().push_back(Amount::ForInvoiceOrRetry(value_msat)); - self - } - fn expect_send(self, value_msat: Amount) -> Self { self.expectations.borrow_mut().push_back(value_msat); self @@ -1249,13 +1265,13 @@ mod tests { } } - fn check_attempts(&self) -> bool { + fn check_attempts(&self) -> Result { let mut attempts = self.attempts.borrow_mut(); *attempts += 1; match self.failing_on_attempt { - None => true, - Some(attempt) if attempt != *attempts => true, - Some(_) => false, + None => Ok(PaymentId([1; 32])), + Some(attempt) if attempt != *attempts => Ok(PaymentId([1; 32])), + Some(_) => Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed)), } } @@ -1290,41 +1306,25 @@ mod tests { } fn send_payment( - &self, - route: &Route, - _payment_hash: PaymentHash, + &self, route: &Route, _payment_hash: PaymentHash, _payment_secret: &Option ) -> Result { - if self.check_attempts() { - self.check_value_msats(Amount::ForInvoiceOrRetry(route.get_total_amount())); - Ok(PaymentId([1; 32])) - } else { - Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed)) - } + self.check_value_msats(Amount::ForInvoice(route.get_total_amount())); + self.check_attempts() } fn send_spontaneous_payment( - &self, - route: &Route, - _payment_preimage: PaymentPreimage, + &self, route: &Route, _payment_preimage: PaymentPreimage, ) -> Result { - if self.check_attempts() { - self.check_value_msats(Amount::Spontaneous(route.get_total_amount())); - Ok(PaymentId([1; 32])) - } else { - Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed)) - } + self.check_value_msats(Amount::Spontaneous(route.get_total_amount())); + self.check_attempts() } fn retry_payment( &self, route: &Route, _payment_id: PaymentId ) -> Result<(), PaymentSendFailure> { - if self.check_attempts() { - self.check_value_msats(Amount::ForInvoiceOrRetry(route.get_total_amount())); - Ok(()) - } else { - Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed)) - } + self.check_value_msats(Amount::OnRetry(route.get_total_amount())); + self.check_attempts().map(|_| ()) } } From 756b3051573ed9b4e04cc2227af93c45fe0d8104 Mon Sep 17 00:00:00 2001 From: Jeffrey Czyz Date: Mon, 15 Nov 2021 22:47:40 -0600 Subject: [PATCH 4/5] Test retrying payment on partial send failure Add some test coverage for when InvoicePayer retries within pay_invoice because the Payer returned a partial failure. --- lightning-invoice/src/payment.rs | 58 ++++++++++++++++++++++++++------ 1 file changed, 48 insertions(+), 10 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index 55d877d415e..1e450296b58 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -628,6 +628,30 @@ mod tests { assert_eq!(*payer.attempts.borrow(), 2); } + #[test] + fn pays_invoice_on_partial_failure() { + let event_handler = |_: &_| { panic!() }; + + let payment_preimage = PaymentPreimage([1; 32]); + let invoice = invoice(payment_preimage); + let retry = TestRouter::retry_for_invoice(&invoice); + let final_value_msat = invoice.amount_milli_satoshis().unwrap(); + + let payer = TestPayer::new() + .fails_with_partial_failure(retry.clone(), OnAttempt(1)) + .fails_with_partial_failure(retry, OnAttempt(2)) + .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 logger = TestLogger::new(); + let invoice_payer = + InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2)); + + assert!(invoice_payer.pay_invoice(&invoice).is_ok()); + } + #[test] fn retries_payment_path_for_unknown_payment() { let event_handled = core::cell::RefCell::new(false); @@ -1233,7 +1257,7 @@ mod tests { struct TestPayer { expectations: core::cell::RefCell>, attempts: core::cell::RefCell, - failing_on_attempt: Option, + failing_on_attempt: core::cell::RefCell>, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -1243,12 +1267,14 @@ mod tests { OnRetry(u64), } + struct OnAttempt(usize); + impl TestPayer { fn new() -> Self { Self { expectations: core::cell::RefCell::new(VecDeque::new()), attempts: core::cell::RefCell::new(0), - failing_on_attempt: None, + failing_on_attempt: core::cell::RefCell::new(HashMap::new()), } } @@ -1258,20 +1284,30 @@ mod tests { } fn fails_on_attempt(self, attempt: usize) -> Self { - Self { - expectations: core::cell::RefCell::new(self.expectations.borrow().clone()), - attempts: core::cell::RefCell::new(0), - failing_on_attempt: Some(attempt), - } + let failure = PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed); + self.fails_with(failure, OnAttempt(attempt)) + } + + fn fails_with_partial_failure(self, retry: RouteParameters, attempt: OnAttempt) -> Self { + self.fails_with(PaymentSendFailure::PartialFailure { + results: vec![], + failed_paths_retry: Some(retry), + payment_id: PaymentId([1; 32]), + }, attempt) + } + + fn fails_with(self, failure: PaymentSendFailure, attempt: OnAttempt) -> Self { + self.failing_on_attempt.borrow_mut().insert(attempt.0, failure); + self } fn check_attempts(&self) -> Result { let mut attempts = self.attempts.borrow_mut(); *attempts += 1; - match self.failing_on_attempt { + + match self.failing_on_attempt.borrow_mut().remove(&*attempts) { + Some(failure) => Err(failure), None => Ok(PaymentId([1; 32])), - Some(attempt) if attempt != *attempts => Ok(PaymentId([1; 32])), - Some(_) => Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed)), } } @@ -1279,6 +1315,8 @@ mod tests { let expected_value_msats = self.expectations.borrow_mut().pop_front(); if let Some(expected_value_msats) = expected_value_msats { assert_eq!(actual_value_msats, expected_value_msats); + } else { + panic!("Unexpected amount: {:?}", actual_value_msats); } } } From 592bfd7c58e73eaa5cfd5032d982883878510037 Mon Sep 17 00:00:00 2001 From: Jeffrey Czyz Date: Thu, 11 Nov 2021 21:47:59 -0600 Subject: [PATCH 5/5] Add PaymentHash parameter to Router::find_route Implementations of Router may need the payment hash in order to look up pre-computed routes from a probe for a given payment. Add a PaymentHash parameter to Router::find_route to allow for this. --- lightning-invoice/src/payment.rs | 37 +++++++++++++++----------------- lightning-invoice/src/utils.rs | 4 ++-- 2 files changed, 19 insertions(+), 22 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index 1e450296b58..85786a90a34 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -65,7 +65,7 @@ //! # struct FakeRouter {}; //! # impl Router for FakeRouter { //! # fn find_route( -//! # &self, payer: &PublicKey, params: &RouteParameters, +//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash, //! # first_hops: Option<&[&ChannelDetails]>, scorer: &S //! # ) -> Result { unimplemented!() } //! # } @@ -180,8 +180,8 @@ pub trait Payer { pub trait Router { /// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. fn find_route( - &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>, - scorer: &S + &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash, + first_hops: Option<&[&ChannelDetails]>, scorer: &S ) -> Result; } @@ -329,10 +329,8 @@ where let payer = self.payer.node_id(); let first_hops = self.payer.first_hops(); let route = self.router.find_route( - &payer, - params, - Some(&first_hops.iter().collect::>()), - &self.scorer.lock(), + &payer, params, &payment_hash, Some(&first_hops.iter().collect::>()), + &self.scorer.lock() ).map_err(|e| PaymentError::Routing(e))?; match send_payment(&route) { @@ -392,7 +390,10 @@ where let payer = self.payer.node_id(); let first_hops = self.payer.first_hops(); - let route = self.router.find_route(&payer, ¶ms, Some(&first_hops.iter().collect::>()), &self.scorer.lock()); + let route = self.router.find_route( + &payer, ¶ms, &payment_hash, Some(&first_hops.iter().collect::>()), + &self.scorer.lock() + ); if route.is_err() { log_trace!(self.logger, "Failed to find a route for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts); return Err(()); @@ -1187,11 +1188,8 @@ mod tests { impl Router for TestRouter { fn find_route( - &self, - _payer: &PublicKey, - params: &RouteParameters, - _first_hops: Option<&[&ChannelDetails]>, - _scorer: &S, + &self, _payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash, + _first_hops: Option<&[&ChannelDetails]>, _scorer: &S ) -> Result { Ok(Route { payee: Some(params.payee.clone()), ..Self::route_for_value(params.final_value_msat) @@ -1203,11 +1201,8 @@ mod tests { impl Router for FailingRouter { fn find_route( - &self, - _payer: &PublicKey, - _params: &RouteParameters, - _first_hops: Option<&[&ChannelDetails]>, - _scorer: &S, + &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash, + _first_hops: Option<&[&ChannelDetails]>, _scorer: &S ) -> Result { Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError }) } @@ -1370,8 +1365,10 @@ mod tests { struct ManualRouter(RefCell>>); impl Router for ManualRouter { - fn find_route(&self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, _scorer: &S) - -> Result { + fn find_route( + &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash, + _first_hops: Option<&[&ChannelDetails]>, _scorer: &S + ) -> Result { self.0.borrow_mut().pop_front().unwrap() } } diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 641a09ad746..ad94b080436 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -112,8 +112,8 @@ impl DefaultRouter where G: Deref, L:: impl Router for DefaultRouter where G: Deref, L::Target: Logger { fn find_route( - &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>, - scorer: &S + &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash, + first_hops: Option<&[&ChannelDetails]>, scorer: &S ) -> Result { find_route(payer, params, &*self.network_graph, first_hops, &*self.logger, scorer) }