_ Git - rust-lightning/blob - lightning-invoice/src/payment.rs

   1 // This file is Copyright its original authors, visible in version control
   2 // history.
   3 //
   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
   8 // licenses.
   9
  10 //! A module for paying Lightning invoices.
  11 //!
  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`].
  16 //!
  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.
  22 //!
  23 //! # Example
  24 //!
  25 //! ```
  26 //! # extern crate lightning;
  27 //! # extern crate lightning_invoice;
  28 //! # extern crate secp256k1;
  29 //! #
  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::ops::Deref;
  42 //! #
  43 //! # struct FakeEventProvider {}
  44 //! # impl EventsProvider for FakeEventProvider {
  45 //! #     fn process_pending_events<H: Deref>(&self, handler: H) where H::Target: EventHandler {}
  46 //! # }
  47 //! #
  48 //! # struct FakePayer {}
  49 //! # impl Payer for FakePayer {
  50 //! #     fn node_id(&self) -> PublicKey { unimplemented!() }
  51 //! #     fn first_hops(&self) -> Vec<ChannelDetails> { unimplemented!() }
  52 //! #     fn send_payment(
  53 //! #         &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>
  54 //! #     ) -> Result<PaymentId, PaymentSendFailure> { unimplemented!() }
  55 //! #     fn retry_payment(
  56 //! #         &self, route: &Route, payment_id: PaymentId
  57 //! #     ) -> Result<(), PaymentSendFailure> { unimplemented!() }
  58 //! # }
  59 //! #
  60 //! # struct FakeRouter {};
  61 //! # impl Router for FakeRouter {
  62 //! #     fn find_route<S: routing::Score>(
  63 //! #         &self, payer: &PublicKey, params: &RouteParameters,
  64 //! #         first_hops: Option<&[&ChannelDetails]>, scorer: &S
  65 //! #     ) -> Result<Route, LightningError> { unimplemented!() }
  66 //! # }
  67 //! #
  68 //! # struct FakeScorer {};
  69 //! # impl routing::Score for FakeScorer {
  70 //! #     fn channel_penalty_msat(
  71 //! #         &self, _short_channel_id: u64, _source: &NodeId, _target: &NodeId
  72 //! #     ) -> u64 { 0 }
  73 //! #     fn payment_path_failed(&mut self, _path: &Vec<RouteHop>, _short_channel_id: u64) {}
  74 //! # }
  75 //! #
  76 //! # struct FakeLogger {};
  77 //! # impl Logger for FakeLogger {
  78 //! #     fn log(&self, record: &Record) { unimplemented!() }
  79 //! # }
  80 //! #
  81 //! # fn main() {
  82 //! let event_handler = |event: &Event| {
  83 //!     match event {
  84 //!         Event::PaymentPathFailed { .. } => println!("payment failed after retries"),
  85 //!         Event::PaymentSent { .. } => println!("payment successful"),
  86 //!         _ => {},
  87 //!     }
  88 //! };
  89 //! # let payer = FakePayer {};
  90 //! # let router = FakeRouter {};
  91 //! # let scorer = FakeScorer {};
  92 //! # let logger = FakeLogger {};
  93 //! let invoice_payer = InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(2));
  94 //!
  95 //! let invoice = "...";
  96 //! let invoice = invoice.parse::<Invoice>().unwrap();
  97 //! invoice_payer.pay_invoice(&invoice).unwrap();
  98 //!
  99 //! # let event_provider = FakeEventProvider {};
 100 //! loop {
 101 //!     event_provider.process_pending_events(&invoice_payer);
 102 //! }
 103 //! # }
 104 //! ```
 105 //!
 106 //! # Note
 107 //!
 108 //! The [`Route`] is computed before each payment attempt. Any updates affecting path finding such
 109 //! as updates to the network graph or changes to channel scores should be applied prior to
 110 //! retries, typically by way of composing [`EventHandler`]s accordingly.
 111
 112 use crate::Invoice;
 113
 114 use bitcoin_hashes::Hash;
 115
 116 use lightning::ln::{PaymentHash, PaymentSecret};
 117 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 118 use lightning::ln::msgs::LightningError;
 119 use lightning::routing;
 120 use lightning::routing::router::{Payee, Route, RouteParameters};
 121 use lightning::util::events::{Event, EventHandler};
 122 use lightning::util::logger::Logger;
 123
 124 use secp256k1::key::PublicKey;
 125
 126 use std::collections::hash_map::{self, HashMap};
 127 use std::ops::Deref;
 128 use std::sync::{Mutex, RwLock};
 129 use std::time::{Duration, SystemTime};
 130
 131 /// A utility for paying [`Invoice]`s.
 132 pub struct InvoicePayer<P: Deref, R, S, L: Deref, E>
 133 where
 134         P::Target: Payer,
 135         R: Router,
 136         S: routing::Score,
 137         L::Target: Logger,
 138         E: EventHandler,
 139 {
 140         payer: P,
 141         router: R,
 142         scorer: RwLock<S>,
 143         logger: L,
 144         event_handler: E,
 145         payment_cache: Mutex<HashMap<PaymentHash, usize>>,
 146         retry_attempts: RetryAttempts,
 147 }
 148
 149 /// A trait defining behavior of an [`Invoice`] payer.
 150 pub trait Payer {
 151         /// Returns the payer's node id.
 152         fn node_id(&self) -> PublicKey;
 153
 154         /// Returns the payer's channels.
 155         fn first_hops(&self) -> Vec<ChannelDetails>;
 156
 157         /// Sends a payment over the Lightning Network using the given [`Route`].
 158         fn send_payment(
 159                 &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>
 160         ) -> Result<PaymentId, PaymentSendFailure>;
 161
 162         /// Retries a failed payment path for the [`PaymentId`] using the given [`Route`].
 163         fn retry_payment(&self, route: &Route, payment_id: PaymentId) -> Result<(), PaymentSendFailure>;
 164 }
 165
 166 /// A trait defining behavior for routing an [`Invoice`] payment.
 167 pub trait Router {
 168         /// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
 169         fn find_route<S: routing::Score>(
 170                 &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
 171                 scorer: &S
 172         ) -> Result<Route, LightningError>;
 173 }
 174
 175 /// Number of attempts to retry payment path failures for an [`Invoice`].
 176 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 177 pub struct RetryAttempts(pub usize);
 178
 179 /// An error that may occur when making a payment.
 180 #[derive(Clone, Debug)]
 181 pub enum PaymentError {
 182         /// An error resulting from the provided [`Invoice`] or payment hash.
 183         Invoice(&'static str),
 184         /// An error occurring when finding a route.
 185         Routing(LightningError),
 186         /// An error occurring when sending a payment.
 187         Sending(PaymentSendFailure),
 188 }
 189
 190 impl<P: Deref, R, S, L: Deref, E> InvoicePayer<P, R, S, L, E>
 191 where
 192         P::Target: Payer,
 193         R: Router,
 194         S: routing::Score,
 195         L::Target: Logger,
 196         E: EventHandler,
 197 {
 198         /// Creates an invoice payer that retries failed payment paths.
 199         ///
 200         /// Will forward any [`Event::PaymentPathFailed`] events to the decorated `event_handler` once
 201         /// `retry_attempts` has been exceeded for a given [`Invoice`].
 202         pub fn new(
 203                 payer: P, router: R, scorer: S, logger: L, event_handler: E, retry_attempts: RetryAttempts
 204         ) -> Self {
 205                 Self {
 206                         payer,
 207                         router,
 208                         scorer: RwLock::new(scorer),
 209                         logger,
 210                         event_handler,
 211                         payment_cache: Mutex::new(HashMap::new()),
 212                         retry_attempts,
 213                 }
 214         }
 215
 216         /// Returns a read-only reference to the parameterized [`routing::Score`].
 217         ///
 218         /// Useful if the scorer needs to be persisted. Be sure to drop the returned guard immediately
 219         /// after use since retrying failed payment paths require write access.
 220         pub fn scorer(&self) -> std::sync::RwLockReadGuard<'_, S> {
 221                 self.scorer.read().unwrap()
 222         }
 223
 224         /// Pays the given [`Invoice`], caching it for later use in case a retry is needed.
 225         pub fn pay_invoice(&self, invoice: &Invoice) -> Result<PaymentId, PaymentError> {
 226                 if invoice.amount_milli_satoshis().is_none() {
 227                         Err(PaymentError::Invoice("amount missing"))
 228                 } else {
 229                         self.pay_invoice_internal(invoice, None)
 230                 }
 231         }
 232
 233         /// Pays the given zero-value [`Invoice`] using the given amount, caching it for later use in
 234         /// case a retry is needed.
 235         pub fn pay_zero_value_invoice(
 236                 &self, invoice: &Invoice, amount_msats: u64
 237         ) -> Result<PaymentId, PaymentError> {
 238                 if invoice.amount_milli_satoshis().is_some() {
 239                         Err(PaymentError::Invoice("amount unexpected"))
 240                 } else {
 241                         self.pay_invoice_internal(invoice, Some(amount_msats))
 242                 }
 243         }
 244
 245         fn pay_invoice_internal(
 246                 &self, invoice: &Invoice, amount_msats: Option<u64>
 247         ) -> Result<PaymentId, PaymentError> {
 248                 debug_assert!(invoice.amount_milli_satoshis().is_some() ^ amount_msats.is_some());
 249                 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
 250                 let mut payment_cache = self.payment_cache.lock().unwrap();
 251                 match payment_cache.entry(payment_hash) {
 252                         hash_map::Entry::Vacant(entry) => {
 253                                 let payer = self.payer.node_id();
 254                                 let mut payee = Payee::new(invoice.recover_payee_pub_key())
 255                                         .with_expiry_time(expiry_time_from_unix_epoch(&invoice).as_secs())
 256                                         .with_route_hints(invoice.route_hints());
 257                                 if let Some(features) = invoice.features() {
 258                                         payee = payee.with_features(features.clone());
 259                                 }
 260                                 let params = RouteParameters {
 261                                         payee,
 262                                         final_value_msat: invoice.amount_milli_satoshis().or(amount_msats).unwrap(),
 263                                         final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
 264                                 };
 265                                 let first_hops = self.payer.first_hops();
 266                                 let route = self.router.find_route(
 267                                         &payer,
 268                                         &params,
 269                                         Some(&first_hops.iter().collect::<Vec<_>>()),
 270                                         &*self.scorer.read().unwrap(),
 271                                 ).map_err(|e| PaymentError::Routing(e))?;
 272
 273                                 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
 274                                 let payment_secret = Some(invoice.payment_secret().clone());
 275                                 let payment_id = self.payer.send_payment(&route, payment_hash, &payment_secret)
 276                                         .map_err(|e| PaymentError::Sending(e))?;
 277                                 entry.insert(0);
 278                                 Ok(payment_id)
 279                         },
 280                         hash_map::Entry::Occupied(_) => Err(PaymentError::Invoice("payment pending")),
 281                 }
 282         }
 283
 284         fn retry_payment(
 285                 &self, payment_id: PaymentId, params: &RouteParameters
 286         ) -> Result<(), PaymentError> {
 287                 let payer = self.payer.node_id();
 288                 let first_hops = self.payer.first_hops();
 289                 let route = self.router.find_route(
 290                         &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()),
 291                         &*self.scorer.read().unwrap()
 292                 ).map_err(|e| PaymentError::Routing(e))?;
 293                 self.payer.retry_payment(&route, payment_id).map_err(|e| PaymentError::Sending(e))
 294         }
 295
 296         /// Removes the payment cached by the given payment hash.
 297         ///
 298         /// Should be called once a payment has failed or succeeded if not using [`InvoicePayer`] as an
 299         /// [`EventHandler`]. Otherwise, calling this method is unnecessary.
 300         pub fn remove_cached_payment(&self, payment_hash: &PaymentHash) {
 301                 self.payment_cache.lock().unwrap().remove(payment_hash);
 302         }
 303 }
 304
 305 fn expiry_time_from_unix_epoch(invoice: &Invoice) -> Duration {
 306         invoice.timestamp().duration_since(SystemTime::UNIX_EPOCH).unwrap() + invoice.expiry_time()
 307 }
 308
 309 fn has_expired(params: &RouteParameters) -> bool {
 310         let expiry_time = Duration::from_secs(params.payee.expiry_time.unwrap());
 311         Invoice::is_expired_from_epoch(&SystemTime::UNIX_EPOCH, expiry_time)
 312 }
 313
 314 impl<P: Deref, R, S, L: Deref, E> EventHandler for InvoicePayer<P, R, S, L, E>
 315 where
 316         P::Target: Payer,
 317         R: Router,
 318         S: routing::Score,
 319         L::Target: Logger,
 320         E: EventHandler,
 321 {
 322         fn handle_event(&self, event: &Event) {
 323                 match event {
 324                         Event::PaymentPathFailed {
 325                                 payment_id, payment_hash, rejected_by_dest, path, short_channel_id, retry, ..
 326                         } => {
 327                                 if let Some(short_channel_id) = short_channel_id {
 328                                         self.scorer.write().unwrap().payment_path_failed(path, *short_channel_id);
 329                                 }
 330
 331                                 let mut payment_cache = self.payment_cache.lock().unwrap();
 332                                 let entry = loop {
 333                                         let entry = payment_cache.entry(*payment_hash);
 334                                         match entry {
 335                                                 hash_map::Entry::Occupied(_) => break entry,
 336                                                 hash_map::Entry::Vacant(entry) => entry.insert(0),
 337                                         };
 338                                 };
 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();
 342                                         *attempts += 1;
 343
 344                                         if *rejected_by_dest {
 345                                                 log_trace!(self.logger, "Payment {} rejected by destination; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
 346                                         } else if payment_id.is_none() {
 347                                                 log_trace!(self.logger, "Payment {} has no id; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
 348                                         } else if *attempts >= max_payment_attempts {
 349                                                 log_trace!(self.logger, "Payment {} exceeded maximum attempts; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
 350                                         } else if retry.is_none() {
 351                                                 log_trace!(self.logger, "Payment {} missing retry params; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
 352                                         } else if has_expired(retry.as_ref().unwrap()) {
 353                                                 log_trace!(self.logger, "Invoice expired for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
 354                                         } else if self.retry_payment(*payment_id.as_ref().unwrap(), retry.as_ref().unwrap()).is_err() {
 355                                                 log_trace!(self.logger, "Error retrying payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
 356                                         } else {
 357                                                 log_trace!(self.logger, "Payment {} failed; retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
 358                                                 return;
 359                                         }
 360
 361                                         // Either the payment was rejected, the maximum attempts were exceeded, or an
 362                                         // error occurred when attempting to retry.
 363                                         entry.remove();
 364                                 } else {
 365                                         unreachable!();
 366                                 }
 367                         },
 368                         Event::PaymentSent { payment_hash, .. } => {
 369                                 let mut payment_cache = self.payment_cache.lock().unwrap();
 370                                 let attempts = payment_cache
 371                                         .remove(payment_hash)
 372                                         .map_or(1, |attempts| attempts + 1);
 373                                 log_trace!(self.logger, "Payment {} succeeded (attempts: {})", log_bytes!(payment_hash.0), attempts);
 374                         },
 375                         _ => {},
 376                 }
 377
 378                 // Delegate to the decorated event handler unless the payment is retried.
 379                 self.event_handler.handle_event(event)
 380         }
 381 }
 382
 383 #[cfg(test)]
 384 mod tests {
 385         use super::*;
 386         use crate::{DEFAULT_EXPIRY_TIME, InvoiceBuilder, Currency};
 387         use bitcoin_hashes::sha256::Hash as Sha256;
 388         use lightning::ln::PaymentPreimage;
 389         use lightning::ln::features::{ChannelFeatures, NodeFeatures};
 390         use lightning::ln::msgs::{ErrorAction, LightningError};
 391         use lightning::routing::network_graph::NodeId;
 392         use lightning::routing::router::{Payee, Route, RouteHop};
 393         use lightning::util::test_utils::TestLogger;
 394         use lightning::util::errors::APIError;
 395         use lightning::util::events::Event;
 396         use secp256k1::{SecretKey, PublicKey, Secp256k1};
 397         use std::time::{SystemTime, Duration};
 398
 399         fn invoice(payment_preimage: PaymentPreimage) -> Invoice {
 400                 let payment_hash = Sha256::hash(&payment_preimage.0);
 401                 let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
 402                 InvoiceBuilder::new(Currency::Bitcoin)
 403                         .description("test".into())
 404                         .payment_hash(payment_hash)
 405                         .payment_secret(PaymentSecret([0; 32]))
 406                         .current_timestamp()
 407                         .min_final_cltv_expiry(144)
 408                         .amount_milli_satoshis(128)
 409                         .build_signed(|hash| {
 410                                 Secp256k1::new().sign_recoverable(hash, &private_key)
 411                         })
 412                         .unwrap()
 413         }
 414
 415         fn zero_value_invoice(payment_preimage: PaymentPreimage) -> Invoice {
 416                 let payment_hash = Sha256::hash(&payment_preimage.0);
 417                 let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
 418                 InvoiceBuilder::new(Currency::Bitcoin)
 419                         .description("test".into())
 420                         .payment_hash(payment_hash)
 421                         .payment_secret(PaymentSecret([0; 32]))
 422                         .current_timestamp()
 423                         .min_final_cltv_expiry(144)
 424                         .build_signed(|hash| {
 425                                 Secp256k1::new().sign_recoverable(hash, &private_key)
 426                         })
 427                         .unwrap()
 428         }
 429
 430         fn expired_invoice(payment_preimage: PaymentPreimage) -> Invoice {
 431                 let payment_hash = Sha256::hash(&payment_preimage.0);
 432                 let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
 433                 let timestamp = SystemTime::now()
 434                         .checked_sub(Duration::from_secs(DEFAULT_EXPIRY_TIME * 2))
 435                         .unwrap();
 436                 InvoiceBuilder::new(Currency::Bitcoin)
 437                         .description("test".into())
 438                         .payment_hash(payment_hash)
 439                         .payment_secret(PaymentSecret([0; 32]))
 440                         .timestamp(timestamp)
 441                         .min_final_cltv_expiry(144)
 442                         .amount_milli_satoshis(128)
 443                         .build_signed(|hash| {
 444                                 Secp256k1::new().sign_recoverable(hash, &private_key)
 445                         })
 446                         .unwrap()
 447         }
 448
 449         #[test]
 450         fn pays_invoice_on_first_attempt() {
 451                 let event_handled = core::cell::RefCell::new(false);
 452                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 453
 454                 let payment_preimage = PaymentPreimage([1; 32]);
 455                 let invoice = invoice(payment_preimage);
 456                 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
 457
 458                 let payer = TestPayer::new();
 459                 let router = TestRouter {};
 460                 let scorer = TestScorer::new();
 461                 let logger = TestLogger::new();
 462                 let invoice_payer =
 463                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(0));
 464
 465                 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
 466                 assert_eq!(*payer.attempts.borrow(), 1);
 467
 468                 invoice_payer.handle_event(&Event::PaymentSent {
 469                         payment_id, payment_preimage, payment_hash
 470                 });
 471                 assert_eq!(*event_handled.borrow(), true);
 472                 assert_eq!(*payer.attempts.borrow(), 1);
 473         }
 474
 475         #[test]
 476         fn pays_invoice_on_retry() {
 477                 let event_handled = core::cell::RefCell::new(false);
 478                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 479
 480                 let payment_preimage = PaymentPreimage([1; 32]);
 481                 let invoice = invoice(payment_preimage);
 482                 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
 483                 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
 484
 485                 let payer = TestPayer::new()
 486                         .expect_value_msat(final_value_msat)
 487                         .expect_value_msat(final_value_msat / 2);
 488                 let router = TestRouter {};
 489                 let scorer = TestScorer::new();
 490                 let logger = TestLogger::new();
 491                 let invoice_payer =
 492                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(2));
 493
 494                 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
 495                 assert_eq!(*payer.attempts.borrow(), 1);
 496
 497                 let event = Event::PaymentPathFailed {
 498                         payment_id,
 499                         payment_hash,
 500                         network_update: None,
 501                         rejected_by_dest: false,
 502                         all_paths_failed: false,
 503                         path: TestRouter::path_for_value(final_value_msat),
 504                         short_channel_id: None,
 505                         retry: Some(TestRouter::retry_for_invoice(&invoice)),
 506                 };
 507                 invoice_payer.handle_event(&event);
 508                 assert_eq!(*event_handled.borrow(), false);
 509                 assert_eq!(*payer.attempts.borrow(), 2);
 510
 511                 invoice_payer.handle_event(&Event::PaymentSent {
 512                         payment_id, payment_preimage, payment_hash
 513                 });
 514                 assert_eq!(*event_handled.borrow(), true);
 515                 assert_eq!(*payer.attempts.borrow(), 2);
 516         }
 517
 518         #[test]
 519         fn retries_payment_path_for_unknown_payment() {
 520                 let event_handled = core::cell::RefCell::new(false);
 521                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 522
 523                 let payment_preimage = PaymentPreimage([1; 32]);
 524                 let invoice = invoice(payment_preimage);
 525                 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
 526                 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
 527
 528                 let payer = TestPayer::new();
 529                 let router = TestRouter {};
 530                 let scorer = TestScorer::new();
 531                 let logger = TestLogger::new();
 532                 let invoice_payer =
 533                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(2));
 534
 535                 let payment_id = Some(PaymentId([1; 32]));
 536                 let event = Event::PaymentPathFailed {
 537                         payment_id,
 538                         payment_hash,
 539                         network_update: None,
 540                         rejected_by_dest: false,
 541                         all_paths_failed: false,
 542                         path: TestRouter::path_for_value(final_value_msat),
 543                         short_channel_id: None,
 544                         retry: Some(TestRouter::retry_for_invoice(&invoice)),
 545                 };
 546                 invoice_payer.handle_event(&event);
 547                 assert_eq!(*event_handled.borrow(), false);
 548                 assert_eq!(*payer.attempts.borrow(), 1);
 549
 550                 invoice_payer.handle_event(&event);
 551                 assert_eq!(*event_handled.borrow(), false);
 552                 assert_eq!(*payer.attempts.borrow(), 2);
 553
 554                 invoice_payer.handle_event(&Event::PaymentSent {
 555                         payment_id, payment_preimage, payment_hash
 556                 });
 557                 assert_eq!(*event_handled.borrow(), true);
 558                 assert_eq!(*payer.attempts.borrow(), 2);
 559         }
 560
 561         #[test]
 562         fn fails_paying_invoice_after_max_retries() {
 563                 let event_handled = core::cell::RefCell::new(false);
 564                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 565
 566                 let payment_preimage = PaymentPreimage([1; 32]);
 567                 let invoice = invoice(payment_preimage);
 568                 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
 569
 570                 let payer = TestPayer::new()
 571                         .expect_value_msat(final_value_msat)
 572                         .expect_value_msat(final_value_msat / 2)
 573                         .expect_value_msat(final_value_msat / 2);
 574                 let router = TestRouter {};
 575                 let scorer = TestScorer::new();
 576                 let logger = TestLogger::new();
 577                 let invoice_payer =
 578                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(2));
 579
 580                 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
 581                 assert_eq!(*payer.attempts.borrow(), 1);
 582
 583                 let event = Event::PaymentPathFailed {
 584                         payment_id,
 585                         payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
 586                         network_update: None,
 587                         rejected_by_dest: false,
 588                         all_paths_failed: true,
 589                         path: TestRouter::path_for_value(final_value_msat),
 590                         short_channel_id: None,
 591                         retry: Some(TestRouter::retry_for_invoice(&invoice)),
 592                 };
 593                 invoice_payer.handle_event(&event);
 594                 assert_eq!(*event_handled.borrow(), false);
 595                 assert_eq!(*payer.attempts.borrow(), 2);
 596
 597                 let event = Event::PaymentPathFailed {
 598                         payment_id,
 599                         payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
 600                         network_update: None,
 601                         rejected_by_dest: false,
 602                         all_paths_failed: false,
 603                         path: TestRouter::path_for_value(final_value_msat / 2),
 604                         short_channel_id: None,
 605                         retry: Some(RouteParameters {
 606                                 final_value_msat: final_value_msat / 2, ..TestRouter::retry_for_invoice(&invoice)
 607                         }),
 608                 };
 609                 invoice_payer.handle_event(&event);
 610                 assert_eq!(*event_handled.borrow(), false);
 611                 assert_eq!(*payer.attempts.borrow(), 3);
 612
 613                 invoice_payer.handle_event(&event);
 614                 assert_eq!(*event_handled.borrow(), true);
 615                 assert_eq!(*payer.attempts.borrow(), 3);
 616         }
 617
 618         #[test]
 619         fn fails_paying_invoice_with_missing_retry_params() {
 620                 let event_handled = core::cell::RefCell::new(false);
 621                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 622
 623                 let payer = TestPayer::new();
 624                 let router = TestRouter {};
 625                 let scorer = TestScorer::new();
 626                 let logger = TestLogger::new();
 627                 let invoice_payer =
 628                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(2));
 629
 630                 let payment_preimage = PaymentPreimage([1; 32]);
 631                 let invoice = invoice(payment_preimage);
 632                 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
 633                 assert_eq!(*payer.attempts.borrow(), 1);
 634
 635                 let event = Event::PaymentPathFailed {
 636                         payment_id,
 637                         payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
 638                         network_update: None,
 639                         rejected_by_dest: false,
 640                         all_paths_failed: false,
 641                         path: vec![],
 642                         short_channel_id: None,
 643                         retry: None,
 644                 };
 645                 invoice_payer.handle_event(&event);
 646                 assert_eq!(*event_handled.borrow(), true);
 647                 assert_eq!(*payer.attempts.borrow(), 1);
 648         }
 649
 650         #[test]
 651         fn fails_paying_invoice_after_expiration() {
 652                 let event_handled = core::cell::RefCell::new(false);
 653                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 654
 655                 let payer = TestPayer::new();
 656                 let router = TestRouter {};
 657                 let scorer = TestScorer::new();
 658                 let logger = TestLogger::new();
 659                 let invoice_payer =
 660                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(2));
 661
 662                 let payment_preimage = PaymentPreimage([1; 32]);
 663                 let invoice = expired_invoice(payment_preimage);
 664                 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
 665                 assert_eq!(*payer.attempts.borrow(), 1);
 666
 667                 let event = Event::PaymentPathFailed {
 668                         payment_id,
 669                         payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
 670                         network_update: None,
 671                         rejected_by_dest: false,
 672                         all_paths_failed: false,
 673                         path: vec![],
 674                         short_channel_id: None,
 675                         retry: Some(TestRouter::retry_for_invoice(&invoice)),
 676                 };
 677                 invoice_payer.handle_event(&event);
 678                 assert_eq!(*event_handled.borrow(), true);
 679                 assert_eq!(*payer.attempts.borrow(), 1);
 680         }
 681
 682         #[test]
 683         fn fails_paying_invoice_after_retry_error() {
 684                 let event_handled = core::cell::RefCell::new(false);
 685                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 686
 687                 let payment_preimage = PaymentPreimage([1; 32]);
 688                 let invoice = invoice(payment_preimage);
 689                 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
 690
 691                 let payer = TestPayer::new()
 692                         .fails_on_attempt(2)
 693                         .expect_value_msat(final_value_msat);
 694                 let router = TestRouter {};
 695                 let scorer = TestScorer::new();
 696                 let logger = TestLogger::new();
 697                 let invoice_payer =
 698                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(2));
 699
 700                 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
 701                 assert_eq!(*payer.attempts.borrow(), 1);
 702
 703                 let event = Event::PaymentPathFailed {
 704                         payment_id,
 705                         payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
 706                         network_update: None,
 707                         rejected_by_dest: false,
 708                         all_paths_failed: false,
 709                         path: TestRouter::path_for_value(final_value_msat / 2),
 710                         short_channel_id: None,
 711                         retry: Some(TestRouter::retry_for_invoice(&invoice)),
 712                 };
 713                 invoice_payer.handle_event(&event);
 714                 assert_eq!(*event_handled.borrow(), true);
 715                 assert_eq!(*payer.attempts.borrow(), 2);
 716         }
 717
 718         #[test]
 719         fn fails_paying_invoice_after_rejected_by_payee() {
 720                 let event_handled = core::cell::RefCell::new(false);
 721                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 722
 723                 let payer = TestPayer::new();
 724                 let router = TestRouter {};
 725                 let scorer = TestScorer::new();
 726                 let logger = TestLogger::new();
 727                 let invoice_payer =
 728                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(2));
 729
 730                 let payment_preimage = PaymentPreimage([1; 32]);
 731                 let invoice = invoice(payment_preimage);
 732                 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
 733                 assert_eq!(*payer.attempts.borrow(), 1);
 734
 735                 let event = Event::PaymentPathFailed {
 736                         payment_id,
 737                         payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
 738                         network_update: None,
 739                         rejected_by_dest: true,
 740                         all_paths_failed: false,
 741                         path: vec![],
 742                         short_channel_id: None,
 743                         retry: Some(TestRouter::retry_for_invoice(&invoice)),
 744                 };
 745                 invoice_payer.handle_event(&event);
 746                 assert_eq!(*event_handled.borrow(), true);
 747                 assert_eq!(*payer.attempts.borrow(), 1);
 748         }
 749
 750         #[test]
 751         fn fails_repaying_invoice_with_pending_payment() {
 752                 let event_handled = core::cell::RefCell::new(false);
 753                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 754
 755                 let payer = TestPayer::new();
 756                 let router = TestRouter {};
 757                 let scorer = TestScorer::new();
 758                 let logger = TestLogger::new();
 759                 let invoice_payer =
 760                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(0));
 761
 762                 let payment_preimage = PaymentPreimage([1; 32]);
 763                 let invoice = invoice(payment_preimage);
 764                 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
 765
 766                 // Cannot repay an invoice pending payment.
 767                 match invoice_payer.pay_invoice(&invoice) {
 768                         Err(PaymentError::Invoice("payment pending")) => {},
 769                         Err(_) => panic!("unexpected error"),
 770                         Ok(_) => panic!("expected invoice error"),
 771                 }
 772
 773                 // Can repay an invoice once cleared from cache.
 774                 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
 775                 invoice_payer.remove_cached_payment(&payment_hash);
 776                 assert!(invoice_payer.pay_invoice(&invoice).is_ok());
 777
 778                 // Cannot retry paying an invoice if cleared from cache.
 779                 invoice_payer.remove_cached_payment(&payment_hash);
 780                 let event = Event::PaymentPathFailed {
 781                         payment_id,
 782                         payment_hash,
 783                         network_update: None,
 784                         rejected_by_dest: false,
 785                         all_paths_failed: false,
 786                         path: vec![],
 787                         short_channel_id: None,
 788                         retry: Some(TestRouter::retry_for_invoice(&invoice)),
 789                 };
 790                 invoice_payer.handle_event(&event);
 791                 assert_eq!(*event_handled.borrow(), true);
 792         }
 793
 794         #[test]
 795         fn fails_paying_invoice_with_routing_errors() {
 796                 let payer = TestPayer::new();
 797                 let router = FailingRouter {};
 798                 let scorer = TestScorer::new();
 799                 let logger = TestLogger::new();
 800                 let invoice_payer =
 801                         InvoicePayer::new(&payer, router, scorer, &logger, |_: &_| {}, RetryAttempts(0));
 802
 803                 let payment_preimage = PaymentPreimage([1; 32]);
 804                 let invoice = invoice(payment_preimage);
 805                 match invoice_payer.pay_invoice(&invoice) {
 806                         Err(PaymentError::Routing(_)) => {},
 807                         Err(_) => panic!("unexpected error"),
 808                         Ok(_) => panic!("expected routing error"),
 809                 }
 810         }
 811
 812         #[test]
 813         fn fails_paying_invoice_with_sending_errors() {
 814                 let payer = TestPayer::new().fails_on_attempt(1);
 815                 let router = TestRouter {};
 816                 let scorer = TestScorer::new();
 817                 let logger = TestLogger::new();
 818                 let invoice_payer =
 819                         InvoicePayer::new(&payer, router, scorer, &logger, |_: &_| {}, RetryAttempts(0));
 820
 821                 let payment_preimage = PaymentPreimage([1; 32]);
 822                 let invoice = invoice(payment_preimage);
 823                 match invoice_payer.pay_invoice(&invoice) {
 824                         Err(PaymentError::Sending(_)) => {},
 825                         Err(_) => panic!("unexpected error"),
 826                         Ok(_) => panic!("expected sending error"),
 827                 }
 828         }
 829
 830         #[test]
 831         fn pays_zero_value_invoice_using_amount() {
 832                 let event_handled = core::cell::RefCell::new(false);
 833                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 834
 835                 let payment_preimage = PaymentPreimage([1; 32]);
 836                 let invoice = zero_value_invoice(payment_preimage);
 837                 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
 838                 let final_value_msat = 100;
 839
 840                 let payer = TestPayer::new().expect_value_msat(final_value_msat);
 841                 let router = TestRouter {};
 842                 let scorer = TestScorer::new();
 843                 let logger = TestLogger::new();
 844                 let invoice_payer =
 845                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(0));
 846
 847                 let payment_id =
 848                         Some(invoice_payer.pay_zero_value_invoice(&invoice, final_value_msat).unwrap());
 849                 assert_eq!(*payer.attempts.borrow(), 1);
 850
 851                 invoice_payer.handle_event(&Event::PaymentSent {
 852                         payment_id, payment_preimage, payment_hash
 853                 });
 854                 assert_eq!(*event_handled.borrow(), true);
 855                 assert_eq!(*payer.attempts.borrow(), 1);
 856         }
 857
 858         #[test]
 859         fn fails_paying_zero_value_invoice_with_amount() {
 860                 let event_handled = core::cell::RefCell::new(false);
 861                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 862
 863                 let payer = TestPayer::new();
 864                 let router = TestRouter {};
 865                 let scorer = TestScorer::new();
 866                 let logger = TestLogger::new();
 867                 let invoice_payer =
 868                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(0));
 869
 870                 let payment_preimage = PaymentPreimage([1; 32]);
 871                 let invoice = invoice(payment_preimage);
 872
 873                 // Cannot repay an invoice pending payment.
 874                 match invoice_payer.pay_zero_value_invoice(&invoice, 100) {
 875                         Err(PaymentError::Invoice("amount unexpected")) => {},
 876                         Err(_) => panic!("unexpected error"),
 877                         Ok(_) => panic!("expected invoice error"),
 878                 }
 879         }
 880
 881         #[test]
 882         fn scores_failed_channel() {
 883                 let event_handled = core::cell::RefCell::new(false);
 884                 let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
 885
 886                 let payment_preimage = PaymentPreimage([1; 32]);
 887                 let invoice = invoice(payment_preimage);
 888                 let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
 889                 let final_value_msat = invoice.amount_milli_satoshis().unwrap();
 890                 let path = TestRouter::path_for_value(final_value_msat);
 891                 let short_channel_id = Some(path[0].short_channel_id);
 892
 893                 let payer = TestPayer::new();
 894                 let router = TestRouter {};
 895                 let scorer = TestScorer::new().expect_channel_failure(short_channel_id.unwrap());
 896                 let logger = TestLogger::new();
 897                 let invoice_payer =
 898                         InvoicePayer::new(&payer, router, scorer, &logger, event_handler, RetryAttempts(2));
 899
 900                 let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
 901                 let event = Event::PaymentPathFailed {
 902                         payment_id,
 903                         payment_hash,
 904                         network_update: None,
 905                         rejected_by_dest: false,
 906                         all_paths_failed: false,
 907                         path,
 908                         short_channel_id,
 909                         retry: Some(TestRouter::retry_for_invoice(&invoice)),
 910                 };
 911                 invoice_payer.handle_event(&event);
 912         }
 913
 914         struct TestRouter;
 915
 916         impl TestRouter {
 917                 fn route_for_value(final_value_msat: u64) -> Route {
 918                         Route {
 919                                 paths: vec![
 920                                         vec![RouteHop {
 921                                                 pubkey: PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(),
 922                                                 channel_features: ChannelFeatures::empty(),
 923                                                 node_features: NodeFeatures::empty(),
 924                                                 short_channel_id: 0, fee_msat: final_value_msat / 2, cltv_expiry_delta: 144
 925                                         }],
 926                                         vec![RouteHop {
 927                                                 pubkey: PublicKey::from_slice(&hex::decode("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap(),
 928                                                 channel_features: ChannelFeatures::empty(),
 929                                                 node_features: NodeFeatures::empty(),
 930                                                 short_channel_id: 1, fee_msat: final_value_msat / 2, cltv_expiry_delta: 144
 931                                         }],
 932                                 ],
 933                                 payee: None,
 934                         }
 935                 }
 936
 937                 fn path_for_value(final_value_msat: u64) -> Vec<RouteHop> {
 938                         TestRouter::route_for_value(final_value_msat).paths[0].clone()
 939                 }
 940
 941                 fn retry_for_invoice(invoice: &Invoice) -> RouteParameters {
 942                         let mut payee = Payee::new(invoice.recover_payee_pub_key())
 943                                 .with_expiry_time(expiry_time_from_unix_epoch(invoice).as_secs())
 944                                 .with_route_hints(invoice.route_hints());
 945                         if let Some(features) = invoice.features() {
 946                                 payee = payee.with_features(features.clone());
 947                         }
 948                         let final_value_msat = invoice.amount_milli_satoshis().unwrap() / 2;
 949                         RouteParameters {
 950                                 payee,
 951                                 final_value_msat,
 952                                 final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
 953                         }
 954                 }
 955         }
 956
 957         impl Router for TestRouter {
 958                 fn find_route<S: routing::Score>(
 959                         &self,
 960                         _payer: &PublicKey,
 961                         params: &RouteParameters,
 962                         _first_hops: Option<&[&ChannelDetails]>,
 963                         _scorer: &S,
 964                 ) -> Result<Route, LightningError> {
 965                         Ok(Route {
 966                                 payee: Some(params.payee.clone()), ..Self::route_for_value(params.final_value_msat)
 967                         })
 968                 }
 969         }
 970
 971         struct FailingRouter;
 972
 973         impl Router for FailingRouter {
 974                 fn find_route<S: routing::Score>(
 975                         &self,
 976                         _payer: &PublicKey,
 977                         _params: &RouteParameters,
 978                         _first_hops: Option<&[&ChannelDetails]>,
 979                         _scorer: &S,
 980                 ) -> Result<Route, LightningError> {
 981                         Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
 982                 }
 983         }
 984
 985         struct TestScorer {
 986                 expectations: std::collections::VecDeque<u64>,
 987         }
 988
 989         impl TestScorer {
 990                 fn new() -> Self {
 991                         Self {
 992                                 expectations: std::collections::VecDeque::new(),
 993                         }
 994                 }
 995
 996                 fn expect_channel_failure(mut self, short_channel_id: u64) -> Self {
 997                         self.expectations.push_back(short_channel_id);
 998                         self
 999                 }
1000         }
1001
1002         impl routing::Score for TestScorer {
1003                 fn channel_penalty_msat(
1004                         &self, _short_channel_id: u64, _source: &NodeId, _target: &NodeId
1005                 ) -> u64 { 0 }
1006
1007                 fn payment_path_failed(&mut self, _path: &Vec<RouteHop>, short_channel_id: u64) {
1008                         if let Some(expected_short_channel_id) = self.expectations.pop_front() {
1009                                 assert_eq!(short_channel_id, expected_short_channel_id);
1010                         }
1011                 }
1012         }
1013
1014         impl Drop for TestScorer {
1015                 fn drop(&mut self) {
1016                         if std::thread::panicking() {
1017                                 return;
1018                         }
1019
1020                         if !self.expectations.is_empty() {
1021                                 panic!("Unsatisfied channel failure expectations: {:?}", self.expectations);
1022                         }
1023                 }
1024         }
1025
1026         struct TestPayer {
1027                 expectations: core::cell::RefCell<std::collections::VecDeque<u64>>,
1028                 attempts: core::cell::RefCell<usize>,
1029                 failing_on_attempt: Option<usize>,
1030         }
1031
1032         impl TestPayer {
1033                 fn new() -> Self {
1034                         Self {
1035                                 expectations: core::cell::RefCell::new(std::collections::VecDeque::new()),
1036                                 attempts: core::cell::RefCell::new(0),
1037                                 failing_on_attempt: None,
1038                         }
1039                 }
1040
1041                 fn expect_value_msat(self, value_msat: u64) -> Self {
1042                         self.expectations.borrow_mut().push_back(value_msat);
1043                         self
1044                 }
1045
1046                 fn fails_on_attempt(self, attempt: usize) -> Self {
1047                         Self {
1048                                 expectations: core::cell::RefCell::new(self.expectations.borrow().clone()),
1049                                 attempts: core::cell::RefCell::new(0),
1050                                 failing_on_attempt: Some(attempt),
1051                         }
1052                 }
1053
1054                 fn check_attempts(&self) -> bool {
1055                         let mut attempts = self.attempts.borrow_mut();
1056                         *attempts += 1;
1057                         match self.failing_on_attempt {
1058                                 None => true,
1059                                 Some(attempt) if attempt != *attempts => true,
1060                                 Some(_) => false,
1061                         }
1062                 }
1063
1064                 fn check_value_msats(&self, route: &Route) {
1065                         let expected_value_msats = self.expectations.borrow_mut().pop_front();
1066                         if let Some(expected_value_msats) = expected_value_msats {
1067                                 let actual_value_msats = route.get_total_amount();
1068                                 assert_eq!(actual_value_msats, expected_value_msats);
1069                         }
1070                 }
1071         }
1072
1073         impl Drop for TestPayer {
1074                 fn drop(&mut self) {
1075                         if std::thread::panicking() {
1076                                 return;
1077                         }
1078
1079                         if !self.expectations.borrow().is_empty() {
1080                                 panic!("Unsatisfied payment expectations: {:?}", self.expectations.borrow());
1081                         }
1082                 }
1083         }
1084
1085         impl Payer for TestPayer {
1086                 fn node_id(&self) -> PublicKey {
1087                         let secp_ctx = Secp256k1::new();
1088                         PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap())
1089                 }
1090
1091                 fn first_hops(&self) -> Vec<ChannelDetails> {
1092                         Vec::new()
1093                 }
1094
1095                 fn send_payment(
1096                         &self,
1097                         route: &Route,
1098                         _payment_hash: PaymentHash,
1099                         _payment_secret: &Option<PaymentSecret>
1100                 ) -> Result<PaymentId, PaymentSendFailure> {
1101                         if self.check_attempts() {
1102                                 self.check_value_msats(route);
1103                                 Ok(PaymentId([1; 32]))
1104                         } else {
1105                                 Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed))
1106                         }
1107                 }
1108
1109                 fn retry_payment(
1110                         &self, route: &Route, _payment_id: PaymentId
1111                 ) -> Result<(), PaymentSendFailure> {
1112                         if self.check_attempts() {
1113                                 self.check_value_msats(route);
1114                                 Ok(())
1115                         } else {
1116                                 Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed))
1117                         }
1118                 }
1119         }
1120 }