//! # 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;
//! # fn node_id(&self) -> PublicKey { unimplemented!() }
//! # fn first_hops(&self) -> Vec<ChannelDetails> { unimplemented!() }
//! # fn send_payment(
-//! # &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>
-//! # ) -> Result<PaymentId, PaymentSendFailure> { unimplemented!() }
+//! # &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>,
+//! # payment_id: PaymentId
+//! # ) -> Result<(), PaymentSendFailure> { unimplemented!() }
//! # fn send_spontaneous_payment(
-//! # &self, route: &Route, payment_preimage: PaymentPreimage
-//! # ) -> Result<PaymentId, PaymentSendFailure> { 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!() }
//! # 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<Route, LightningError> { 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!() }
//! # }
//! #
//! # 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"),
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")]
#[cfg(not(feature = "no-std"))]
type ConfiguredTime = std::time::Instant;
#[cfg(feature = "no-std")]
-use time_utils;
+use crate::time_utils;
#[cfg(feature = "no-std")]
type ConfiguredTime = time_utils::Eternity;
+/// Sealed trait with a blanket implementation to allow both sync and async implementations of event
+/// handling to exist within the InvoicePayer.
+mod sealed {
+ pub trait BaseEventHandler {}
+ impl<T> BaseEventHandler for T {}
+}
+
/// (C-not exported) generally all users should use the [`InvoicePayer`] type alias.
-pub struct InvoicePayerUsingTime<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time>
-where
+pub struct InvoicePayerUsingTime<
+ P: Deref,
+ R: ScoringRouter,
+ L: Deref,
+ E: sealed::BaseEventHandler,
+ T: Time
+> where
P::Target: Payer,
L::Target: Logger,
{
}
/// 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;
/// Sends a payment over the Lightning Network using the given [`Route`].
fn send_payment(
- &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>
- ) -> Result<PaymentId, PaymentSendFailure>;
+ &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>,
+ 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<PaymentId, PaymentSendFailure>;
+ &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>;
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<Route, LightningError>;
+/// 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<Route, LightningError> {
+ 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.
Sending(PaymentSendFailure),
}
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: sealed::BaseEventHandler, T: Time>
+ InvoicePayerUsingTime<P, R, L, E, T>
where
P::Target: Payer,
L::Target: Logger,
/// 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<PaymentId, PaymentError> {
+ 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<PaymentId, PaymentError> {
+ 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<u64>
- ) -> Result<PaymentId, PaymentError> {
+ &self, invoice: &Invoice, amount_msats: Option<u64>, 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());
};
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)
/// 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<PaymentId, PaymentError> {
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()),
};
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<F: FnOnce(&Route) -> Result<PaymentId, PaymentSendFailure> + Copy>(
+ fn pay_internal<F: FnOnce(&Route) -> Result<(), PaymentSendFailure> + Copy>(
&self, params: &RouteParameters, payment_hash: PaymentHash, send_payment: F,
- ) -> Result<PaymentId, PaymentError> {
+ ) -> 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));
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::<Vec<_>>()),
- inflight_htlcs
+ &payer, ¶ms, Some(&first_hops.iter().collect::<Vec<_>>()), 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),
},
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);
},
_ => {},
// 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(())
}
},
},
let inflight_htlcs = self.create_inflight_map();
let route = self.router.find_route(
- &payer, ¶ms, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, ¶ms, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
);
if route.is_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 `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);
},
_ => {},
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.
}
}
- InFlightHtlcs(total_inflight_map)
+ InFlightHtlcs::new(total_inflight_map)
}
}
} else { false }
}
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: sealed::BaseEventHandler, T: Time>
+ InvoicePayerUsingTime<P, R, L, E, T>
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), .. }
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());
}
}
// 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<u64> {
- self.0.get(&(channel_scid, source < target)).map(|v| *v)
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time>
+ EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+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<W: lightning::util::ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
-}
-
-impl lightning::util::ser::Readable for InFlightHtlcs {
- fn read<R: io::Read>(reader: &mut R) -> Result<Self, lightning::ln::msgs::DecodeError> {
- let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?;
- Ok(Self(infight_map))
+impl<P: Deref, R: ScoringRouter, L: Deref, T: Time, F: Future, H: Fn(Event) -> F>
+ InvoicePayerUsingTime<P, R, L, H, T>
+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;
+ }
}
}
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;
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;
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);
#[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);
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);
#[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);
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);
#[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);
#[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);
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);
#[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);
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);
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);
}
#[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);
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);
}
#[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);
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);
}
#[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());
#[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);
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);
}
#[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);
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);
}
#[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);
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);
}
#[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);
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);
}
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);
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(_)) => {},
#[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);
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);
#[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());
#[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]);
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);
#[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);
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);
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);
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()
});
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);
// 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()
});
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);
// 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,
});
// 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,
#[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);
.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));
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);
}
#[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);
.fails_with_partial_failure(
retry.clone(), OnAttempt(1),
Some(vec![
- Ok(()), Err(MonitorUpdateFailed)
+ Ok(()), Err(MonitorUpdateInProgress)
]))
.expect_send(Amount::ForInvoice(final_value_msat));
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<Route, LightningError> {
// Simulate calling the Scorer just as you would in find_route
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);
}
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<Route, LightningError> {
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]) {}
}
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))
}
self
}
- fn check_attempts(&self) -> Result<PaymentId, PaymentSendFailure> {
+ 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(())
}
}
fn send_payment(
&self, route: &Route, _payment_hash: PaymentHash,
- _payment_secret: &Option<PaymentSecret>
- ) -> Result<PaymentId, PaymentSendFailure> {
+ _payment_secret: &Option<PaymentSecret>, _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<PaymentId, PaymentSendFailure> {
+ &self, route: &Route, _payment_preimage: PaymentPreimage, _payment_id: PaymentId,
+ ) -> Result<(), PaymentSendFailure> {
self.check_value_msats(Amount::Spontaneous(route.get_total_amount()));
self.check_attempts()
}
&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) { }
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<Route, LightningError> {
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]) {}
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);
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);
route.paths.remove(1);
router.expect_find_route(Ok(route.clone()));
- let expected_events: RefCell<VecDeque<&dyn Fn(&Event)>> = RefCell::new(VecDeque::new());
- let event_handler = |event: &Event| {
+ let expected_events: RefCell<VecDeque<&dyn Fn(Event)>> = 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);
// `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);
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"); }
});
projects / rust-lightning / blobdiff