X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-invoice%2Fsrc%2Fpayment.rs;h=cbd760c37d02d045c82cbc942432c1f2c82dc419;hb=49c9f1885dd7a564c0c78ad5f73ea4792c0171a8;hp=a1c0db58fa4792a5e340a10f9393b3ae90def96f;hpb=5211bfd3f6e49c330432a181512cd84027522215;p=rust-lightning diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index a1c0db58..cbd760c3 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -38,13 +38,13 @@ //! # 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::{InFlightHtlcs, InvoicePayer, Payer, Retry, Router}; +//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter}; //! # use secp256k1::PublicKey; //! # use std::cell::RefCell; //! # use std::ops::Deref; @@ -59,11 +59,12 @@ //! # 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!() } @@ -73,10 +74,11 @@ //! # struct FakeRouter {} //! # impl Router for FakeRouter { //! # fn find_route( -//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash, +//! # &self, payer: &PublicKey, params: &RouteParameters, //! # 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!() } @@ -103,7 +105,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"), @@ -140,23 +142,22 @@ use bitcoin_hashes::Hash; use bitcoin_hashes::sha256::Hash as Sha256; use crate::prelude::*; -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::{PaymentParameters, Route, RouteHop, RouteParameters}; +use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router}; use lightning::util::errors::APIError; use lightning::util::events::{Event, EventHandler}; use lightning::util::logger::Logger; -use lightning::util::ser::Writeable; -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")] @@ -172,13 +173,25 @@ pub type InvoicePayer = InvoicePayerUsingTime:: 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: ScoringRouter, + L: Deref, + E: sealed::BaseEventHandler, + T: Time +> where P::Target: Payer, L::Target: Logger, { @@ -242,6 +255,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; @@ -251,13 +276,14 @@ 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>; @@ -266,13 +292,20 @@ pub trait Payer { 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]>, inflight_htlcs: InFlightHtlcs - ) -> Result; +/// 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. @@ -322,7 +355,8 @@ pub enum PaymentError { Sending(PaymentSendFailure), } -impl InvoicePayerUsingTime +impl + InvoicePayerUsingTime where P::Target: Payer, L::Target: Logger, @@ -346,36 +380,76 @@ 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()); @@ -398,7 +472,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) @@ -408,13 +482,41 @@ 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()), @@ -427,15 +529,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)); @@ -447,16 +549,15 @@ where let first_hops = self.payer.first_hops(); let inflight_htlcs = self.create_inflight_map(); let route = self.router.find_route( - &payer, ¶ms, &payment_hash, 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(payment_id) => { + Ok(()) => { for path in route.paths { self.process_path_inflight_htlcs(payment_hash, path); } - Ok(payment_id) + Ok(()) }, Err(e) => match e { PaymentSendFailure::ParameterError(_) => Err(e), @@ -474,11 +575,11 @@ where }, 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 + // 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::MonitorUpdateFailed) => { + Ok(_) | Err(APIError::MonitorUpdateInProgress) => { self.process_path_inflight_htlcs(payment_hash, path); }, _ => {}, @@ -491,13 +592,13 @@ where // 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(()) } }, }, @@ -552,8 +653,7 @@ where let inflight_htlcs = self.create_inflight_map(); let route = self.router.find_route( - &payer, ¶ms, &payment_hash, Some(&first_hops.iter().collect::>()), - inflight_htlcs + &payer, ¶ms, Some(&first_hops.iter().collect::>()), inflight_htlcs ); if route.is_err() { @@ -578,11 +678,11 @@ where }, 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 + // 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::MonitorUpdateFailed) => { + Ok(_) | Err(APIError::MonitorUpdateInProgress) => { self.process_path_inflight_htlcs(payment_hash, path); }, _ => {}, @@ -606,9 +706,8 @@ where 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. + /// Use path information in the payment_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. @@ -644,7 +743,7 @@ where } } - InFlightHtlcs(total_inflight_map) + InFlightHtlcs::new(total_inflight_map) } } @@ -659,12 +758,15 @@ fn has_expired(route_params: &RouteParameters) -> bool { } else { false } } -impl EventHandler for InvoicePayerUsingTime +impl + InvoicePayerUsingTime where P::Target: Payer, L::Target: Logger, { - fn handle_event(&self, event: &Event) { + /// 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), .. } @@ -694,7 +796,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()); } @@ -729,32 +831,37 @@ where } // Delegate to the decorated event handler unless the payment is retried. - self.event_handler.handle_event(event) + true } } -/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC -/// is traveling in. The direction boolean is determined by checking if the HTLC source's public -/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more -/// details. -pub struct InFlightHtlcs(HashMap<(u64, bool), u64>); - -impl InFlightHtlcs { - /// Returns liquidity in msat given the public key of the HTLC source, target, and short channel - /// id. - pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option { - self.0.get(&(channel_scid, source < target)).map(|v| *v) +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 Writeable for InFlightHtlcs { - fn write(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) } -} - -impl lightning::util::ser::Readable for InFlightHtlcs { - fn read(reader: &mut R) -> Result { - let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?; - Ok(Self(infight_map)) +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; + } } } @@ -762,7 +869,7 @@ impl lightning::util::ser::Readable for InFlightHtlcs { mod tests { use super::*; use crate::{InvoiceBuilder, Currency}; - use utils::{ScorerAccountingForInFlightHtlcs, create_invoice_from_channelmanager_and_duration_since_epoch}; + use crate::utils::{ScorerAccountingForInFlightHtlcs, create_invoice_from_channelmanager_and_duration_since_epoch}; use bitcoin_hashes::sha256::Hash as Sha256; use lightning::ln::PaymentPreimage; use lightning::ln::channelmanager; @@ -770,7 +877,7 @@ mod tests { 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::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router}; use lightning::routing::scoring::{ChannelUsage, LockableScore, Score}; use lightning::util::test_utils::TestLogger; use lightning::util::errors::APIError; @@ -780,9 +887,9 @@ mod tests { 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; + use lightning::util::errors::APIError::{ChannelUnavailable, MonitorUpdateInProgress}; fn invoice(payment_preimage: PaymentPreimage) -> Invoice { let payment_hash = Sha256::hash(&payment_preimage.0); @@ -853,7 +960,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); @@ -869,7 +976,7 @@ mod tests { 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); @@ -879,7 +986,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); @@ -907,11 +1014,11 @@ mod tests { 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); @@ -920,7 +1027,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); @@ -944,7 +1051,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,15 +1077,15 @@ mod tests { 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); @@ -988,7 +1095,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); @@ -1016,7 +1123,7 @@ mod tests { 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); @@ -1032,11 +1139,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); } @@ -1045,7 +1152,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); @@ -1075,13 +1182,13 @@ mod tests { 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); } @@ -1089,7 +1196,7 @@ 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); @@ -1114,7 +1221,7 @@ mod tests { 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); } @@ -1124,7 +1231,7 @@ 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::new(TestScorer::new()); @@ -1144,7 +1251,7 @@ 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); @@ -1173,7 +1280,7 @@ mod tests { 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); } @@ -1181,7 +1288,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); @@ -1209,7 +1316,7 @@ mod tests { 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); } @@ -1217,7 +1324,7 @@ 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); @@ -1242,7 +1349,7 @@ mod tests { 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); } @@ -1250,7 +1357,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); @@ -1290,7 +1397,7 @@ mod tests { 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); } @@ -1300,7 +1407,7 @@ mod tests { let router = FailingRouter {}; let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &logger, |_: &_| {}, Retry::Attempts(0)); + InvoicePayer::new(&payer, router, &logger, |_: Event| {}, Retry::Attempts(0)); let payment_preimage = PaymentPreimage([1; 32]); let invoice = invoice(payment_preimage); @@ -1323,7 +1430,7 @@ mod tests { let router = TestRouter::new(TestScorer::new()); let logger = TestLogger::new(); let invoice_payer = - InvoicePayer::new(&payer, router, &logger, |_: &_| {}, Retry::Attempts(0)); + InvoicePayer::new(&payer, router, &logger, |_: Event| {}, Retry::Attempts(0)); match invoice_payer.pay_invoice(&invoice) { Err(PaymentError::Sending(_)) => {}, @@ -1335,7 +1442,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); @@ -1352,7 +1459,7 @@ mod tests { 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); @@ -1362,7 +1469,7 @@ 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::new(TestScorer::new()); @@ -1384,7 +1491,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]); @@ -1420,11 +1527,11 @@ mod tests { 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); @@ -1434,7 +1541,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); @@ -1466,13 +1573,13 @@ mod tests { 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); @@ -1494,17 +1601,17 @@ mod tests { 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() { 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); @@ -1531,7 +1638,7 @@ mod tests { assert_eq!(inflight_map.0.get(&(3, false)).unwrap().clone(), 74); assert_eq!(inflight_map.0.get(&(4, false)).unwrap().clone(), 64); - invoice_payer.handle_event(&Event::PaymentPathSuccessful { + invoice_payer.handle_event(Event::PaymentPathSuccessful { payment_id, payment_hash, path: route.paths[0].clone() }); @@ -1550,7 +1657,7 @@ mod tests { 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); @@ -1584,7 +1691,7 @@ mod tests { // Succeed 1st path, leave 2nd path inflight let payment_id = invoice_payer.pay_invoice(&payment_invoice).unwrap(); - invoice_payer.handle_event(&Event::PaymentPathSuccessful { + invoice_payer.handle_event(Event::PaymentPathSuccessful { payment_id, payment_hash, path: route.paths[0].clone() }); @@ -1601,7 +1708,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); @@ -1642,7 +1749,7 @@ mod tests { // 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.handle_event(Event::PaymentPathFailed { payment_id, payment_hash, network_update: None, @@ -1654,7 +1761,7 @@ mod tests { }); // Fails again the 1st path of our retry - invoice_payer.handle_event(&Event::PaymentPathFailed { + invoice_payer.handle_event(Event::PaymentPathFailed { payment_id, payment_hash, network_update: None, @@ -1672,7 +1779,7 @@ 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 event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice_to_pay = invoice(payment_preimage); @@ -1683,7 +1790,7 @@ mod tests { .fails_with_partial_failure( retry.clone(), OnAttempt(1), Some(vec![ - Err(ChannelUnavailable { err: "abc".to_string() }), Err(MonitorUpdateFailed) + Err(ChannelUnavailable { err: "abc".to_string() }), Err(MonitorUpdateInProgress) ])) .expect_send(Amount::ForInvoice(final_value_msat)); @@ -1695,7 +1802,7 @@ mod tests { 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 + // Only the second path, which failed with `MonitorUpdateInProgress` should be added to our // inflight map because retries are disabled. assert_eq!(inflight_map.0.len(), 2); } @@ -1703,7 +1810,7 @@ mod tests { #[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 event_handler = |_: Event| { *event_handled.borrow_mut() = true; }; let payment_preimage = PaymentPreimage([1; 32]); let invoice_to_pay = invoice(payment_preimage); @@ -1714,7 +1821,7 @@ mod tests { .fails_with_partial_failure( retry.clone(), OnAttempt(1), Some(vec![ - Ok(()), Err(MonitorUpdateFailed) + Ok(()), Err(MonitorUpdateInProgress) ])) .expect_send(Amount::ForInvoice(final_value_msat)); @@ -1813,7 +1920,7 @@ mod tests { impl Router for TestRouter { fn find_route( - &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash, + &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 @@ -1844,7 +1951,9 @@ 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); } @@ -1866,12 +1975,14 @@ mod tests { impl Router for FailingRouter { fn find_route( - &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash, - _first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs + &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, + _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]) {} @@ -1913,7 +2024,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 { @@ -2039,7 +2150,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)) } @@ -2056,13 +2167,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(()) } } @@ -2100,15 +2211,15 @@ 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.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() } @@ -2117,7 +2228,7 @@ 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.check_attempts() } fn abandon_payment(&self, _payment_id: PaymentId) { } @@ -2128,12 +2239,13 @@ mod tests { impl Router for ManualRouter { fn find_route( - &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash, - _first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs + &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, + _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]) {} @@ -2195,12 +2307,12 @@ mod tests { route.paths[1][0].fee_msat = 50_000_000; router.expect_find_route(Ok(route.clone())); - let event_handler = |_: &_| { panic!(); }; + 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); @@ -2240,12 +2352,12 @@ mod tests { route.paths[1][0].fee_msat = 50_000_001; router.expect_find_route(Ok(route.clone())); - let event_handler = |_: &_| { panic!(); }; + 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); @@ -2317,16 +2429,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 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); @@ -2393,7 +2505,7 @@ 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| { + 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); @@ -2411,13 +2523,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| { + 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"); } });