X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;ds=sidebyside;f=lightning-invoice%2Fsrc%2Fpayment.rs;h=a3517264b4a0bd1e8846f26afbf975f0f77b42eb;hb=ccf92157620da45032d75f06b5972eaf142c1ce3;hp=d6c876d0c9fc90b535a1f7e4fe495470c9f2244a;hpb=89f162c168bc934f64a663f31ea12793568c55b1;p=rust-lightning diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index d6c876d0..a3517264 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -44,7 +44,7 @@ //! # use lightning::util::logger::{Logger, Record}; //! # use lightning::util::ser::{Writeable, Writer}; //! # use lightning_invoice::Invoice; -//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter}; +//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry}; //! # use secp256k1::PublicKey; //! # use std::cell::RefCell; //! # use std::ops::Deref; @@ -76,10 +76,8 @@ //! # impl Router for FakeRouter { //! # fn find_route( //! # &self, payer: &PublicKey, params: &RouteParameters, -//! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs +//! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: &InFlightHtlcs //! # ) -> Result { unimplemented!() } -//! # } -//! # impl ScoringRouter for FakeRouter { //! # 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!() } @@ -117,7 +115,7 @@ //! # let router = FakeRouter {}; //! # let scorer = RefCell::new(FakeScorer {}); //! # let logger = FakeLogger {}; -//! let invoice_payer = InvoicePayer::new(&payer, router, &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::() { @@ -146,8 +144,7 @@ use crate::prelude::*; use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure}; use lightning::ln::msgs::LightningError; -use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router}; -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 crate::time_utils::Time; @@ -187,12 +184,13 @@ mod sealed { /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias. pub struct InvoicePayerUsingTime< P: Deref, - R: ScoringRouter, + R: Deref, L: Deref, E: sealed::BaseEventHandler, T: Time > where P::Target: Payer, + R::Target: Router, L::Target: Logger, { payer: P, @@ -200,26 +198,10 @@ pub struct InvoicePayerUsingTime< 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![], - } - } -} - /// Storing minimal payment attempts information required for determining if a outbound payment can /// be retried. #[derive(Clone, Copy)] @@ -296,30 +278,6 @@ pub trait Payer { fn inflight_htlcs(&self) -> InFlightHtlcs; } -/// A trait defining behavior for a [`Router`] implementation that also supports scoring channels -/// based on payment and probe success/failure. -/// -/// [`Router`]: lightning::routing::router::Router -pub trait ScoringRouter: Router { - /// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes - /// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment. - fn find_route_with_id( - &self, payer: &PublicKey, route_params: &RouteParameters, - first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs, - _payment_hash: PaymentHash, _payment_id: PaymentId - ) -> Result { - self.find_route(payer, route_params, first_hops, inflight_htlcs) - } - /// Lets the router know that payment through a specific path has failed. - fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64); - /// Lets the router know that payment through a specific path was successful. - fn notify_payment_path_successful(&self, path: &[&RouteHop]); - /// Lets the router know that a payment probe was successful. - fn notify_payment_probe_successful(&self, path: &[&RouteHop]); - /// Lets the router know that a payment probe failed. - fn notify_payment_probe_failed(&self, path: &[&RouteHop], short_channel_id: u64); -} - /// Strategies available to retry payment path failures for an [`Invoice`]. /// #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] @@ -359,10 +317,11 @@ pub enum PaymentError { Sending(PaymentSendFailure), } -impl +impl InvoicePayerUsingTime where P::Target: Payer, + R::Target: Router, L::Target: Logger, { /// Creates an invoice payer that retries failed payment paths. @@ -459,7 +418,7 @@ where 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()); @@ -472,7 +431,7 @@ where let route_params = RouteParameters { payment_params, final_value_msat: invoice.amount_milli_satoshis().or(amount_msats).unwrap(), - final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32, + final_cltv_expiry_delta: invoice.min_final_cltv_expiry_delta() as u32, }; let send_payment = |route: &Route| { @@ -523,7 +482,7 @@ where ) -> 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 { @@ -553,44 +512,27 @@ where let first_hops = self.payer.first_hops(); let inflight_htlcs = self.payer.inflight_htlcs(); let route = self.router.find_route( - &payer, ¶ms, Some(&first_hops.iter().collect::>()), inflight_htlcs + &payer, ¶ms, Some(&first_hops.iter().collect::>()), &inflight_htlcs ).map_err(|e| PaymentError::Routing(e))?; match send_payment(&route) { - Ok(()) => { - for path in route.paths { - self.process_path_inflight_htlcs(payment_hash, path); - } - Ok(()) - }, + Ok(()) => Ok(()), Err(e) => match e { PaymentSendFailure::ParameterError(_) => Err(e), PaymentSendFailure::PathParameterError(_) => Err(e), 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 `MonitorUpdateInProgress`, 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::MonitorUpdateInProgress) => { - 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 @@ -610,36 +552,16 @@ where }.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); @@ -658,7 +580,7 @@ where let inflight_htlcs = self.payer.inflight_htlcs(); let route = self.router.find_route( - &payer, ¶ms, Some(&first_hops.iter().collect::>()), inflight_htlcs + &payer, ¶ms, Some(&first_hops.iter().collect::>()), &inflight_htlcs ); if route.is_err() { @@ -667,12 +589,7 @@ 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)); @@ -685,19 +602,7 @@ where 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, results, .. }) => { - // If a `PartialFailure` error contains a result that is an `Ok()`, it means that - // part of our payment is retried. When we receive `MonitorUpdateInProgress`, 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::MonitorUpdateInProgress) => { - self.process_path_inflight_htlcs(payment_hash, path); - }, - _ => {}, - } - } - + 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); @@ -727,25 +632,16 @@ fn has_expired(route_params: &RouteParameters) -> bool { } else { false } } -impl +impl InvoicePayerUsingTime where P::Target: Payer, + R::Target: Router, L::Target: Logger, { /// 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_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); - }, - _ => {}, - } - match event { Event::PaymentPathFailed { payment_id, payment_hash, payment_failed_permanently, path, short_channel_id, retry, .. @@ -781,7 +677,7 @@ where 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, .. } => { @@ -804,10 +700,11 @@ where } } -impl +impl EventHandler for InvoicePayerUsingTime where P::Target: Payer, + R::Target: Router, L::Target: Logger, { fn handle_event(&self, event: Event) { @@ -818,10 +715,11 @@ where } } -impl F> +impl F> InvoicePayerUsingTime where P::Target: Payer, + R::Target: Router, L::Target: Logger, { /// Intercepts events required by the [`InvoicePayer`] and forwards them to the underlying event @@ -838,15 +736,14 @@ where mod tests { use super::*; use crate::{InvoiceBuilder, Currency}; - use crate::utils::{ScorerAccountingForInFlightHtlcs, 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::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::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router}; + 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; @@ -854,7 +751,6 @@ mod tests { use secp256k1::{SecretKey, PublicKey, Secp256k1}; use std::cell::RefCell; use std::collections::VecDeque; - use std::ops::DerefMut; use std::time::{SystemTime, Duration}; use crate::time_utils::tests::SinceEpoch; use crate::DEFAULT_EXPIRY_TIME; @@ -868,7 +764,7 @@ mod tests { .payment_hash(payment_hash) .payment_secret(PaymentSecret([0; 32])) .duration_since_epoch(duration_since_epoch()) - .min_final_cltv_expiry(144) + .min_final_cltv_expiry_delta(144) .amount_milli_satoshis(128) .build_signed(|hash| { Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key) @@ -894,7 +790,7 @@ mod tests { .payment_hash(payment_hash) .payment_secret(PaymentSecret([0; 32])) .duration_since_epoch(duration_since_epoch()) - .min_final_cltv_expiry(144) + .min_final_cltv_expiry_delta(144) .build_signed(|hash| { Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key) }) @@ -913,7 +809,7 @@ mod tests { .payment_hash(payment_hash) .payment_secret(PaymentSecret([0; 32])) .duration_since_epoch(duration) - .min_final_cltv_expiry(144) + .min_final_cltv_expiry_delta(144) .amount_milli_satoshis(128) .build_signed(|hash| { Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key) @@ -939,7 +835,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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); @@ -967,7 +863,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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); @@ -1011,7 +907,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(2)); + InvoicePayer::new(&payer, &router, &logger, event_handler, Retry::Attempts(2)); assert!(invoice_payer.pay_invoice(&invoice).is_ok()); } @@ -1032,7 +928,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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 { @@ -1076,7 +972,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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); @@ -1135,7 +1031,7 @@ mod tests { type InvoicePayerUsingSinceEpoch = InvoicePayerUsingTime::; let invoice_payer = - InvoicePayerUsingSinceEpoch::new(&payer, router, &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); @@ -1174,7 +1070,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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); @@ -1205,7 +1101,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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); @@ -1229,7 +1125,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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); @@ -1269,7 +1165,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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); @@ -1302,7 +1198,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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); @@ -1337,7 +1233,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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()); @@ -1375,7 +1271,7 @@ mod tests { let router = FailingRouter {}; let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &logger, |_: Event| {}, Retry::Attempts(0)); + InvoicePayer::new(&payer, &router, &logger, |_: Event| {}, Retry::Attempts(0)); let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1398,7 +1294,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &logger, |_: Event| {}, Retry::Attempts(0)); + InvoicePayer::new(&payer, &router, &logger, |_: Event| {}, Retry::Attempts(0)); match invoice_payer.pay_invoice(&invoice) { Err(PaymentError::Sending(_)) => {}, @@ -1421,7 +1317,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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()); @@ -1443,7 +1339,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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); @@ -1473,7 +1369,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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 @@ -1528,7 +1424,7 @@ mod tests { let router = TestRouter::new(scorer); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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 { @@ -1563,7 +1459,7 @@ mod tests { let router = TestRouter::new(scorer); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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 { @@ -1606,7 +1502,7 @@ mod tests { let router = TestRouter::new(scorer); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &logger, event_handler, Retry::Attempts(0)); + InvoicePayer::new(&payer, &router, &logger, event_handler, Retry::Attempts(0)); // Make first invoice payment. invoice_payer.pay_invoice(&payment_invoice).unwrap(); @@ -1660,7 +1556,7 @@ mod tests { let router = TestRouter::new(scorer); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &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()); @@ -1769,7 +1665,7 @@ mod tests { RouteParameters { payment_params, final_value_msat, - final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32, + final_cltv_expiry_delta: invoice.min_final_cltv_expiry_delta() as u32, } } } @@ -1777,12 +1673,12 @@ mod tests { impl Router for TestRouter { fn find_route( &self, payer: &PublicKey, route_params: &RouteParameters, - _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs + _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); + let locked_scorer = self.scorer.lock(); + let scorer = ScorerAccountingForInFlightHtlcs::new(locked_scorer, inflight_htlcs); for path in route.paths { let mut aggregate_msat = 0u64; for (idx, hop) in path.iter().rev().enumerate() { @@ -1807,9 +1703,7 @@ mod tests { payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat) }) } - } - impl ScoringRouter for TestRouter { fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { self.scorer.lock().payment_path_failed(path, short_channel_id); } @@ -1832,13 +1726,11 @@ mod tests { impl Router for FailingRouter { fn find_route( &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, - _inflight_htlcs: InFlightHtlcs, + _inflight_htlcs: &InFlightHtlcs, ) -> Result { Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError }) } - } - impl ScoringRouter for FailingRouter { fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {} fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {} @@ -2122,12 +2014,11 @@ mod tests { impl Router for ManualRouter { fn find_route( &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, - _inflight_htlcs: InFlightHtlcs + _inflight_htlcs: &InFlightHtlcs ) -> Result { self.0.borrow_mut().pop_front().unwrap() } - } - impl ScoringRouter for ManualRouter { + fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {} fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {} @@ -2158,24 +2049,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, 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()); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); 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: channelmanager::provided_node_features(), + node_features: nodes[1].node.node_features(), short_channel_id: chans[0].short_channel_id.unwrap(), - channel_features: channelmanager::provided_channel_features(), + channel_features: nodes[1].node.channel_features(), fee_msat: 10_000, cltv_expiry_delta: 100, }], vec![RouteHop { pubkey: nodes[1].node.get_our_node_id(), - node_features: channelmanager::provided_node_features(), + node_features: nodes[1].node.node_features(), short_channel_id: chans[1].short_channel_id.unwrap(), - channel_features: channelmanager::provided_channel_features(), + channel_features: nodes[1].node.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, }], @@ -2190,11 +2081,11 @@ mod tests { router.expect_find_route(Ok(route.clone())); let event_handler = |_: Event| { panic!(); }; - let invoice_payer = InvoicePayer::new(nodes[0].node, router, 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, nodes[1].logger, Currency::Bitcoin, - Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600).unwrap()) + Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600, None).unwrap()) .is_ok()); let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(htlc_msgs.len(), 2); @@ -2209,16 +2100,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, 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()); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); 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: channelmanager::provided_node_features(), + node_features: nodes[1].node.node_features(), short_channel_id: chans[0].short_channel_id.unwrap(), - channel_features: channelmanager::provided_channel_features(), + channel_features: nodes[1].node.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, }], @@ -2235,11 +2126,11 @@ mod tests { router.expect_find_route(Ok(route.clone())); let event_handler = |_: Event| { panic!(); }; - let invoice_payer = InvoicePayer::new(nodes[0].node, router, 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, nodes[1].logger, Currency::Bitcoin, - Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600).unwrap()) + Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600, None).unwrap()) .is_ok()); let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events(); assert_eq!(htlc_msgs.len(), 2); @@ -2267,38 +2158,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, 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 chan_1_scid = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0).0.contents.short_channel_id; + let chan_2_scid = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 10_000_000, 0).0.contents.short_channel_id; let mut route = Route { paths: vec![ vec![RouteHop { pubkey: nodes[1].node.get_our_node_id(), - node_features: channelmanager::provided_node_features(), + node_features: nodes[1].node.node_features(), short_channel_id: chan_1_scid, - channel_features: channelmanager::provided_channel_features(), + channel_features: nodes[1].node.channel_features(), fee_msat: 0, cltv_expiry_delta: 100, }, RouteHop { pubkey: nodes[2].node.get_our_node_id(), - node_features: channelmanager::provided_node_features(), + node_features: nodes[2].node.node_features(), short_channel_id: chan_2_scid, - channel_features: channelmanager::provided_channel_features(), + channel_features: nodes[2].node.channel_features(), fee_msat: 100_000_000, cltv_expiry_delta: 100, }], vec![RouteHop { pubkey: nodes[1].node.get_our_node_id(), - node_features: channelmanager::provided_node_features(), + node_features: nodes[1].node.node_features(), short_channel_id: chan_1_scid, - channel_features: channelmanager::provided_channel_features(), + channel_features: nodes[2].node.channel_features(), fee_msat: 0, cltv_expiry_delta: 100, }, RouteHop { pubkey: nodes[2].node.get_our_node_id(), - node_features: channelmanager::provided_node_features(), + node_features: nodes[2].node.node_features(), short_channel_id: chan_2_scid, - channel_features: channelmanager::provided_channel_features(), + channel_features: nodes[2].node.channel_features(), fee_msat: 100_000_000, cltv_expiry_delta: 100, }] @@ -2316,11 +2207,11 @@ mod tests { let event_checker = expected_events.borrow_mut().pop_front().unwrap(); event_checker(event); }; - let invoice_payer = InvoicePayer::new(nodes[0].node, router, 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, nodes[1].logger, Currency::Bitcoin, - Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600).unwrap()) + Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600, None).unwrap()) .is_ok()); let htlc_updates = SendEvent::from_node(&nodes[0]); check_added_monitors!(nodes[0], 1);