1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! A module for paying Lightning invoices.
12 //! Defines an [`InvoicePayer`] utility for paying invoices, parameterized by [`Payer`] and
13 //! [`Router`] traits. Implementations of [`Payer`] provide the payer's node id, channels, and means
14 //! to send a payment over a [`Route`]. Implementations of [`Router`] find a [`Route`] between payer
15 //! and payee using information provided by the payer and from the payee's [`Invoice`].
17 //! [`InvoicePayer`] is capable of retrying failed payments. It accomplishes this by implementing
18 //! [`EventHandler`] which decorates a user-provided handler. It will intercept any
19 //! [`Event::PaymentPathFailed`] events and retry the failed paths for a fixed number of total
20 //! attempts or until retry is no longer possible. In such a situation, [`InvoicePayer`] will pass
21 //! along the events to the user-provided handler.
26 //! # extern crate lightning;
27 //! # extern crate lightning_invoice;
28 //! # extern crate secp256k1;
30 //! # use lightning::ln::{PaymentHash, PaymentSecret};
31 //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
32 //! # use lightning::ln::msgs::LightningError;
33 //! # use lightning::routing;
34 //! # use lightning::routing::network_graph::NodeId;
35 //! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
36 //! # use lightning::util::events::{Event, EventHandler, EventsProvider};
37 //! # use lightning::util::logger::{Logger, Record};
38 //! # use lightning_invoice::Invoice;
39 //! # use lightning_invoice::payment::{InvoicePayer, Payer, RetryAttempts, Router};
40 //! # use secp256k1::key::PublicKey;
41 //! # use std::cell::RefCell;
42 //! # use std::ops::Deref;
44 //! # struct FakeEventProvider {}
45 //! # impl EventsProvider for FakeEventProvider {
46 //! # fn process_pending_events<H: Deref>(&self, handler: H) where H::Target: EventHandler {}
49 //! # struct FakePayer {}
50 //! # impl Payer for FakePayer {
51 //! # fn node_id(&self) -> PublicKey { unimplemented!() }
52 //! # fn first_hops(&self) -> Vec<ChannelDetails> { unimplemented!() }
53 //! # fn send_payment(
54 //! # &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>
55 //! # ) -> Result<PaymentId, PaymentSendFailure> { unimplemented!() }
56 //! # fn retry_payment(
57 //! # &self, route: &Route, payment_id: PaymentId
58 //! # ) -> Result<(), PaymentSendFailure> { unimplemented!() }
61 //! # struct FakeRouter {};
62 //! # impl<S: routing::Score> Router<S> for FakeRouter {
64 //! # &self, payer: &PublicKey, params: &RouteParameters,
65 //! # first_hops: Option<&[&ChannelDetails]>, scorer: &S
66 //! # ) -> Result<Route, LightningError> { unimplemented!() }
69 //! # struct FakeScorer {};
70 //! # impl routing::Score for FakeScorer {
71 //! # fn channel_penalty_msat(
72 //! # &self, _short_channel_id: u64, _source: &NodeId, _target: &NodeId
74 //! # fn payment_path_failed(&mut self, _path: &[&RouteHop], _short_channel_id: u64) {}
77 //! # struct FakeLogger {};
78 //! # impl Logger for FakeLogger {
79 //! # fn log(&self, record: &Record) { unimplemented!() }
83 //! let event_handler = |event: &Event| {
85 //! Event::PaymentPathFailed { .. } => println!("payment failed after retries"),
86 //! Event::PaymentSent { .. } => println!("payment successful"),
90 //! # let payer = FakePayer {};
91 //! # let router = FakeRouter {};
92 //! # let scorer = RefCell::new(FakeScorer {});
93 //! # let logger = FakeLogger {};
94 //! let invoice_payer = InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
96 //! let invoice = "...";
97 //! let invoice = invoice.parse::<Invoice>().unwrap();
98 //! invoice_payer.pay_invoice(&invoice).unwrap();
100 //! # let event_provider = FakeEventProvider {};
102 //! event_provider.process_pending_events(&invoice_payer);
109 //! The [`Route`] is computed before each payment attempt. Any updates affecting path finding such
110 //! as updates to the network graph or changes to channel scores should be applied prior to
111 //! retries, typically by way of composing [`EventHandler`]s accordingly.
115 use bitcoin_hashes::Hash;
117 use lightning::ln::{PaymentHash, PaymentSecret};
118 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
119 use lightning::ln::msgs::LightningError;
120 use lightning::routing;
121 use lightning::routing::{LockableScore, Score};
122 use lightning::routing::router::{Payee, Route, RouteParameters};
123 use lightning::util::events::{Event, EventHandler};
124 use lightning::util::logger::Logger;
126 use secp256k1::key::PublicKey;
128 use std::collections::hash_map::{self, HashMap};
130 use std::sync::Mutex;
131 use std::time::{Duration, SystemTime};
133 /// A utility for paying [`Invoice]`s.
134 pub struct InvoicePayer<P: Deref, R, S: Deref, L: Deref, E>
137 R: for <'a> Router<<<S as Deref>::Target as routing::LockableScore<'a>>::Locked>,
138 S::Target: for <'a> routing::LockableScore<'a>,
147 payment_cache: Mutex<HashMap<PaymentHash, usize>>,
148 retry_attempts: RetryAttempts,
151 /// A trait defining behavior of an [`Invoice`] payer.
153 /// Returns the payer's node id.
154 fn node_id(&self) -> PublicKey;
156 /// Returns the payer's channels.
157 fn first_hops(&self) -> Vec<ChannelDetails>;
159 /// Sends a payment over the Lightning Network using the given [`Route`].
161 &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>
162 ) -> Result<PaymentId, PaymentSendFailure>;
164 /// Retries a failed payment path for the [`PaymentId`] using the given [`Route`].
165 fn retry_payment(&self, route: &Route, payment_id: PaymentId) -> Result<(), PaymentSendFailure>;
168 /// A trait defining behavior for routing an [`Invoice`] payment.
169 pub trait Router<S: routing::Score> {
170 /// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
172 &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
174 ) -> Result<Route, LightningError>;
177 /// Number of attempts to retry payment path failures for an [`Invoice`].
179 /// Note that this is the number of *path* failures, not full payment retries. For multi-path
180 /// payments, if this is less than the total number of paths, we will never even retry all of the
182 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
183 pub struct RetryAttempts(pub usize);
185 /// An error that may occur when making a payment.
186 #[derive(Clone, Debug)]
187 pub enum PaymentError {
188 /// An error resulting from the provided [`Invoice`] or payment hash.
189 Invoice(&'static str),
190 /// An error occurring when finding a route.
191 Routing(LightningError),
192 /// An error occurring when sending a payment.
193 Sending(PaymentSendFailure),
196 impl<P: Deref, R, S: Deref, L: Deref, E> InvoicePayer<P, R, S, L, E>
199 R: for <'a> Router<<<S as Deref>::Target as routing::LockableScore<'a>>::Locked>,
200 S::Target: for <'a> routing::LockableScore<'a>,
204 /// Creates an invoice payer that retries failed payment paths.
206 /// Will forward any [`Event::PaymentPathFailed`] events to the decorated `event_handler` once
207 /// `retry_attempts` has been exceeded for a given [`Invoice`].
209 payer: P, router: R, scorer: S, logger: L, event_handler: E, retry_attempts: RetryAttempts
217 payment_cache: Mutex::new(HashMap::new()),
222 /// Pays the given [`Invoice`], caching it for later use in case a retry is needed.
224 /// You should ensure that the `invoice.payment_hash()` is unique and the same payment_hash has
225 /// never been paid before. Because [`InvoicePayer`] is stateless no effort is made to do so
227 pub fn pay_invoice(&self, invoice: &Invoice) -> Result<PaymentId, PaymentError> {
228 if invoice.amount_milli_satoshis().is_none() {
229 Err(PaymentError::Invoice("amount missing"))
231 self.pay_invoice_internal(invoice, None, 0)
235 /// Pays the given zero-value [`Invoice`] using the given amount, caching it for later use in
236 /// case a retry is needed.
238 /// You should ensure that the `invoice.payment_hash()` is unique and the same payment_hash has
239 /// never been paid before. Because [`InvoicePayer`] is stateless no effort is made to do so
241 pub fn pay_zero_value_invoice(
242 &self, invoice: &Invoice, amount_msats: u64
243 ) -> Result<PaymentId, PaymentError> {
244 if invoice.amount_milli_satoshis().is_some() {
245 Err(PaymentError::Invoice("amount unexpected"))
247 self.pay_invoice_internal(invoice, Some(amount_msats), 0)
251 fn pay_invoice_internal(
252 &self, invoice: &Invoice, amount_msats: Option<u64>, retry_count: usize
253 ) -> Result<PaymentId, PaymentError> {
254 debug_assert!(invoice.amount_milli_satoshis().is_some() ^ amount_msats.is_some());
255 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
256 if invoice.is_expired() {
257 log_trace!(self.logger, "Invoice expired prior to first send for payment {}", log_bytes!(payment_hash.0));
258 return Err(PaymentError::Invoice("Invoice expired prior to send"));
260 let retry_data_payment_id = loop {
261 let mut payment_cache = self.payment_cache.lock().unwrap();
262 match payment_cache.entry(payment_hash) {
263 hash_map::Entry::Vacant(entry) => {
264 let payer = self.payer.node_id();
265 let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key())
266 .with_expiry_time(expiry_time_from_unix_epoch(&invoice).as_secs())
267 .with_route_hints(invoice.route_hints());
268 if let Some(features) = invoice.features() {
269 payee = payee.with_features(features.clone());
271 let params = RouteParameters {
273 final_value_msat: invoice.amount_milli_satoshis().or(amount_msats).unwrap(),
274 final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
276 let first_hops = self.payer.first_hops();
277 let route = self.router.find_route(
280 Some(&first_hops.iter().collect::<Vec<_>>()),
282 ).map_err(|e| PaymentError::Routing(e))?;
284 let payment_secret = Some(invoice.payment_secret().clone());
285 let payment_id = match self.payer.send_payment(&route, payment_hash, &payment_secret) {
286 Ok(payment_id) => payment_id,
287 Err(PaymentSendFailure::ParameterError(e)) =>
288 return Err(PaymentError::Sending(PaymentSendFailure::ParameterError(e))),
289 Err(PaymentSendFailure::PathParameterError(e)) =>
290 return Err(PaymentError::Sending(PaymentSendFailure::PathParameterError(e))),
291 Err(PaymentSendFailure::AllFailedRetrySafe(e)) => {
292 if retry_count >= self.retry_attempts.0 {
293 return Err(PaymentError::Sending(PaymentSendFailure::AllFailedRetrySafe(e)))
297 Err(PaymentSendFailure::PartialFailure { results: _, failed_paths_retry, payment_id }) => {
298 if let Some(retry_data) = failed_paths_retry {
299 entry.insert(retry_count);
300 break Some((retry_data, payment_id));
302 // This may happen if we send a payment and some paths fail, but
303 // only due to a temporary monitor failure or the like, implying
304 // they're really in-flight, but we haven't sent the initial
305 // HTLC-Add messages yet.
310 entry.insert(retry_count);
311 return Ok(payment_id);
313 hash_map::Entry::Occupied(_) => return Err(PaymentError::Invoice("payment pending")),
316 if let Some((retry_data, payment_id)) = retry_data_payment_id {
317 // Some paths were sent, even if we failed to send the full MPP value our recipient may
318 // misbehave and claim the funds, at which point we have to consider the payment sent,
319 // so return `Ok()` here, ignoring any retry errors.
320 let _ = self.retry_payment(payment_id, payment_hash, &retry_data);
323 self.pay_invoice_internal(invoice, amount_msats, retry_count + 1)
327 fn retry_payment(&self, payment_id: PaymentId, payment_hash: PaymentHash, params: &RouteParameters)
331 let mut payment_cache = self.payment_cache.lock().unwrap();
333 let entry = payment_cache.entry(payment_hash);
335 hash_map::Entry::Occupied(_) => break entry,
336 hash_map::Entry::Vacant(entry) => entry.insert(0),
339 if let hash_map::Entry::Occupied(mut entry) = entry {
340 let max_payment_attempts = self.retry_attempts.0 + 1;
341 let attempts = entry.get_mut();
344 if *attempts >= max_payment_attempts {
345 log_trace!(self.logger, "Payment {} exceeded maximum attempts; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
347 } else if has_expired(params) {
348 log_trace!(self.logger, "Invoice expired for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
352 let payer = self.payer.node_id();
353 let first_hops = self.payer.first_hops();
354 route = self.router.find_route(&payer, ¶ms, Some(&first_hops.iter().collect::<Vec<_>>()), &self.scorer.lock());
356 log_trace!(self.logger, "Failed to find a route for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
364 let retry_res = self.payer.retry_payment(&route.unwrap(), payment_id);
367 Err(PaymentSendFailure::ParameterError(_)) |
368 Err(PaymentSendFailure::PathParameterError(_)) => {
369 log_trace!(self.logger, "Failed to retry for payment {} due to bogus route/payment data, not retrying.", log_bytes!(payment_hash.0));
372 Err(PaymentSendFailure::AllFailedRetrySafe(_)) => {
373 self.retry_payment(payment_id, payment_hash, params)
375 Err(PaymentSendFailure::PartialFailure { results: _, failed_paths_retry, .. }) => {
376 if let Some(retry) = failed_paths_retry {
377 self.retry_payment(payment_id, payment_hash, &retry)
385 /// Removes the payment cached by the given payment hash.
387 /// Should be called once a payment has failed or succeeded if not using [`InvoicePayer`] as an
388 /// [`EventHandler`]. Otherwise, calling this method is unnecessary.
389 pub fn remove_cached_payment(&self, payment_hash: &PaymentHash) {
390 self.payment_cache.lock().unwrap().remove(payment_hash);
394 fn expiry_time_from_unix_epoch(invoice: &Invoice) -> Duration {
395 invoice.timestamp().duration_since(SystemTime::UNIX_EPOCH).unwrap() + invoice.expiry_time()
398 fn has_expired(params: &RouteParameters) -> bool {
399 if let Some(expiry_time) = params.payee.expiry_time {
400 Invoice::is_expired_from_epoch(&SystemTime::UNIX_EPOCH, Duration::from_secs(expiry_time))
404 impl<P: Deref, R, S: Deref, L: Deref, E> EventHandler for InvoicePayer<P, R, S, L, E>
407 R: for <'a> Router<<<S as Deref>::Target as routing::LockableScore<'a>>::Locked>,
408 S::Target: for <'a> routing::LockableScore<'a>,
412 fn handle_event(&self, event: &Event) {
414 Event::PaymentPathFailed {
415 all_paths_failed, payment_id, payment_hash, rejected_by_dest, path, short_channel_id, retry, ..
417 if let Some(short_channel_id) = short_channel_id {
418 let t = path.iter().collect::<Vec<_>>();
419 self.scorer.lock().payment_path_failed(&t, *short_channel_id);
422 if *rejected_by_dest {
423 log_trace!(self.logger, "Payment {} rejected by destination; not retrying", log_bytes!(payment_hash.0));
424 } else if payment_id.is_none() {
425 log_trace!(self.logger, "Payment {} has no id; not retrying", log_bytes!(payment_hash.0));
426 } else if let Some(params) = retry {
427 if self.retry_payment(payment_id.unwrap(), *payment_hash, params).is_ok() {
428 // We retried at least somewhat, don't provide the PaymentPathFailed event to the user.
432 log_trace!(self.logger, "Payment {} missing retry params; not retrying", log_bytes!(payment_hash.0));
434 if *all_paths_failed { self.payment_cache.lock().unwrap().remove(payment_hash); }
436 Event::PaymentSent { payment_hash, .. } => {
437 let mut payment_cache = self.payment_cache.lock().unwrap();
438 let attempts = payment_cache
439 .remove(payment_hash)
440 .map_or(1, |attempts| attempts + 1);
441 log_trace!(self.logger, "Payment {} succeeded (attempts: {})", log_bytes!(payment_hash.0), attempts);
446 // Delegate to the decorated event handler unless the payment is retried.
447 self.event_handler.handle_event(event)
454 use crate::{DEFAULT_EXPIRY_TIME, InvoiceBuilder, Currency};
455 use utils::create_invoice_from_channelmanager;
456 use bitcoin_hashes::sha256::Hash as Sha256;
457 use lightning::ln::PaymentPreimage;
458 use lightning::ln::features::{ChannelFeatures, NodeFeatures, InitFeatures};
459 use lightning::ln::functional_test_utils::*;
460 use lightning::ln::msgs::{ErrorAction, LightningError};
461 use lightning::routing::network_graph::NodeId;
462 use lightning::routing::router::{Payee, Route, RouteHop};
463 use lightning::util::test_utils::TestLogger;
464 use lightning::util::errors::APIError;
465 use lightning::util::events::{Event, MessageSendEventsProvider};
466 use secp256k1::{SecretKey, PublicKey, Secp256k1};
467 use std::cell::RefCell;
468 use std::collections::VecDeque;
469 use std::time::{SystemTime, Duration};
471 fn invoice(payment_preimage: PaymentPreimage) -> Invoice {
472 let payment_hash = Sha256::hash(&payment_preimage.0);
473 let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
474 InvoiceBuilder::new(Currency::Bitcoin)
475 .description("test".into())
476 .payment_hash(payment_hash)
477 .payment_secret(PaymentSecret([0; 32]))
479 .min_final_cltv_expiry(144)
480 .amount_milli_satoshis(128)
481 .build_signed(|hash| {
482 Secp256k1::new().sign_recoverable(hash, &private_key)
487 fn zero_value_invoice(payment_preimage: PaymentPreimage) -> Invoice {
488 let payment_hash = Sha256::hash(&payment_preimage.0);
489 let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
490 InvoiceBuilder::new(Currency::Bitcoin)
491 .description("test".into())
492 .payment_hash(payment_hash)
493 .payment_secret(PaymentSecret([0; 32]))
495 .min_final_cltv_expiry(144)
496 .build_signed(|hash| {
497 Secp256k1::new().sign_recoverable(hash, &private_key)
502 fn expired_invoice(payment_preimage: PaymentPreimage) -> Invoice {
503 let payment_hash = Sha256::hash(&payment_preimage.0);
504 let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
505 let timestamp = SystemTime::now()
506 .checked_sub(Duration::from_secs(DEFAULT_EXPIRY_TIME * 2))
508 InvoiceBuilder::new(Currency::Bitcoin)
509 .description("test".into())
510 .payment_hash(payment_hash)
511 .payment_secret(PaymentSecret([0; 32]))
512 .timestamp(timestamp)
513 .min_final_cltv_expiry(144)
514 .amount_milli_satoshis(128)
515 .build_signed(|hash| {
516 Secp256k1::new().sign_recoverable(hash, &private_key)
522 fn pays_invoice_on_first_attempt() {
523 let event_handled = core::cell::RefCell::new(false);
524 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
526 let payment_preimage = PaymentPreimage([1; 32]);
527 let invoice = invoice(payment_preimage);
528 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
530 let payer = TestPayer::new();
531 let router = TestRouter {};
532 let scorer = RefCell::new(TestScorer::new());
533 let logger = TestLogger::new();
535 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(0));
537 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
538 assert_eq!(*payer.attempts.borrow(), 1);
540 invoice_payer.handle_event(&Event::PaymentSent {
541 payment_id, payment_preimage, payment_hash, fee_paid_msat: None
543 assert_eq!(*event_handled.borrow(), true);
544 assert_eq!(*payer.attempts.borrow(), 1);
548 fn pays_invoice_on_retry() {
549 let event_handled = core::cell::RefCell::new(false);
550 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
552 let payment_preimage = PaymentPreimage([1; 32]);
553 let invoice = invoice(payment_preimage);
554 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
555 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
557 let payer = TestPayer::new()
558 .expect_value_msat(final_value_msat)
559 .expect_value_msat(final_value_msat / 2);
560 let router = TestRouter {};
561 let scorer = RefCell::new(TestScorer::new());
562 let logger = TestLogger::new();
564 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
566 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
567 assert_eq!(*payer.attempts.borrow(), 1);
569 let event = Event::PaymentPathFailed {
572 network_update: None,
573 rejected_by_dest: false,
574 all_paths_failed: false,
575 path: TestRouter::path_for_value(final_value_msat),
576 short_channel_id: None,
577 retry: Some(TestRouter::retry_for_invoice(&invoice)),
579 invoice_payer.handle_event(&event);
580 assert_eq!(*event_handled.borrow(), false);
581 assert_eq!(*payer.attempts.borrow(), 2);
583 invoice_payer.handle_event(&Event::PaymentSent {
584 payment_id, payment_preimage, payment_hash, fee_paid_msat: None
586 assert_eq!(*event_handled.borrow(), true);
587 assert_eq!(*payer.attempts.borrow(), 2);
591 fn retries_payment_path_for_unknown_payment() {
592 let event_handled = core::cell::RefCell::new(false);
593 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
595 let payment_preimage = PaymentPreimage([1; 32]);
596 let invoice = invoice(payment_preimage);
597 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
598 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
600 let payer = TestPayer::new();
601 let router = TestRouter {};
602 let scorer = RefCell::new(TestScorer::new());
603 let logger = TestLogger::new();
605 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
607 let payment_id = Some(PaymentId([1; 32]));
608 let event = Event::PaymentPathFailed {
611 network_update: None,
612 rejected_by_dest: false,
613 all_paths_failed: false,
614 path: TestRouter::path_for_value(final_value_msat),
615 short_channel_id: None,
616 retry: Some(TestRouter::retry_for_invoice(&invoice)),
618 invoice_payer.handle_event(&event);
619 assert_eq!(*event_handled.borrow(), false);
620 assert_eq!(*payer.attempts.borrow(), 1);
622 invoice_payer.handle_event(&event);
623 assert_eq!(*event_handled.borrow(), false);
624 assert_eq!(*payer.attempts.borrow(), 2);
626 invoice_payer.handle_event(&Event::PaymentSent {
627 payment_id, payment_preimage, payment_hash, fee_paid_msat: None
629 assert_eq!(*event_handled.borrow(), true);
630 assert_eq!(*payer.attempts.borrow(), 2);
634 fn fails_paying_invoice_after_max_retries() {
635 let event_handled = core::cell::RefCell::new(false);
636 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
638 let payment_preimage = PaymentPreimage([1; 32]);
639 let invoice = invoice(payment_preimage);
640 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
642 let payer = TestPayer::new()
643 .expect_value_msat(final_value_msat)
644 .expect_value_msat(final_value_msat / 2)
645 .expect_value_msat(final_value_msat / 2);
646 let router = TestRouter {};
647 let scorer = RefCell::new(TestScorer::new());
648 let logger = TestLogger::new();
650 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
652 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
653 assert_eq!(*payer.attempts.borrow(), 1);
655 let event = Event::PaymentPathFailed {
657 payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
658 network_update: None,
659 rejected_by_dest: false,
660 all_paths_failed: true,
661 path: TestRouter::path_for_value(final_value_msat),
662 short_channel_id: None,
663 retry: Some(TestRouter::retry_for_invoice(&invoice)),
665 invoice_payer.handle_event(&event);
666 assert_eq!(*event_handled.borrow(), false);
667 assert_eq!(*payer.attempts.borrow(), 2);
669 let event = Event::PaymentPathFailed {
671 payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
672 network_update: None,
673 rejected_by_dest: false,
674 all_paths_failed: false,
675 path: TestRouter::path_for_value(final_value_msat / 2),
676 short_channel_id: None,
677 retry: Some(RouteParameters {
678 final_value_msat: final_value_msat / 2, ..TestRouter::retry_for_invoice(&invoice)
681 invoice_payer.handle_event(&event);
682 assert_eq!(*event_handled.borrow(), false);
683 assert_eq!(*payer.attempts.borrow(), 3);
685 invoice_payer.handle_event(&event);
686 assert_eq!(*event_handled.borrow(), true);
687 assert_eq!(*payer.attempts.borrow(), 3);
691 fn fails_paying_invoice_with_missing_retry_params() {
692 let event_handled = core::cell::RefCell::new(false);
693 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
695 let payer = TestPayer::new();
696 let router = TestRouter {};
697 let scorer = RefCell::new(TestScorer::new());
698 let logger = TestLogger::new();
700 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
702 let payment_preimage = PaymentPreimage([1; 32]);
703 let invoice = invoice(payment_preimage);
704 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
705 assert_eq!(*payer.attempts.borrow(), 1);
707 let event = Event::PaymentPathFailed {
709 payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
710 network_update: None,
711 rejected_by_dest: false,
712 all_paths_failed: false,
714 short_channel_id: None,
717 invoice_payer.handle_event(&event);
718 assert_eq!(*event_handled.borrow(), true);
719 assert_eq!(*payer.attempts.borrow(), 1);
723 fn fails_paying_invoice_after_expiration() {
724 let event_handled = core::cell::RefCell::new(false);
725 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
727 let payer = TestPayer::new();
728 let router = TestRouter {};
729 let scorer = RefCell::new(TestScorer::new());
730 let logger = TestLogger::new();
732 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
734 let payment_preimage = PaymentPreimage([1; 32]);
735 let invoice = expired_invoice(payment_preimage);
736 if let PaymentError::Invoice(msg) = invoice_payer.pay_invoice(&invoice).unwrap_err() {
737 assert_eq!(msg, "Invoice expired prior to send");
738 } else { panic!("Expected Invoice Error"); }
742 fn fails_retrying_invoice_after_expiration() {
743 let event_handled = core::cell::RefCell::new(false);
744 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
746 let payer = TestPayer::new();
747 let router = TestRouter {};
748 let scorer = RefCell::new(TestScorer::new());
749 let logger = TestLogger::new();
751 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
753 let payment_preimage = PaymentPreimage([1; 32]);
754 let invoice = invoice(payment_preimage);
755 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
756 assert_eq!(*payer.attempts.borrow(), 1);
758 let mut retry_data = TestRouter::retry_for_invoice(&invoice);
759 retry_data.payee.expiry_time = Some(SystemTime::now()
760 .checked_sub(Duration::from_secs(2)).unwrap()
761 .duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs());
762 let event = Event::PaymentPathFailed {
764 payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
765 network_update: None,
766 rejected_by_dest: false,
767 all_paths_failed: false,
769 short_channel_id: None,
770 retry: Some(retry_data),
772 invoice_payer.handle_event(&event);
773 assert_eq!(*event_handled.borrow(), true);
774 assert_eq!(*payer.attempts.borrow(), 1);
778 fn fails_paying_invoice_after_retry_error() {
779 let event_handled = core::cell::RefCell::new(false);
780 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
782 let payment_preimage = PaymentPreimage([1; 32]);
783 let invoice = invoice(payment_preimage);
784 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
786 let payer = TestPayer::new()
788 .expect_value_msat(final_value_msat);
789 let router = TestRouter {};
790 let scorer = RefCell::new(TestScorer::new());
791 let logger = TestLogger::new();
793 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
795 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
796 assert_eq!(*payer.attempts.borrow(), 1);
798 let event = Event::PaymentPathFailed {
800 payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
801 network_update: None,
802 rejected_by_dest: false,
803 all_paths_failed: false,
804 path: TestRouter::path_for_value(final_value_msat / 2),
805 short_channel_id: None,
806 retry: Some(TestRouter::retry_for_invoice(&invoice)),
808 invoice_payer.handle_event(&event);
809 assert_eq!(*event_handled.borrow(), true);
810 assert_eq!(*payer.attempts.borrow(), 2);
814 fn fails_paying_invoice_after_rejected_by_payee() {
815 let event_handled = core::cell::RefCell::new(false);
816 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
818 let payer = TestPayer::new();
819 let router = TestRouter {};
820 let scorer = RefCell::new(TestScorer::new());
821 let logger = TestLogger::new();
823 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
825 let payment_preimage = PaymentPreimage([1; 32]);
826 let invoice = invoice(payment_preimage);
827 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
828 assert_eq!(*payer.attempts.borrow(), 1);
830 let event = Event::PaymentPathFailed {
832 payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
833 network_update: None,
834 rejected_by_dest: true,
835 all_paths_failed: false,
837 short_channel_id: None,
838 retry: Some(TestRouter::retry_for_invoice(&invoice)),
840 invoice_payer.handle_event(&event);
841 assert_eq!(*event_handled.borrow(), true);
842 assert_eq!(*payer.attempts.borrow(), 1);
846 fn fails_repaying_invoice_with_pending_payment() {
847 let event_handled = core::cell::RefCell::new(false);
848 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
850 let payer = TestPayer::new();
851 let router = TestRouter {};
852 let scorer = RefCell::new(TestScorer::new());
853 let logger = TestLogger::new();
855 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(0));
857 let payment_preimage = PaymentPreimage([1; 32]);
858 let invoice = invoice(payment_preimage);
859 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
861 // Cannot repay an invoice pending payment.
862 match invoice_payer.pay_invoice(&invoice) {
863 Err(PaymentError::Invoice("payment pending")) => {},
864 Err(_) => panic!("unexpected error"),
865 Ok(_) => panic!("expected invoice error"),
868 // Can repay an invoice once cleared from cache.
869 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
870 invoice_payer.remove_cached_payment(&payment_hash);
871 assert!(invoice_payer.pay_invoice(&invoice).is_ok());
873 // Cannot retry paying an invoice if cleared from cache.
874 invoice_payer.remove_cached_payment(&payment_hash);
875 let event = Event::PaymentPathFailed {
878 network_update: None,
879 rejected_by_dest: false,
880 all_paths_failed: false,
882 short_channel_id: None,
883 retry: Some(TestRouter::retry_for_invoice(&invoice)),
885 invoice_payer.handle_event(&event);
886 assert_eq!(*event_handled.borrow(), true);
890 fn fails_paying_invoice_with_routing_errors() {
891 let payer = TestPayer::new();
892 let router = FailingRouter {};
893 let scorer = RefCell::new(TestScorer::new());
894 let logger = TestLogger::new();
896 InvoicePayer::new(&payer, router, &scorer, &logger, |_: &_| {}, RetryAttempts(0));
898 let payment_preimage = PaymentPreimage([1; 32]);
899 let invoice = invoice(payment_preimage);
900 match invoice_payer.pay_invoice(&invoice) {
901 Err(PaymentError::Routing(_)) => {},
902 Err(_) => panic!("unexpected error"),
903 Ok(_) => panic!("expected routing error"),
908 fn fails_paying_invoice_with_sending_errors() {
909 let payer = TestPayer::new().fails_on_attempt(1);
910 let router = TestRouter {};
911 let scorer = RefCell::new(TestScorer::new());
912 let logger = TestLogger::new();
914 InvoicePayer::new(&payer, router, &scorer, &logger, |_: &_| {}, RetryAttempts(0));
916 let payment_preimage = PaymentPreimage([1; 32]);
917 let invoice = invoice(payment_preimage);
918 match invoice_payer.pay_invoice(&invoice) {
919 Err(PaymentError::Sending(_)) => {},
920 Err(_) => panic!("unexpected error"),
921 Ok(_) => panic!("expected sending error"),
926 fn pays_zero_value_invoice_using_amount() {
927 let event_handled = core::cell::RefCell::new(false);
928 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
930 let payment_preimage = PaymentPreimage([1; 32]);
931 let invoice = zero_value_invoice(payment_preimage);
932 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
933 let final_value_msat = 100;
935 let payer = TestPayer::new().expect_value_msat(final_value_msat);
936 let router = TestRouter {};
937 let scorer = RefCell::new(TestScorer::new());
938 let logger = TestLogger::new();
940 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(0));
943 Some(invoice_payer.pay_zero_value_invoice(&invoice, final_value_msat).unwrap());
944 assert_eq!(*payer.attempts.borrow(), 1);
946 invoice_payer.handle_event(&Event::PaymentSent {
947 payment_id, payment_preimage, payment_hash, fee_paid_msat: None
949 assert_eq!(*event_handled.borrow(), true);
950 assert_eq!(*payer.attempts.borrow(), 1);
954 fn fails_paying_zero_value_invoice_with_amount() {
955 let event_handled = core::cell::RefCell::new(false);
956 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
958 let payer = TestPayer::new();
959 let router = TestRouter {};
960 let scorer = RefCell::new(TestScorer::new());
961 let logger = TestLogger::new();
963 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(0));
965 let payment_preimage = PaymentPreimage([1; 32]);
966 let invoice = invoice(payment_preimage);
968 // Cannot repay an invoice pending payment.
969 match invoice_payer.pay_zero_value_invoice(&invoice, 100) {
970 Err(PaymentError::Invoice("amount unexpected")) => {},
971 Err(_) => panic!("unexpected error"),
972 Ok(_) => panic!("expected invoice error"),
977 fn scores_failed_channel() {
978 let event_handled = core::cell::RefCell::new(false);
979 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
981 let payment_preimage = PaymentPreimage([1; 32]);
982 let invoice = invoice(payment_preimage);
983 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
984 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
985 let path = TestRouter::path_for_value(final_value_msat);
986 let short_channel_id = Some(path[0].short_channel_id);
988 // Expect that scorer is given short_channel_id upon handling the event.
989 let payer = TestPayer::new();
990 let router = TestRouter {};
991 let scorer = RefCell::new(TestScorer::new().expect_channel_failure(short_channel_id.unwrap()));
992 let logger = TestLogger::new();
994 InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
996 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
997 let event = Event::PaymentPathFailed {
1000 network_update: None,
1001 rejected_by_dest: false,
1002 all_paths_failed: false,
1005 retry: Some(TestRouter::retry_for_invoice(&invoice)),
1007 invoice_payer.handle_event(&event);
1013 fn route_for_value(final_value_msat: u64) -> Route {
1017 pubkey: PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(),
1018 channel_features: ChannelFeatures::empty(),
1019 node_features: NodeFeatures::empty(),
1020 short_channel_id: 0, fee_msat: final_value_msat / 2, cltv_expiry_delta: 144
1023 pubkey: PublicKey::from_slice(&hex::decode("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap(),
1024 channel_features: ChannelFeatures::empty(),
1025 node_features: NodeFeatures::empty(),
1026 short_channel_id: 1, fee_msat: final_value_msat / 2, cltv_expiry_delta: 144
1033 fn path_for_value(final_value_msat: u64) -> Vec<RouteHop> {
1034 TestRouter::route_for_value(final_value_msat).paths[0].clone()
1037 fn retry_for_invoice(invoice: &Invoice) -> RouteParameters {
1038 let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key())
1039 .with_expiry_time(expiry_time_from_unix_epoch(invoice).as_secs())
1040 .with_route_hints(invoice.route_hints());
1041 if let Some(features) = invoice.features() {
1042 payee = payee.with_features(features.clone());
1044 let final_value_msat = invoice.amount_milli_satoshis().unwrap() / 2;
1048 final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
1053 impl<S: routing::Score> Router<S> for TestRouter {
1057 params: &RouteParameters,
1058 _first_hops: Option<&[&ChannelDetails]>,
1060 ) -> Result<Route, LightningError> {
1062 payee: Some(params.payee.clone()), ..Self::route_for_value(params.final_value_msat)
1067 struct FailingRouter;
1069 impl<S: routing::Score> Router<S> for FailingRouter {
1073 _params: &RouteParameters,
1074 _first_hops: Option<&[&ChannelDetails]>,
1076 ) -> Result<Route, LightningError> {
1077 Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
1082 expectations: VecDeque<u64>,
1088 expectations: VecDeque::new(),
1092 fn expect_channel_failure(mut self, short_channel_id: u64) -> Self {
1093 self.expectations.push_back(short_channel_id);
1098 impl routing::Score for TestScorer {
1099 fn channel_penalty_msat(
1100 &self, _short_channel_id: u64, _source: &NodeId, _target: &NodeId
1103 fn payment_path_failed(&mut self, _path: &[&RouteHop], short_channel_id: u64) {
1104 if let Some(expected_short_channel_id) = self.expectations.pop_front() {
1105 assert_eq!(short_channel_id, expected_short_channel_id);
1110 impl Drop for TestScorer {
1111 fn drop(&mut self) {
1112 if std::thread::panicking() {
1116 if !self.expectations.is_empty() {
1117 panic!("Unsatisfied channel failure expectations: {:?}", self.expectations);
1123 expectations: core::cell::RefCell<VecDeque<u64>>,
1124 attempts: core::cell::RefCell<usize>,
1125 failing_on_attempt: Option<usize>,
1131 expectations: core::cell::RefCell::new(VecDeque::new()),
1132 attempts: core::cell::RefCell::new(0),
1133 failing_on_attempt: None,
1137 fn expect_value_msat(self, value_msat: u64) -> Self {
1138 self.expectations.borrow_mut().push_back(value_msat);
1142 fn fails_on_attempt(self, attempt: usize) -> Self {
1144 expectations: core::cell::RefCell::new(self.expectations.borrow().clone()),
1145 attempts: core::cell::RefCell::new(0),
1146 failing_on_attempt: Some(attempt),
1150 fn check_attempts(&self) -> bool {
1151 let mut attempts = self.attempts.borrow_mut();
1153 match self.failing_on_attempt {
1155 Some(attempt) if attempt != *attempts => true,
1160 fn check_value_msats(&self, route: &Route) {
1161 let expected_value_msats = self.expectations.borrow_mut().pop_front();
1162 if let Some(expected_value_msats) = expected_value_msats {
1163 let actual_value_msats = route.get_total_amount();
1164 assert_eq!(actual_value_msats, expected_value_msats);
1169 impl Drop for TestPayer {
1170 fn drop(&mut self) {
1171 if std::thread::panicking() {
1175 if !self.expectations.borrow().is_empty() {
1176 panic!("Unsatisfied payment expectations: {:?}", self.expectations.borrow());
1181 impl Payer for TestPayer {
1182 fn node_id(&self) -> PublicKey {
1183 let secp_ctx = Secp256k1::new();
1184 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap())
1187 fn first_hops(&self) -> Vec<ChannelDetails> {
1194 _payment_hash: PaymentHash,
1195 _payment_secret: &Option<PaymentSecret>
1196 ) -> Result<PaymentId, PaymentSendFailure> {
1197 if self.check_attempts() {
1198 self.check_value_msats(route);
1199 Ok(PaymentId([1; 32]))
1201 Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed))
1206 &self, route: &Route, _payment_id: PaymentId
1207 ) -> Result<(), PaymentSendFailure> {
1208 if self.check_attempts() {
1209 self.check_value_msats(route);
1212 Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed))
1217 // *** Full Featured Functional Tests with a Real ChannelManager ***
1218 struct ManualRouter(RefCell<VecDeque<Result<Route, LightningError>>>);
1220 impl<S: routing::Score> Router<S> for ManualRouter {
1221 fn find_route(&self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, _scorer: &S)
1222 -> Result<Route, LightningError> {
1223 self.0.borrow_mut().pop_front().unwrap()
1227 fn expect_find_route(&self, result: Result<Route, LightningError>) {
1228 self.0.borrow_mut().push_back(result);
1231 impl Drop for ManualRouter {
1232 fn drop(&mut self) {
1233 if std::thread::panicking() {
1236 assert!(self.0.borrow_mut().is_empty());
1241 fn retry_multi_path_single_failed_payment() {
1242 // Tests that we can/will retry after a single path of an MPP payment failed immediately
1243 let chanmon_cfgs = create_chanmon_cfgs(2);
1244 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1245 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None, None]);
1246 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1248 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
1249 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
1250 let chans = nodes[0].node.list_usable_channels();
1251 let mut route = Route {
1254 pubkey: nodes[1].node.get_our_node_id(),
1255 node_features: NodeFeatures::known(),
1256 short_channel_id: chans[0].short_channel_id.unwrap(),
1257 channel_features: ChannelFeatures::known(),
1259 cltv_expiry_delta: 100,
1262 pubkey: nodes[1].node.get_our_node_id(),
1263 node_features: NodeFeatures::known(),
1264 short_channel_id: chans[1].short_channel_id.unwrap(),
1265 channel_features: ChannelFeatures::known(),
1266 fee_msat: 100_000_001, // Our default max-HTLC-value is 10% of the channel value, which this is one more than
1267 cltv_expiry_delta: 100,
1270 payee: Some(Payee::from_node_id(nodes[1].node.get_our_node_id())),
1272 let router = ManualRouter(RefCell::new(VecDeque::new()));
1273 router.expect_find_route(Ok(route.clone()));
1274 // On retry, split the payment across both channels.
1275 route.paths[0][0].fee_msat = 50_000_001;
1276 route.paths[1][0].fee_msat = 50_000_000;
1277 router.expect_find_route(Ok(route.clone()));
1279 let event_handler = |_: &_| { panic!(); };
1280 let scorer = RefCell::new(TestScorer::new());
1281 let invoice_payer = InvoicePayer::new(nodes[0].node, router, &scorer, nodes[0].logger, event_handler, RetryAttempts(1));
1283 assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager(
1284 &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string()).unwrap())
1286 let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events();
1287 assert_eq!(htlc_msgs.len(), 2);
1288 check_added_monitors!(nodes[0], 2);
1292 fn immediate_retry_on_failure() {
1293 // Tests that we can/will retry immediately after a failure
1294 let chanmon_cfgs = create_chanmon_cfgs(2);
1295 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1296 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None, None]);
1297 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1299 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
1300 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
1301 let chans = nodes[0].node.list_usable_channels();
1302 let mut route = Route {
1305 pubkey: nodes[1].node.get_our_node_id(),
1306 node_features: NodeFeatures::known(),
1307 short_channel_id: chans[0].short_channel_id.unwrap(),
1308 channel_features: ChannelFeatures::known(),
1309 fee_msat: 100_000_001, // Our default max-HTLC-value is 10% of the channel value, which this is one more than
1310 cltv_expiry_delta: 100,
1313 payee: Some(Payee::from_node_id(nodes[1].node.get_our_node_id())),
1315 let router = ManualRouter(RefCell::new(VecDeque::new()));
1316 router.expect_find_route(Ok(route.clone()));
1317 // On retry, split the payment across both channels.
1318 route.paths.push(route.paths[0].clone());
1319 route.paths[0][0].short_channel_id = chans[1].short_channel_id.unwrap();
1320 route.paths[0][0].fee_msat = 50_000_000;
1321 route.paths[1][0].fee_msat = 50_000_001;
1322 router.expect_find_route(Ok(route.clone()));
1324 let event_handler = |_: &_| { panic!(); };
1325 let scorer = RefCell::new(TestScorer::new());
1326 let invoice_payer = InvoicePayer::new(nodes[0].node, router, &scorer, nodes[0].logger, event_handler, RetryAttempts(1));
1328 assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager(
1329 &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string()).unwrap())
1331 let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events();
1332 assert_eq!(htlc_msgs.len(), 2);
1333 check_added_monitors!(nodes[0], 2);