use lightning::ln::script::ShutdownScript;
use lightning::routing::network_graph::{NetGraphMsgHandler, NetworkGraph};
use lightning::routing::router::{find_route, Payee, RouteParameters};
-use lightning::routing::scorer::Scorer;
+use lightning::routing::scoring::Scorer;
use lightning::util::config::UserConfig;
use lightning::util::errors::APIError;
use lightning::util::events::Event;
use lightning::ln::features::InitFeatures;
use lightning::ln::msgs;
use lightning::routing::router::{find_route, Payee, RouteHint, RouteHintHop, RouteParameters};
-use lightning::routing::scorer::Scorer;
+use lightning::routing::scoring::Scorer;
use lightning::util::logger::Logger;
use lightning::util::ser::Readable;
use lightning::routing::network_graph::{NetworkGraph, RoutingFees};
// You may not use this file except in accordance with one or both of these
// licenses.
-//! A module for paying Lightning invoices.
+//! A module for paying Lightning invoices and sending spontaneous payments.
//!
-//! Defines an [`InvoicePayer`] utility for paying invoices, parameterized by [`Payer`] and
+//! Defines an [`InvoicePayer`] utility for sending payments, parameterized by [`Payer`] and
//! [`Router`] traits. Implementations of [`Payer`] provide the payer's node id, channels, and means
//! to send a payment over a [`Route`]. Implementations of [`Router`] find a [`Route`] between payer
-//! and payee using information provided by the payer and from the payee's [`Invoice`].
+//! and payee using information provided by the payer and from the payee's [`Invoice`], when
+//! applicable.
//!
//! [`InvoicePayer`] is capable of retrying failed payments. It accomplishes this by implementing
//! [`EventHandler`] which decorates a user-provided handler. It will intercept any
//! # extern crate lightning_invoice;
//! # extern crate secp256k1;
//! #
-//! # use lightning::ln::{PaymentHash, PaymentSecret};
+//! # use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
//! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
//! # use lightning::ln::msgs::LightningError;
-//! # use lightning::routing;
+//! # use lightning::routing::scoring::Score;
//! # use lightning::routing::network_graph::NodeId;
//! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
//! # use lightning::util::events::{Event, EventHandler, EventsProvider};
//! # fn send_payment(
//! # &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>
//! # ) -> Result<PaymentId, PaymentSendFailure> { unimplemented!() }
+//! # fn send_spontaneous_payment(
+//! # &self, route: &Route, payment_preimage: PaymentPreimage
+//! # ) -> Result<PaymentId, PaymentSendFailure> { unimplemented!() }
//! # fn retry_payment(
//! # &self, route: &Route, payment_id: PaymentId
//! # ) -> Result<(), PaymentSendFailure> { unimplemented!() }
//! # }
//! #
//! # struct FakeRouter {};
-//! # impl<S: routing::Score> Router<S> for FakeRouter {
+//! # impl<S: Score> Router<S> for FakeRouter {
//! # fn find_route(
-//! # &self, payer: &PublicKey, params: &RouteParameters,
+//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
//! # first_hops: Option<&[&ChannelDetails]>, scorer: &S
//! # ) -> Result<Route, LightningError> { unimplemented!() }
//! # }
//! #
//! # struct FakeScorer {};
-//! # impl routing::Score for FakeScorer {
+//! # impl Score for FakeScorer {
//! # fn channel_penalty_msat(
-//! # &self, _short_channel_id: u64, _source: &NodeId, _target: &NodeId
+//! # &self, _short_channel_id: u64, _send_amt: u64, _chan_amt: Option<u64>, _source: &NodeId, _target: &NodeId
//! # ) -> u64 { 0 }
//! # fn payment_path_failed(&mut self, _path: &[&RouteHop], _short_channel_id: u64) {}
//! # }
use crate::Invoice;
use bitcoin_hashes::Hash;
+use bitcoin_hashes::sha256::Hash as Sha256;
-use lightning::ln::{PaymentHash, PaymentSecret};
+use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
use lightning::ln::msgs::LightningError;
-use lightning::routing;
-use lightning::routing::{LockableScore, Score};
+use lightning::routing::scoring::{LockableScore, Score};
use lightning::routing::router::{Payee, Route, RouteParameters};
use lightning::util::events::{Event, EventHandler};
use lightning::util::logger::Logger;
use std::sync::Mutex;
use std::time::{Duration, SystemTime};
-/// A utility for paying [`Invoice]`s.
+/// A utility for paying [`Invoice`]s and sending spontaneous payments.
pub struct InvoicePayer<P: Deref, R, S: Deref, L: Deref, E>
where
P::Target: Payer,
- R: for <'a> Router<<<S as Deref>::Target as routing::LockableScore<'a>>::Locked>,
- S::Target: for <'a> routing::LockableScore<'a>,
+ R: for <'a> Router<<<S as Deref>::Target as LockableScore<'a>>::Locked>,
+ S::Target: for <'a> LockableScore<'a>,
L::Target: Logger,
E: EventHandler,
{
scorer: S,
logger: L,
event_handler: E,
+ /// Caches the overall attempts at making a payment, which is updated prior to retrying.
payment_cache: Mutex<HashMap<PaymentHash, usize>>,
retry_attempts: RetryAttempts,
}
&self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option<PaymentSecret>
) -> Result<PaymentId, PaymentSendFailure>;
+ /// Sends a spontaneous payment over the Lightning Network using the given [`Route`].
+ fn send_spontaneous_payment(
+ &self, route: &Route, payment_preimage: PaymentPreimage
+ ) -> Result<PaymentId, PaymentSendFailure>;
+
/// Retries a failed payment path for the [`PaymentId`] using the given [`Route`].
fn retry_payment(&self, route: &Route, payment_id: PaymentId) -> Result<(), PaymentSendFailure>;
}
/// A trait defining behavior for routing an [`Invoice`] payment.
-pub trait Router<S: routing::Score> {
+pub trait Router<S: Score> {
/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
- scorer: &S
+ &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+ first_hops: Option<&[&ChannelDetails]>, scorer: &S
) -> Result<Route, LightningError>;
}
impl<P: Deref, R, S: Deref, L: Deref, E> InvoicePayer<P, R, S, L, E>
where
P::Target: Payer,
- R: for <'a> Router<<<S as Deref>::Target as routing::LockableScore<'a>>::Locked>,
- S::Target: for <'a> routing::LockableScore<'a>,
+ R: for <'a> Router<<<S as Deref>::Target as LockableScore<'a>>::Locked>,
+ S::Target: for <'a> LockableScore<'a>,
L::Target: Logger,
E: EventHandler,
{
if invoice.amount_milli_satoshis().is_none() {
Err(PaymentError::Invoice("amount missing"))
} else {
- self.pay_invoice_internal(invoice, None, 0)
+ self.pay_invoice_using_amount(invoice, None)
}
}
if invoice.amount_milli_satoshis().is_some() {
Err(PaymentError::Invoice("amount unexpected"))
} else {
- self.pay_invoice_internal(invoice, Some(amount_msats), 0)
+ self.pay_invoice_using_amount(invoice, Some(amount_msats))
}
}
- fn pay_invoice_internal(
- &self, invoice: &Invoice, amount_msats: Option<u64>, retry_count: usize
+ fn pay_invoice_using_amount(
+ &self, invoice: &Invoice, amount_msats: Option<u64>
) -> Result<PaymentId, PaymentError> {
debug_assert!(invoice.amount_milli_satoshis().is_some() ^ amount_msats.is_some());
+
let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
- if invoice.is_expired() {
- log_trace!(self.logger, "Invoice expired prior to first send for payment {}", log_bytes!(payment_hash.0));
+ match self.payment_cache.lock().unwrap().entry(payment_hash) {
+ hash_map::Entry::Occupied(_) => return Err(PaymentError::Invoice("payment pending")),
+ hash_map::Entry::Vacant(entry) => entry.insert(0),
+ };
+
+ let payment_secret = Some(invoice.payment_secret().clone());
+ let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key())
+ .with_expiry_time(expiry_time_from_unix_epoch(&invoice).as_secs())
+ .with_route_hints(invoice.route_hints());
+ if let Some(features) = invoice.features() {
+ payee = payee.with_features(features.clone());
+ }
+ let params = RouteParameters {
+ payee,
+ final_value_msat: invoice.amount_milli_satoshis().or(amount_msats).unwrap(),
+ final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
+ };
+
+ let send_payment = |route: &Route| {
+ self.payer.send_payment(route, payment_hash, &payment_secret)
+ };
+ self.pay_internal(¶ms, payment_hash, send_payment)
+ .map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e })
+ }
+
+ /// Pays `pubkey` an amount using the hash of the given preimage, caching it for later use in
+ /// case a retry is needed.
+ ///
+ /// You should ensure that `payment_preimage` is unique and that its `payment_hash` has never
+ /// been paid before. Because [`InvoicePayer`] is stateless no effort is made to do so for you.
+ pub fn pay_pubkey(
+ &self, pubkey: PublicKey, payment_preimage: PaymentPreimage, amount_msats: u64,
+ final_cltv_expiry_delta: u32
+ ) -> Result<PaymentId, PaymentError> {
+ let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
+ match self.payment_cache.lock().unwrap().entry(payment_hash) {
+ hash_map::Entry::Occupied(_) => return Err(PaymentError::Invoice("payment pending")),
+ hash_map::Entry::Vacant(entry) => entry.insert(0),
+ };
+
+ let params = RouteParameters {
+ payee: Payee::for_keysend(pubkey),
+ final_value_msat: amount_msats,
+ final_cltv_expiry_delta,
+ };
+
+ let send_payment = |route: &Route| {
+ self.payer.send_spontaneous_payment(route, payment_preimage)
+ };
+ self.pay_internal(¶ms, payment_hash, send_payment)
+ .map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e })
+ }
+
+ fn pay_internal<F: FnOnce(&Route) -> Result<PaymentId, PaymentSendFailure> + Copy>(
+ &self, params: &RouteParameters, payment_hash: PaymentHash, send_payment: F,
+ ) -> Result<PaymentId, PaymentError> {
+ if has_expired(params) {
+ log_trace!(self.logger, "Invoice expired prior to send for payment {}", log_bytes!(payment_hash.0));
return Err(PaymentError::Invoice("Invoice expired prior to send"));
}
- let retry_data_payment_id = loop {
- let mut payment_cache = self.payment_cache.lock().unwrap();
- match payment_cache.entry(payment_hash) {
- hash_map::Entry::Vacant(entry) => {
- let payer = self.payer.node_id();
- let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key())
- .with_expiry_time(expiry_time_from_unix_epoch(&invoice).as_secs())
- .with_route_hints(invoice.route_hints());
- if let Some(features) = invoice.features() {
- payee = payee.with_features(features.clone());
+
+ let payer = self.payer.node_id();
+ let first_hops = self.payer.first_hops();
+ let route = self.router.find_route(
+ &payer, params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
+ &self.scorer.lock()
+ ).map_err(|e| PaymentError::Routing(e))?;
+
+ match send_payment(&route) {
+ Ok(payment_id) => Ok(payment_id),
+ Err(e) => match e {
+ PaymentSendFailure::ParameterError(_) => Err(e),
+ PaymentSendFailure::PathParameterError(_) => Err(e),
+ PaymentSendFailure::AllFailedRetrySafe(_) => {
+ let mut payment_cache = self.payment_cache.lock().unwrap();
+ let retry_count = payment_cache.get_mut(&payment_hash).unwrap();
+ if *retry_count >= self.retry_attempts.0 {
+ Err(e)
+ } else {
+ *retry_count += 1;
+ std::mem::drop(payment_cache);
+ Ok(self.pay_internal(params, payment_hash, send_payment)?)
}
- let params = RouteParameters {
- payee,
- final_value_msat: invoice.amount_milli_satoshis().or(amount_msats).unwrap(),
- final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
- };
- let first_hops = self.payer.first_hops();
- let route = self.router.find_route(
- &payer,
- ¶ms,
- Some(&first_hops.iter().collect::<Vec<_>>()),
- &self.scorer.lock(),
- ).map_err(|e| PaymentError::Routing(e))?;
-
- let payment_secret = Some(invoice.payment_secret().clone());
- let payment_id = match self.payer.send_payment(&route, payment_hash, &payment_secret) {
- Ok(payment_id) => payment_id,
- Err(PaymentSendFailure::ParameterError(e)) =>
- return Err(PaymentError::Sending(PaymentSendFailure::ParameterError(e))),
- Err(PaymentSendFailure::PathParameterError(e)) =>
- return Err(PaymentError::Sending(PaymentSendFailure::PathParameterError(e))),
- Err(PaymentSendFailure::AllFailedRetrySafe(e)) => {
- if retry_count >= self.retry_attempts.0 {
- return Err(PaymentError::Sending(PaymentSendFailure::AllFailedRetrySafe(e)))
- }
- break None;
- },
- Err(PaymentSendFailure::PartialFailure { results: _, failed_paths_retry, payment_id }) => {
- if let Some(retry_data) = failed_paths_retry {
- entry.insert(retry_count);
- break Some((retry_data, payment_id));
- } else {
- // This may happen if we send a payment and some paths fail, but
- // only due to a temporary monitor failure or the like, implying
- // they're really in-flight, but we haven't sent the initial
- // HTLC-Add messages yet.
- payment_id
- }
- },
- };
- entry.insert(retry_count);
- return Ok(payment_id);
},
- hash_map::Entry::Occupied(_) => return Err(PaymentError::Invoice("payment pending")),
- }
- };
- if let Some((retry_data, payment_id)) = retry_data_payment_id {
- // Some paths were sent, even if we failed to send the full MPP value our recipient may
- // misbehave and claim the funds, at which point we have to consider the payment sent,
- // so return `Ok()` here, ignoring any retry errors.
- let _ = self.retry_payment(payment_id, payment_hash, &retry_data);
- Ok(payment_id)
- } else {
- self.pay_invoice_internal(invoice, amount_msats, retry_count + 1)
- }
+ PaymentSendFailure::PartialFailure { failed_paths_retry, payment_id, .. } => {
+ if let Some(retry_data) = failed_paths_retry {
+ // Some paths were sent, even if we failed to send the full MPP value our
+ // recipient may misbehave and claim the funds, at which point we have to
+ // consider the payment sent, so return `Ok()` here, ignoring any retry
+ // errors.
+ let _ = self.retry_payment(payment_id, payment_hash, &retry_data);
+ Ok(payment_id)
+ } else {
+ // This may happen if we send a payment and some paths fail, but
+ // only due to a temporary monitor failure or the like, implying
+ // they're really in-flight, but we haven't sent the initial
+ // HTLC-Add messages yet.
+ Ok(payment_id)
+ }
+ },
+ },
+ }.map_err(|e| PaymentError::Sending(e))
}
- fn retry_payment(&self, payment_id: PaymentId, payment_hash: PaymentHash, params: &RouteParameters)
- -> Result<(), ()> {
- let route;
- {
- let mut payment_cache = self.payment_cache.lock().unwrap();
- let entry = loop {
- let entry = payment_cache.entry(payment_hash);
- match entry {
- hash_map::Entry::Occupied(_) => break entry,
- hash_map::Entry::Vacant(entry) => entry.insert(0),
- };
- };
- if let hash_map::Entry::Occupied(mut entry) = entry {
- let max_payment_attempts = self.retry_attempts.0 + 1;
- let attempts = entry.get_mut();
- *attempts += 1;
-
- if *attempts >= max_payment_attempts {
- log_trace!(self.logger, "Payment {} exceeded maximum attempts; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
- return Err(());
- } else if has_expired(params) {
- log_trace!(self.logger, "Invoice expired for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
- return Err(());
- }
+ fn retry_payment(
+ &self, payment_id: PaymentId, payment_hash: PaymentHash, params: &RouteParameters
+ ) -> Result<(), ()> {
+ let max_payment_attempts = self.retry_attempts.0 + 1;
+ let attempts = *self.payment_cache.lock().unwrap()
+ .entry(payment_hash)
+ .and_modify(|attempts| *attempts += 1)
+ .or_insert(1);
+
+ if attempts >= max_payment_attempts {
+ log_trace!(self.logger, "Payment {} exceeded maximum attempts; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
+ return Err(());
+ }
- let payer = self.payer.node_id();
- let first_hops = self.payer.first_hops();
- route = self.router.find_route(&payer, ¶ms, Some(&first_hops.iter().collect::<Vec<_>>()), &self.scorer.lock());
- if route.is_err() {
- log_trace!(self.logger, "Failed to find a route for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
- return Err(());
- }
- } else {
- unreachable!();
- }
+ if has_expired(params) {
+ log_trace!(self.logger, "Invoice expired for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
+ return Err(());
}
- let retry_res = self.payer.retry_payment(&route.unwrap(), payment_id);
- match retry_res {
+ let payer = self.payer.node_id();
+ let first_hops = self.payer.first_hops();
+ let route = self.router.find_route(
+ &payer, ¶ms, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
+ &self.scorer.lock()
+ );
+ if route.is_err() {
+ log_trace!(self.logger, "Failed to find a route for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
+ return Err(());
+ }
+
+ match self.payer.retry_payment(&route.unwrap(), payment_id) {
Ok(()) => Ok(()),
Err(PaymentSendFailure::ParameterError(_)) |
Err(PaymentSendFailure::PathParameterError(_)) => {
log_trace!(self.logger, "Failed to retry for payment {} due to bogus route/payment data, not retrying.", log_bytes!(payment_hash.0));
- return Err(());
+ Err(())
},
Err(PaymentSendFailure::AllFailedRetrySafe(_)) => {
self.retry_payment(payment_id, payment_hash, params)
},
- Err(PaymentSendFailure::PartialFailure { results: _, failed_paths_retry, .. }) => {
+ Err(PaymentSendFailure::PartialFailure { failed_paths_retry, .. }) => {
if let Some(retry) = failed_paths_retry {
- self.retry_payment(payment_id, payment_hash, &retry)
- } else {
- Ok(())
+ // Always return Ok for the same reason as noted in pay_internal.
+ let _ = self.retry_payment(payment_id, payment_hash, &retry);
}
+ Ok(())
},
}
}
impl<P: Deref, R, S: Deref, L: Deref, E> EventHandler for InvoicePayer<P, R, S, L, E>
where
P::Target: Payer,
- R: for <'a> Router<<<S as Deref>::Target as routing::LockableScore<'a>>::Locked>,
- S::Target: for <'a> routing::LockableScore<'a>,
+ R: for <'a> Router<<<S as Deref>::Target as LockableScore<'a>>::Locked>,
+ S::Target: for <'a> LockableScore<'a>,
L::Target: Logger,
E: EventHandler,
{
fn handle_event(&self, event: &Event) {
match event {
Event::PaymentPathFailed {
- all_paths_failed, payment_id, payment_hash, rejected_by_dest, path, short_channel_id, retry, ..
+ all_paths_failed, payment_id, payment_hash, rejected_by_dest, path,
+ short_channel_id, retry, ..
} => {
if let Some(short_channel_id) = short_channel_id {
- let t = path.iter().collect::<Vec<_>>();
- self.scorer.lock().payment_path_failed(&t, *short_channel_id);
+ let path = path.iter().collect::<Vec<_>>();
+ self.scorer.lock().payment_path_failed(&path, *short_channel_id);
}
if *rejected_by_dest {
log_trace!(self.logger, "Payment {} rejected by destination; not retrying", log_bytes!(payment_hash.0));
} else if payment_id.is_none() {
log_trace!(self.logger, "Payment {} has no id; not retrying", log_bytes!(payment_hash.0));
- } else if let Some(params) = retry {
- if self.retry_payment(payment_id.unwrap(), *payment_hash, params).is_ok() {
- // We retried at least somewhat, don't provide the PaymentPathFailed event to the user.
- return;
- }
- } else {
+ } else if retry.is_none() {
log_trace!(self.logger, "Payment {} missing retry params; not retrying", log_bytes!(payment_hash.0));
+ } else if self.retry_payment(payment_id.unwrap(), *payment_hash, retry.as_ref().unwrap()).is_ok() {
+ // We retried at least somewhat, don't provide the PaymentPathFailed event to the user.
+ return;
}
+
if *all_paths_failed { self.payment_cache.lock().unwrap().remove(payment_hash); }
},
Event::PaymentSent { payment_hash, .. } => {
.unwrap()
}
+ fn pubkey() -> PublicKey {
+ PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap()
+ }
+
#[test]
fn pays_invoice_on_first_attempt() {
let event_handled = core::cell::RefCell::new(false);
let payment_preimage = PaymentPreimage([1; 32]);
let invoice = invoice(payment_preimage);
let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
+ let final_value_msat = invoice.amount_milli_satoshis().unwrap();
- let payer = TestPayer::new();
+ let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
let payer = TestPayer::new()
- .expect_value_msat(final_value_msat)
- .expect_value_msat(final_value_msat / 2);
+ .expect_send(Amount::ForInvoice(final_value_msat))
+ .expect_send(Amount::OnRetry(final_value_msat / 2));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
assert_eq!(*payer.attempts.borrow(), 2);
}
+ #[test]
+ fn pays_invoice_on_partial_failure() {
+ let event_handler = |_: &_| { panic!() };
+
+ let payment_preimage = PaymentPreimage([1; 32]);
+ let invoice = invoice(payment_preimage);
+ let retry = TestRouter::retry_for_invoice(&invoice);
+ let final_value_msat = invoice.amount_milli_satoshis().unwrap();
+
+ let payer = TestPayer::new()
+ .fails_with_partial_failure(retry.clone(), OnAttempt(1))
+ .fails_with_partial_failure(retry, OnAttempt(2))
+ .expect_send(Amount::ForInvoice(final_value_msat))
+ .expect_send(Amount::OnRetry(final_value_msat / 2))
+ .expect_send(Amount::OnRetry(final_value_msat / 2));
+ let router = TestRouter {};
+ let scorer = RefCell::new(TestScorer::new());
+ let logger = TestLogger::new();
+ let invoice_payer =
+ InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
+
+ assert!(invoice_payer.pay_invoice(&invoice).is_ok());
+ }
+
#[test]
fn retries_payment_path_for_unknown_payment() {
let event_handled = core::cell::RefCell::new(false);
let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
- let payer = TestPayer::new();
+ let payer = TestPayer::new()
+ .expect_send(Amount::OnRetry(final_value_msat / 2))
+ .expect_send(Amount::OnRetry(final_value_msat / 2));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
let payer = TestPayer::new()
- .expect_value_msat(final_value_msat)
- .expect_value_msat(final_value_msat / 2)
- .expect_value_msat(final_value_msat / 2);
+ .expect_send(Amount::ForInvoice(final_value_msat))
+ .expect_send(Amount::OnRetry(final_value_msat / 2))
+ .expect_send(Amount::OnRetry(final_value_msat / 2));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
let event_handled = core::cell::RefCell::new(false);
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
- let payer = TestPayer::new();
+ let payment_preimage = PaymentPreimage([1; 32]);
+ let invoice = invoice(payment_preimage);
+ let final_value_msat = invoice.amount_milli_satoshis().unwrap();
+
+ let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
let invoice_payer =
InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
assert_eq!(*payer.attempts.borrow(), 1);
let event_handled = core::cell::RefCell::new(false);
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
- let payer = TestPayer::new();
+ let payment_preimage = PaymentPreimage([1; 32]);
+ let invoice = invoice(payment_preimage);
+ let final_value_msat = invoice.amount_milli_satoshis().unwrap();
+
+ let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
let invoice_payer =
InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
assert_eq!(*payer.attempts.borrow(), 1);
let payer = TestPayer::new()
.fails_on_attempt(2)
- .expect_value_msat(final_value_msat);
+ .expect_send(Amount::ForInvoice(final_value_msat))
+ .expect_send(Amount::OnRetry(final_value_msat / 2));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
let event_handled = core::cell::RefCell::new(false);
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
- let payer = TestPayer::new();
+ let payment_preimage = PaymentPreimage([1; 32]);
+ let invoice = invoice(payment_preimage);
+ let final_value_msat = invoice.amount_milli_satoshis().unwrap();
+
+ let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
let invoice_payer =
InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
assert_eq!(*payer.attempts.borrow(), 1);
let event_handled = core::cell::RefCell::new(false);
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
- let payer = TestPayer::new();
+ let payment_preimage = PaymentPreimage([1; 32]);
+ let invoice = invoice(payment_preimage);
+ let final_value_msat = invoice.amount_milli_satoshis().unwrap();
+
+ let payer = TestPayer::new()
+ .expect_send(Amount::ForInvoice(final_value_msat))
+ .expect_send(Amount::ForInvoice(final_value_msat));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
let invoice_payer =
InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(0));
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
// Cannot repay an invoice pending payment.
#[test]
fn fails_paying_invoice_with_sending_errors() {
- let payer = TestPayer::new().fails_on_attempt(1);
+ let payment_preimage = PaymentPreimage([1; 32]);
+ let invoice = invoice(payment_preimage);
+ let final_value_msat = invoice.amount_milli_satoshis().unwrap();
+
+ let payer = TestPayer::new()
+ .fails_on_attempt(1)
+ .expect_send(Amount::ForInvoice(final_value_msat));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
let invoice_payer =
InvoicePayer::new(&payer, router, &scorer, &logger, |_: &_| {}, RetryAttempts(0));
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
match invoice_payer.pay_invoice(&invoice) {
Err(PaymentError::Sending(_)) => {},
Err(_) => panic!("unexpected error"),
let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
let final_value_msat = 100;
- let payer = TestPayer::new().expect_value_msat(final_value_msat);
+ let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new());
let logger = TestLogger::new();
}
}
+ #[test]
+ fn pays_pubkey_with_amount() {
+ let event_handled = core::cell::RefCell::new(false);
+ let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
+
+ let pubkey = pubkey();
+ let payment_preimage = PaymentPreimage([1; 32]);
+ let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
+ let final_value_msat = 100;
+ let final_cltv_expiry_delta = 42;
+
+ let payer = TestPayer::new()
+ .expect_send(Amount::Spontaneous(final_value_msat))
+ .expect_send(Amount::OnRetry(final_value_msat));
+ let router = TestRouter {};
+ let scorer = RefCell::new(TestScorer::new());
+ let logger = TestLogger::new();
+ let invoice_payer =
+ InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
+
+ let payment_id = Some(invoice_payer.pay_pubkey(
+ pubkey, payment_preimage, final_value_msat, final_cltv_expiry_delta
+ ).unwrap());
+ assert_eq!(*payer.attempts.borrow(), 1);
+
+ let retry = RouteParameters {
+ payee: Payee::for_keysend(pubkey),
+ final_value_msat,
+ final_cltv_expiry_delta,
+ };
+ let event = Event::PaymentPathFailed {
+ payment_id,
+ payment_hash,
+ network_update: None,
+ rejected_by_dest: false,
+ all_paths_failed: false,
+ path: vec![],
+ short_channel_id: None,
+ retry: Some(retry),
+ };
+ invoice_payer.handle_event(&event);
+ assert_eq!(*event_handled.borrow(), false);
+ assert_eq!(*payer.attempts.borrow(), 2);
+
+ invoice_payer.handle_event(&Event::PaymentSent {
+ payment_id, payment_preimage, payment_hash, fee_paid_msat: None
+ });
+ assert_eq!(*event_handled.borrow(), true);
+ assert_eq!(*payer.attempts.borrow(), 2);
+ }
+
#[test]
fn scores_failed_channel() {
let event_handled = core::cell::RefCell::new(false);
let short_channel_id = Some(path[0].short_channel_id);
// Expect that scorer is given short_channel_id upon handling the event.
- let payer = TestPayer::new();
+ let payer = TestPayer::new()
+ .expect_send(Amount::ForInvoice(final_value_msat))
+ .expect_send(Amount::OnRetry(final_value_msat / 2));
let router = TestRouter {};
let scorer = RefCell::new(TestScorer::new().expect_channel_failure(short_channel_id.unwrap()));
let logger = TestLogger::new();
}
}
- impl<S: routing::Score> Router<S> for TestRouter {
+ impl<S: Score> Router<S> for TestRouter {
fn find_route(
- &self,
- _payer: &PublicKey,
- params: &RouteParameters,
- _first_hops: Option<&[&ChannelDetails]>,
- _scorer: &S,
+ &self, _payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
+ _first_hops: Option<&[&ChannelDetails]>, _scorer: &S
) -> Result<Route, LightningError> {
Ok(Route {
payee: Some(params.payee.clone()), ..Self::route_for_value(params.final_value_msat)
struct FailingRouter;
- impl<S: routing::Score> Router<S> for FailingRouter {
+ impl<S: Score> Router<S> for FailingRouter {
fn find_route(
- &self,
- _payer: &PublicKey,
- _params: &RouteParameters,
- _first_hops: Option<&[&ChannelDetails]>,
- _scorer: &S,
+ &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
+ _first_hops: Option<&[&ChannelDetails]>, _scorer: &S
) -> Result<Route, LightningError> {
Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
}
}
}
- impl routing::Score for TestScorer {
+ impl Score for TestScorer {
fn channel_penalty_msat(
- &self, _short_channel_id: u64, _source: &NodeId, _target: &NodeId
+ &self, _short_channel_id: u64, _send_amt: u64, _chan_amt: Option<u64>, _source: &NodeId, _target: &NodeId
) -> u64 { 0 }
fn payment_path_failed(&mut self, _path: &[&RouteHop], short_channel_id: u64) {
}
struct TestPayer {
- expectations: core::cell::RefCell<VecDeque<u64>>,
+ expectations: core::cell::RefCell<VecDeque<Amount>>,
attempts: core::cell::RefCell<usize>,
- failing_on_attempt: Option<usize>,
+ failing_on_attempt: core::cell::RefCell<HashMap<usize, PaymentSendFailure>>,
}
+ #[derive(Clone, Debug, PartialEq, Eq)]
+ enum Amount {
+ ForInvoice(u64),
+ Spontaneous(u64),
+ OnRetry(u64),
+ }
+
+ struct OnAttempt(usize);
+
impl TestPayer {
fn new() -> Self {
Self {
expectations: core::cell::RefCell::new(VecDeque::new()),
attempts: core::cell::RefCell::new(0),
- failing_on_attempt: None,
+ failing_on_attempt: core::cell::RefCell::new(HashMap::new()),
}
}
- fn expect_value_msat(self, value_msat: u64) -> Self {
+ fn expect_send(self, value_msat: Amount) -> Self {
self.expectations.borrow_mut().push_back(value_msat);
self
}
fn fails_on_attempt(self, attempt: usize) -> Self {
- Self {
- expectations: core::cell::RefCell::new(self.expectations.borrow().clone()),
- attempts: core::cell::RefCell::new(0),
- failing_on_attempt: Some(attempt),
- }
+ let failure = PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed);
+ self.fails_with(failure, OnAttempt(attempt))
+ }
+
+ fn fails_with_partial_failure(self, retry: RouteParameters, attempt: OnAttempt) -> Self {
+ self.fails_with(PaymentSendFailure::PartialFailure {
+ results: vec![],
+ failed_paths_retry: Some(retry),
+ payment_id: PaymentId([1; 32]),
+ }, attempt)
}
- fn check_attempts(&self) -> bool {
+ fn fails_with(self, failure: PaymentSendFailure, attempt: OnAttempt) -> Self {
+ self.failing_on_attempt.borrow_mut().insert(attempt.0, failure);
+ self
+ }
+
+ fn check_attempts(&self) -> Result<PaymentId, PaymentSendFailure> {
let mut attempts = self.attempts.borrow_mut();
*attempts += 1;
- match self.failing_on_attempt {
- None => true,
- Some(attempt) if attempt != *attempts => true,
- Some(_) => false,
+
+ match self.failing_on_attempt.borrow_mut().remove(&*attempts) {
+ Some(failure) => Err(failure),
+ None => Ok(PaymentId([1; 32])),
}
}
- fn check_value_msats(&self, route: &Route) {
+ fn check_value_msats(&self, actual_value_msats: Amount) {
let expected_value_msats = self.expectations.borrow_mut().pop_front();
if let Some(expected_value_msats) = expected_value_msats {
- let actual_value_msats = route.get_total_amount();
assert_eq!(actual_value_msats, expected_value_msats);
+ } else {
+ panic!("Unexpected amount: {:?}", actual_value_msats);
}
}
}
}
fn send_payment(
- &self,
- route: &Route,
- _payment_hash: PaymentHash,
+ &self, route: &Route, _payment_hash: PaymentHash,
_payment_secret: &Option<PaymentSecret>
) -> Result<PaymentId, PaymentSendFailure> {
- if self.check_attempts() {
- self.check_value_msats(route);
- Ok(PaymentId([1; 32]))
- } else {
- Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed))
- }
+ self.check_value_msats(Amount::ForInvoice(route.get_total_amount()));
+ self.check_attempts()
+ }
+
+ fn send_spontaneous_payment(
+ &self, route: &Route, _payment_preimage: PaymentPreimage,
+ ) -> Result<PaymentId, PaymentSendFailure> {
+ self.check_value_msats(Amount::Spontaneous(route.get_total_amount()));
+ self.check_attempts()
}
fn retry_payment(
&self, route: &Route, _payment_id: PaymentId
) -> Result<(), PaymentSendFailure> {
- if self.check_attempts() {
- self.check_value_msats(route);
- Ok(())
- } else {
- Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed))
- }
+ self.check_value_msats(Amount::OnRetry(route.get_total_amount()));
+ self.check_attempts().map(|_| ())
}
}
// *** Full Featured Functional Tests with a Real ChannelManager ***
struct ManualRouter(RefCell<VecDeque<Result<Route, LightningError>>>);
- impl<S: routing::Score> Router<S> for ManualRouter {
- fn find_route(&self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, _scorer: &S)
- -> Result<Route, LightningError> {
+ impl<S: Score> Router<S> for ManualRouter {
+ fn find_route(
+ &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
+ _first_hops: Option<&[&ChannelDetails]>, _scorer: &S
+ ) -> Result<Route, LightningError> {
self.0.borrow_mut().pop_front().unwrap()
}
}
use lightning::chain;
use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
use lightning::chain::keysinterface::{Sign, KeysInterface};
-use lightning::ln::{PaymentHash, PaymentSecret};
+use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, PaymentSendFailure, MIN_FINAL_CLTV_EXPIRY};
use lightning::ln::msgs::LightningError;
-use lightning::routing;
+use lightning::routing::scoring::Score;
use lightning::routing::network_graph::{NetworkGraph, RoutingFees};
use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route};
use lightning::util::logger::Logger;
}
}
-impl<G, L: Deref, S: routing::Score> Router<S> for DefaultRouter<G, L>
+impl<G, L: Deref, S: Score> Router<S> for DefaultRouter<G, L>
where G: Deref<Target = NetworkGraph>, L::Target: Logger {
fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
- scorer: &S
+ &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
+ first_hops: Option<&[&ChannelDetails]>, scorer: &S
) -> Result<Route, LightningError> {
find_route(payer, params, &*self.network_graph, first_hops, &*self.logger, scorer)
}
self.send_payment(route, payment_hash, payment_secret)
}
+ fn send_spontaneous_payment(
+ &self, route: &Route, payment_preimage: PaymentPreimage,
+ ) -> Result<PaymentId, PaymentSendFailure> {
+ self.send_spontaneous_payment(route, Some(payment_preimage))
+ .map(|(_, payment_id)| payment_id)
+ }
+
fn retry_payment(
&self, route: &Route, payment_id: PaymentId
) -> Result<(), PaymentSendFailure> {
use ln::msgs::{ChannelMessageHandler, Init};
use routing::network_graph::NetworkGraph;
use routing::router::{Payee, get_route};
- use routing::scorer::Scorer;
+ use routing::scoring::Scorer;
use util::test_utils;
use util::config::UserConfig;
use util::events::{Event, MessageSendEvent, MessageSendEventsProvider, PaymentPurpose};
pub mod network_graph;
pub mod router;
-pub mod scorer;
-
-use routing::network_graph::NodeId;
-use routing::router::RouteHop;
-
-use core::cell::{RefCell, RefMut};
-use core::ops::DerefMut;
-use sync::{Mutex, MutexGuard};
-
-/// An interface used to score payment channels for path finding.
-///
-/// Scoring is in terms of fees willing to be paid in order to avoid routing through a channel.
-pub trait Score {
- /// Returns the fee in msats willing to be paid to avoid routing through the given channel
- /// in the direction from `source` to `target`.
- fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId) -> u64;
-
- /// Handles updating channel penalties after failing to route through a channel.
- fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64);
-}
-
-/// A scorer that is accessed under a lock.
-///
-/// Needed so that calls to [`Score::channel_penalty_msat`] in [`find_route`] can be made while
-/// having shared ownership of a scorer but without requiring internal locking in [`Score`]
-/// implementations. Internal locking would be detrimental to route finding performance and could
-/// result in [`Score::channel_penalty_msat`] returning a different value for the same channel.
-///
-/// [`find_route`]: crate::routing::router::find_route
-pub trait LockableScore<'a> {
- /// The locked [`Score`] type.
- type Locked: 'a + Score;
-
- /// Returns the locked scorer.
- fn lock(&'a self) -> Self::Locked;
-}
-
-impl<'a, T: 'a + Score> LockableScore<'a> for Mutex<T> {
- type Locked = MutexGuard<'a, T>;
-
- fn lock(&'a self) -> MutexGuard<'a, T> {
- Mutex::lock(self).unwrap()
- }
-}
-
-impl<'a, T: 'a + Score> LockableScore<'a> for RefCell<T> {
- type Locked = RefMut<'a, T>;
-
- fn lock(&'a self) -> RefMut<'a, T> {
- self.borrow_mut()
- }
-}
-
-impl<S: Score, T: DerefMut<Target=S>> Score for T {
- fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId) -> u64 {
- self.deref().channel_penalty_msat(short_channel_id, source, target)
- }
-
- fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
- self.deref_mut().payment_path_failed(path, short_channel_id)
- }
-}
+pub mod scoring;
use ln::channelmanager::ChannelDetails;
use ln::features::{ChannelFeatures, InvoiceFeatures, NodeFeatures};
use ln::msgs::{DecodeError, ErrorAction, LightningError, MAX_VALUE_MSAT};
-use routing;
+use routing::scoring::Score;
use routing::network_graph::{NetworkGraph, NodeId, RoutingFees};
use util::ser::{Writeable, Readable};
use util::logger::{Level, Logger};
///
/// [`ChannelManager::list_usable_channels`]: crate::ln::channelmanager::ChannelManager::list_usable_channels
/// [`Event::PaymentPathFailed`]: crate::util::events::Event::PaymentPathFailed
-pub fn find_route<L: Deref, S: routing::Score>(
+pub fn find_route<L: Deref, S: Score>(
our_node_pubkey: &PublicKey, params: &RouteParameters, network: &NetworkGraph,
first_hops: Option<&[&ChannelDetails]>, logger: L, scorer: &S
) -> Result<Route, LightningError>
)
}
-pub(crate) fn get_route<L: Deref, S: routing::Score>(
+pub(crate) fn get_route<L: Deref, S: Score>(
our_node_pubkey: &PublicKey, payee: &Payee, network: &NetworkGraph,
first_hops: Option<&[&ChannelDetails]>, final_value_msat: u64, final_cltv_expiry_delta: u32,
logger: L, scorer: &S
}
}
- let path_penalty_msat = $next_hops_path_penalty_msat
- .checked_add(scorer.channel_penalty_msat($chan_id.clone(), &$src_node_id, &$dest_node_id))
- .unwrap_or_else(|| u64::max_value());
+ let path_penalty_msat = $next_hops_path_penalty_msat.checked_add(
+ scorer.channel_penalty_msat($chan_id.clone(), amount_to_transfer_over_msat, Some(*available_liquidity_msat),
+ &$src_node_id, &$dest_node_id)).unwrap_or_else(|| u64::max_value());
let new_graph_node = RouteGraphNode {
node_id: $src_node_id,
lowest_fee_to_peer_through_node: total_fee_msat,
let src_node_id = NodeId::from_pubkey(&hop.src_node_id);
let dest_node_id = NodeId::from_pubkey(&prev_hop_id);
aggregate_next_hops_path_penalty_msat = aggregate_next_hops_path_penalty_msat
- .checked_add(scorer.channel_penalty_msat(hop.short_channel_id, &src_node_id, &dest_node_id))
+ .checked_add(scorer.channel_penalty_msat(hop.short_channel_id, final_value_msat, None, &src_node_id, &dest_node_id))
.unwrap_or_else(|| u64::max_value());
// We assume that the recipient only included route hints for routes which had
#[cfg(test)]
mod tests {
- use routing;
+ use routing::scoring::Score;
use routing::network_graph::{NetworkGraph, NetGraphMsgHandler, NodeId};
use routing::router::{get_route, Payee, Route, RouteHint, RouteHintHop, RouteHop, RoutingFees};
use chain::transaction::OutPoint;
short_channel_id: u64,
}
- impl routing::Score for BadChannelScorer {
- fn channel_penalty_msat(&self, short_channel_id: u64, _source: &NodeId, _target: &NodeId) -> u64 {
+ impl Score for BadChannelScorer {
+ fn channel_penalty_msat(&self, short_channel_id: u64, _send_amt: u64, _chan_amt: Option<u64>, _source: &NodeId, _target: &NodeId) -> u64 {
if short_channel_id == self.short_channel_id { u64::max_value() } else { 0 }
}
node_id: NodeId,
}
- impl routing::Score for BadNodeScorer {
- fn channel_penalty_msat(&self, _short_channel_id: u64, _source: &NodeId, target: &NodeId) -> u64 {
+ impl Score for BadNodeScorer {
+ fn channel_penalty_msat(&self, _short_channel_id: u64, _send_amt: u64, _chan_amt: Option<u64>, _source: &NodeId, target: &NodeId) -> u64 {
if *target == self.node_id { u64::max_value() } else { 0 }
}
#[cfg(all(test, feature = "unstable", not(feature = "no-std")))]
mod benches {
use super::*;
- use routing::scorer::Scorer;
+ use routing::scoring::Scorer;
use util::logger::{Logger, Record};
use test::Bencher;
+++ /dev/null
-// This file is Copyright its original authors, visible in version control
-// history.
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-//! Utilities for scoring payment channels.
-//!
-//! [`Scorer`] may be given to [`find_route`] to score payment channels during path finding when a
-//! custom [`routing::Score`] implementation is not needed.
-//!
-//! # Example
-//!
-//! ```
-//! # extern crate secp256k1;
-//! #
-//! # use lightning::routing::network_graph::NetworkGraph;
-//! # use lightning::routing::router::{RouteParameters, find_route};
-//! # use lightning::routing::scorer::{Scorer, ScoringParameters};
-//! # use lightning::util::logger::{Logger, Record};
-//! # use secp256k1::key::PublicKey;
-//! #
-//! # struct FakeLogger {};
-//! # impl Logger for FakeLogger {
-//! # fn log(&self, record: &Record) { unimplemented!() }
-//! # }
-//! # fn find_scored_route(payer: PublicKey, params: RouteParameters, network_graph: NetworkGraph) {
-//! # let logger = FakeLogger {};
-//! #
-//! // Use the default channel penalties.
-//! let scorer = Scorer::default();
-//!
-//! // Or use custom channel penalties.
-//! let scorer = Scorer::new(ScoringParameters {
-//! base_penalty_msat: 1000,
-//! failure_penalty_msat: 2 * 1024 * 1000,
-//! ..ScoringParameters::default()
-//! });
-//!
-//! let route = find_route(&payer, ¶ms, &network_graph, None, &logger, &scorer);
-//! # }
-//! ```
-//!
-//! # Note
-//!
-//! If persisting [`Scorer`], it must be restored using the same [`Time`] parameterization. Using a
-//! different type results in undefined behavior. Specifically, persisting when built with feature
-//! `no-std` and restoring without it, or vice versa, uses different types and thus is undefined.
-//!
-//! [`find_route`]: crate::routing::router::find_route
-
-use routing;
-
-use ln::msgs::DecodeError;
-use routing::network_graph::NodeId;
-use routing::router::RouteHop;
-use util::ser::{Readable, Writeable, Writer};
-
-use prelude::*;
-use core::ops::Sub;
-use core::time::Duration;
-use io::{self, Read};
-
-/// [`routing::Score`] implementation that provides reasonable default behavior.
-///
-/// Used to apply a fixed penalty to each channel, thus avoiding long paths when shorter paths with
-/// slightly higher fees are available. Will further penalize channels that fail to relay payments.
-///
-/// See [module-level documentation] for usage.
-///
-/// [module-level documentation]: crate::routing::scorer
-pub type Scorer = ScorerUsingTime::<DefaultTime>;
-
-/// Time used by [`Scorer`].
-#[cfg(not(feature = "no-std"))]
-pub type DefaultTime = std::time::Instant;
-
-/// Time used by [`Scorer`].
-#[cfg(feature = "no-std")]
-pub type DefaultTime = Eternity;
-
-/// [`routing::Score`] implementation parameterized by [`Time`].
-///
-/// See [`Scorer`] for details.
-///
-/// # Note
-///
-/// Mixing [`Time`] types between serialization and deserialization results in undefined behavior.
-pub struct ScorerUsingTime<T: Time> {
- params: ScoringParameters,
- // TODO: Remove entries of closed channels.
- channel_failures: HashMap<u64, ChannelFailure<T>>,
-}
-
-/// Parameters for configuring [`Scorer`].
-pub struct ScoringParameters {
- /// A fixed penalty in msats to apply to each channel.
- pub base_penalty_msat: u64,
-
- /// A penalty in msats to apply to a channel upon failing to relay a payment.
- ///
- /// This accumulates for each failure but may be reduced over time based on
- /// [`failure_penalty_half_life`].
- ///
- /// [`failure_penalty_half_life`]: Self::failure_penalty_half_life
- pub failure_penalty_msat: u64,
-
- /// The time required to elapse before any accumulated [`failure_penalty_msat`] penalties are
- /// cut in half.
- ///
- /// # Note
- ///
- /// When time is an [`Eternity`], as is default when enabling feature `no-std`, it will never
- /// elapse. Therefore, this penalty will never decay.
- ///
- /// [`failure_penalty_msat`]: Self::failure_penalty_msat
- pub failure_penalty_half_life: Duration,
-}
-
-impl_writeable_tlv_based!(ScoringParameters, {
- (0, base_penalty_msat, required),
- (2, failure_penalty_msat, required),
- (4, failure_penalty_half_life, required),
-});
-
-/// Accounting for penalties against a channel for failing to relay any payments.
-///
-/// Penalties decay over time, though accumulate as more failures occur.
-struct ChannelFailure<T: Time> {
- /// Accumulated penalty in msats for the channel as of `last_failed`.
- undecayed_penalty_msat: u64,
-
- /// Last time the channel failed. Used to decay `undecayed_penalty_msat`.
- last_failed: T,
-}
-
-/// A measurement of time.
-pub trait Time: Sub<Duration, Output = Self> where Self: Sized {
- /// Returns an instance corresponding to the current moment.
- fn now() -> Self;
-
- /// Returns the amount of time elapsed since `self` was created.
- fn elapsed(&self) -> Duration;
-
- /// Returns the amount of time passed since the beginning of [`Time`].
- ///
- /// Used during (de-)serialization.
- fn duration_since_epoch() -> Duration;
-}
-
-impl<T: Time> ScorerUsingTime<T> {
- /// Creates a new scorer using the given scoring parameters.
- pub fn new(params: ScoringParameters) -> Self {
- Self {
- params,
- channel_failures: HashMap::new(),
- }
- }
-
- /// Creates a new scorer using `penalty_msat` as a fixed channel penalty.
- #[cfg(any(test, feature = "fuzztarget", feature = "_test_utils"))]
- pub fn with_fixed_penalty(penalty_msat: u64) -> Self {
- Self::new(ScoringParameters {
- base_penalty_msat: penalty_msat,
- failure_penalty_msat: 0,
- failure_penalty_half_life: Duration::from_secs(0),
- })
- }
-}
-
-impl<T: Time> ChannelFailure<T> {
- fn new(failure_penalty_msat: u64) -> Self {
- Self {
- undecayed_penalty_msat: failure_penalty_msat,
- last_failed: T::now(),
- }
- }
-
- fn add_penalty(&mut self, failure_penalty_msat: u64, half_life: Duration) {
- self.undecayed_penalty_msat = self.decayed_penalty_msat(half_life) + failure_penalty_msat;
- self.last_failed = T::now();
- }
-
- fn decayed_penalty_msat(&self, half_life: Duration) -> u64 {
- let decays = self.last_failed.elapsed().as_secs().checked_div(half_life.as_secs());
- match decays {
- Some(decays) => self.undecayed_penalty_msat >> decays,
- None => 0,
- }
- }
-}
-
-impl<T: Time> Default for ScorerUsingTime<T> {
- fn default() -> Self {
- Self::new(ScoringParameters::default())
- }
-}
-
-impl Default for ScoringParameters {
- fn default() -> Self {
- Self {
- base_penalty_msat: 500,
- failure_penalty_msat: 1024 * 1000,
- failure_penalty_half_life: Duration::from_secs(3600),
- }
- }
-}
-
-impl<T: Time> routing::Score for ScorerUsingTime<T> {
- fn channel_penalty_msat(
- &self, short_channel_id: u64, _source: &NodeId, _target: &NodeId
- ) -> u64 {
- let failure_penalty_msat = self.channel_failures
- .get(&short_channel_id)
- .map_or(0, |value| value.decayed_penalty_msat(self.params.failure_penalty_half_life));
-
- self.params.base_penalty_msat + failure_penalty_msat
- }
-
- fn payment_path_failed(&mut self, _path: &[&RouteHop], short_channel_id: u64) {
- let failure_penalty_msat = self.params.failure_penalty_msat;
- let half_life = self.params.failure_penalty_half_life;
- self.channel_failures
- .entry(short_channel_id)
- .and_modify(|failure| failure.add_penalty(failure_penalty_msat, half_life))
- .or_insert_with(|| ChannelFailure::new(failure_penalty_msat));
- }
-}
-
-#[cfg(not(feature = "no-std"))]
-impl Time for std::time::Instant {
- fn now() -> Self {
- std::time::Instant::now()
- }
-
- fn duration_since_epoch() -> Duration {
- use std::time::SystemTime;
- SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap()
- }
-
- fn elapsed(&self) -> Duration {
- std::time::Instant::elapsed(self)
- }
-}
-
-/// A state in which time has no meaning.
-#[derive(Debug, PartialEq, Eq)]
-pub struct Eternity;
-
-impl Time for Eternity {
- fn now() -> Self {
- Self
- }
-
- fn duration_since_epoch() -> Duration {
- Duration::from_secs(0)
- }
-
- fn elapsed(&self) -> Duration {
- Duration::from_secs(0)
- }
-}
-
-impl Sub<Duration> for Eternity {
- type Output = Self;
-
- fn sub(self, _other: Duration) -> Self {
- self
- }
-}
-
-impl<T: Time> Writeable for ScorerUsingTime<T> {
- #[inline]
- fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
- self.params.write(w)?;
- self.channel_failures.write(w)?;
- write_tlv_fields!(w, {});
- Ok(())
- }
-}
-
-impl<T: Time> Readable for ScorerUsingTime<T> {
- #[inline]
- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
- let res = Ok(Self {
- params: Readable::read(r)?,
- channel_failures: Readable::read(r)?,
- });
- read_tlv_fields!(r, {});
- res
- }
-}
-
-impl<T: Time> Writeable for ChannelFailure<T> {
- #[inline]
- fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
- let duration_since_epoch = T::duration_since_epoch() - self.last_failed.elapsed();
- write_tlv_fields!(w, {
- (0, self.undecayed_penalty_msat, required),
- (2, duration_since_epoch, required),
- });
- Ok(())
- }
-}
-
-impl<T: Time> Readable for ChannelFailure<T> {
- #[inline]
- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
- let mut undecayed_penalty_msat = 0;
- let mut duration_since_epoch = Duration::from_secs(0);
- read_tlv_fields!(r, {
- (0, undecayed_penalty_msat, required),
- (2, duration_since_epoch, required),
- });
- Ok(Self {
- undecayed_penalty_msat,
- last_failed: T::now() - (T::duration_since_epoch() - duration_since_epoch),
- })
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::{Eternity, ScoringParameters, ScorerUsingTime, Time};
-
- use routing::Score;
- use routing::network_graph::NodeId;
- use util::ser::{Readable, Writeable};
-
- use bitcoin::secp256k1::PublicKey;
- use core::cell::Cell;
- use core::ops::Sub;
- use core::time::Duration;
- use io;
-
- /// Time that can be advanced manually in tests.
- #[derive(Debug, PartialEq, Eq)]
- struct SinceEpoch(Duration);
-
- impl SinceEpoch {
- thread_local! {
- static ELAPSED: Cell<Duration> = core::cell::Cell::new(Duration::from_secs(0));
- }
-
- fn advance(duration: Duration) {
- Self::ELAPSED.with(|elapsed| elapsed.set(elapsed.get() + duration))
- }
- }
-
- impl Time for SinceEpoch {
- fn now() -> Self {
- Self(Self::duration_since_epoch())
- }
-
- fn duration_since_epoch() -> Duration {
- Self::ELAPSED.with(|elapsed| elapsed.get())
- }
-
- fn elapsed(&self) -> Duration {
- Self::duration_since_epoch() - self.0
- }
- }
-
- impl Sub<Duration> for SinceEpoch {
- type Output = Self;
-
- fn sub(self, other: Duration) -> Self {
- Self(self.0 - other)
- }
- }
-
- #[test]
- fn time_passes_when_advanced() {
- let now = SinceEpoch::now();
- assert_eq!(now.elapsed(), Duration::from_secs(0));
-
- SinceEpoch::advance(Duration::from_secs(1));
- SinceEpoch::advance(Duration::from_secs(1));
-
- let elapsed = now.elapsed();
- let later = SinceEpoch::now();
-
- assert_eq!(elapsed, Duration::from_secs(2));
- assert_eq!(later - elapsed, now);
- }
-
- #[test]
- fn time_never_passes_in_an_eternity() {
- let now = Eternity::now();
- let elapsed = now.elapsed();
- let later = Eternity::now();
-
- assert_eq!(now.elapsed(), Duration::from_secs(0));
- assert_eq!(later - elapsed, now);
- }
-
- /// A scorer for testing with time that can be manually advanced.
- type Scorer = ScorerUsingTime::<SinceEpoch>;
-
- fn source_node_id() -> NodeId {
- NodeId::from_pubkey(&PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap())
- }
-
- fn target_node_id() -> NodeId {
- NodeId::from_pubkey(&PublicKey::from_slice(&hex::decode("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap())
- }
-
- #[test]
- fn penalizes_without_channel_failures() {
- let scorer = Scorer::new(ScoringParameters {
- base_penalty_msat: 1_000,
- failure_penalty_msat: 512,
- failure_penalty_half_life: Duration::from_secs(1),
- });
- let source = source_node_id();
- let target = target_node_id();
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_000);
-
- SinceEpoch::advance(Duration::from_secs(1));
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_000);
- }
-
- #[test]
- fn accumulates_channel_failure_penalties() {
- let mut scorer = Scorer::new(ScoringParameters {
- base_penalty_msat: 1_000,
- failure_penalty_msat: 64,
- failure_penalty_half_life: Duration::from_secs(10),
- });
- let source = source_node_id();
- let target = target_node_id();
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_000);
-
- scorer.payment_path_failed(&[], 42);
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_064);
-
- scorer.payment_path_failed(&[], 42);
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_128);
-
- scorer.payment_path_failed(&[], 42);
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_192);
- }
-
- #[test]
- fn decays_channel_failure_penalties_over_time() {
- let mut scorer = Scorer::new(ScoringParameters {
- base_penalty_msat: 1_000,
- failure_penalty_msat: 512,
- failure_penalty_half_life: Duration::from_secs(10),
- });
- let source = source_node_id();
- let target = target_node_id();
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_000);
-
- scorer.payment_path_failed(&[], 42);
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_512);
-
- SinceEpoch::advance(Duration::from_secs(9));
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_512);
-
- SinceEpoch::advance(Duration::from_secs(1));
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_256);
-
- SinceEpoch::advance(Duration::from_secs(10 * 8));
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_001);
-
- SinceEpoch::advance(Duration::from_secs(10));
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_000);
-
- SinceEpoch::advance(Duration::from_secs(10));
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_000);
- }
-
- #[test]
- fn accumulates_channel_failure_penalties_after_decay() {
- let mut scorer = Scorer::new(ScoringParameters {
- base_penalty_msat: 1_000,
- failure_penalty_msat: 512,
- failure_penalty_half_life: Duration::from_secs(10),
- });
- let source = source_node_id();
- let target = target_node_id();
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_000);
-
- scorer.payment_path_failed(&[], 42);
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_512);
-
- SinceEpoch::advance(Duration::from_secs(10));
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_256);
-
- scorer.payment_path_failed(&[], 42);
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_768);
-
- SinceEpoch::advance(Duration::from_secs(10));
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_384);
- }
-
- #[test]
- fn restores_persisted_channel_failure_penalties() {
- let mut scorer = Scorer::new(ScoringParameters {
- base_penalty_msat: 1_000,
- failure_penalty_msat: 512,
- failure_penalty_half_life: Duration::from_secs(10),
- });
- let source = source_node_id();
- let target = target_node_id();
-
- scorer.payment_path_failed(&[], 42);
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_512);
-
- SinceEpoch::advance(Duration::from_secs(10));
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_256);
-
- scorer.payment_path_failed(&[], 43);
- assert_eq!(scorer.channel_penalty_msat(43, &source, &target), 1_512);
-
- let mut serialized_scorer = Vec::new();
- scorer.write(&mut serialized_scorer).unwrap();
-
- let deserialized_scorer = <Scorer>::read(&mut io::Cursor::new(&serialized_scorer)).unwrap();
- assert_eq!(deserialized_scorer.channel_penalty_msat(42, &source, &target), 1_256);
- assert_eq!(deserialized_scorer.channel_penalty_msat(43, &source, &target), 1_512);
- }
-
- #[test]
- fn decays_persisted_channel_failure_penalties() {
- let mut scorer = Scorer::new(ScoringParameters {
- base_penalty_msat: 1_000,
- failure_penalty_msat: 512,
- failure_penalty_half_life: Duration::from_secs(10),
- });
- let source = source_node_id();
- let target = target_node_id();
-
- scorer.payment_path_failed(&[], 42);
- assert_eq!(scorer.channel_penalty_msat(42, &source, &target), 1_512);
-
- let mut serialized_scorer = Vec::new();
- scorer.write(&mut serialized_scorer).unwrap();
-
- SinceEpoch::advance(Duration::from_secs(10));
-
- let deserialized_scorer = <Scorer>::read(&mut io::Cursor::new(&serialized_scorer)).unwrap();
- assert_eq!(deserialized_scorer.channel_penalty_msat(42, &source, &target), 1_256);
-
- SinceEpoch::advance(Duration::from_secs(10));
- assert_eq!(deserialized_scorer.channel_penalty_msat(42, &source, &target), 1_128);
- }
-}
--- /dev/null
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+//! Utilities for scoring payment channels.
+//!
+//! [`Scorer`] may be given to [`find_route`] to score payment channels during path finding when a
+//! custom [`Score`] implementation is not needed.
+//!
+//! # Example
+//!
+//! ```
+//! # extern crate secp256k1;
+//! #
+//! # use lightning::routing::network_graph::NetworkGraph;
+//! # use lightning::routing::router::{RouteParameters, find_route};
+//! # use lightning::routing::scoring::{Scorer, ScoringParameters};
+//! # use lightning::util::logger::{Logger, Record};
+//! # use secp256k1::key::PublicKey;
+//! #
+//! # struct FakeLogger {};
+//! # impl Logger for FakeLogger {
+//! # fn log(&self, record: &Record) { unimplemented!() }
+//! # }
+//! # fn find_scored_route(payer: PublicKey, params: RouteParameters, network_graph: NetworkGraph) {
+//! # let logger = FakeLogger {};
+//! #
+//! // Use the default channel penalties.
+//! let scorer = Scorer::default();
+//!
+//! // Or use custom channel penalties.
+//! let scorer = Scorer::new(ScoringParameters {
+//! base_penalty_msat: 1000,
+//! failure_penalty_msat: 2 * 1024 * 1000,
+//! ..ScoringParameters::default()
+//! });
+//!
+//! let route = find_route(&payer, ¶ms, &network_graph, None, &logger, &scorer);
+//! # }
+//! ```
+//!
+//! # Note
+//!
+//! If persisting [`Scorer`], it must be restored using the same [`Time`] parameterization. Using a
+//! different type results in undefined behavior. Specifically, persisting when built with feature
+//! `no-std` and restoring without it, or vice versa, uses different types and thus is undefined.
+//!
+//! [`find_route`]: crate::routing::router::find_route
+
+use ln::msgs::DecodeError;
+use routing::network_graph::NodeId;
+use routing::router::RouteHop;
+use util::ser::{Readable, Writeable, Writer};
+
+use prelude::*;
+use core::cell::{RefCell, RefMut};
+use core::ops::{DerefMut, Sub};
+use core::time::Duration;
+use io::{self, Read}; use sync::{Mutex, MutexGuard};
+
+/// An interface used to score payment channels for path finding.
+///
+/// Scoring is in terms of fees willing to be paid in order to avoid routing through a channel.
+pub trait Score {
+ /// Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
+ /// given channel in the direction from `source` to `target`.
+ ///
+ /// The channel's capacity (less any other MPP parts which are also being considered for use in
+ /// the same payment) is given by `channel_capacity_msat`. It may be guessed from various
+ /// sources or assumed from no data at all.
+ ///
+ /// For hints provided in the invoice, we assume the channel has sufficient capacity to accept
+ /// the invoice's full amount, and provide a `channel_capacity_msat` of `None`. In all other
+ /// cases it is set to `Some`, even if we're guessing at the channel value.
+ ///
+ /// Your code should be overflow-safe through a `channel_capacity_msat` of 21 million BTC.
+ fn channel_penalty_msat(&self, short_channel_id: u64, send_amt_msat: u64, channel_capacity_msat: Option<u64>, source: &NodeId, target: &NodeId) -> u64;
+
+ /// Handles updating channel penalties after failing to route through a channel.
+ fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64);
+}
+
+/// A scorer that is accessed under a lock.
+///
+/// Needed so that calls to [`Score::channel_penalty_msat`] in [`find_route`] can be made while
+/// having shared ownership of a scorer but without requiring internal locking in [`Score`]
+/// implementations. Internal locking would be detrimental to route finding performance and could
+/// result in [`Score::channel_penalty_msat`] returning a different value for the same channel.
+///
+/// [`find_route`]: crate::routing::router::find_route
+pub trait LockableScore<'a> {
+ /// The locked [`Score`] type.
+ type Locked: 'a + Score;
+
+ /// Returns the locked scorer.
+ fn lock(&'a self) -> Self::Locked;
+}
+
+impl<'a, T: 'a + Score> LockableScore<'a> for Mutex<T> {
+ type Locked = MutexGuard<'a, T>;
+
+ fn lock(&'a self) -> MutexGuard<'a, T> {
+ Mutex::lock(self).unwrap()
+ }
+}
+
+impl<'a, T: 'a + Score> LockableScore<'a> for RefCell<T> {
+ type Locked = RefMut<'a, T>;
+
+ fn lock(&'a self) -> RefMut<'a, T> {
+ self.borrow_mut()
+ }
+}
+
+impl<S: Score, T: DerefMut<Target=S>> Score for T {
+ fn channel_penalty_msat(&self, short_channel_id: u64, send_amt_msat: u64, channel_capacity_msat: Option<u64>, source: &NodeId, target: &NodeId) -> u64 {
+ self.deref().channel_penalty_msat(short_channel_id, send_amt_msat, channel_capacity_msat, source, target)
+ }
+
+ fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
+ self.deref_mut().payment_path_failed(path, short_channel_id)
+ }
+}
+
+/// [`Score`] implementation that provides reasonable default behavior.
+///
+/// Used to apply a fixed penalty to each channel, thus avoiding long paths when shorter paths with
+/// slightly higher fees are available. Will further penalize channels that fail to relay payments.
+///
+/// See [module-level documentation] for usage.
+///
+/// [module-level documentation]: crate::routing::scoring
+pub type Scorer = ScorerUsingTime::<DefaultTime>;
+
+/// Time used by [`Scorer`].
+#[cfg(not(feature = "no-std"))]
+pub type DefaultTime = std::time::Instant;
+
+/// Time used by [`Scorer`].
+#[cfg(feature = "no-std")]
+pub type DefaultTime = Eternity;
+
+/// [`Score`] implementation parameterized by [`Time`].
+///
+/// See [`Scorer`] for details.
+///
+/// # Note
+///
+/// Mixing [`Time`] types between serialization and deserialization results in undefined behavior.
+pub struct ScorerUsingTime<T: Time> {
+ params: ScoringParameters,
+ // TODO: Remove entries of closed channels.
+ channel_failures: HashMap<u64, ChannelFailure<T>>,
+}
+
+/// Parameters for configuring [`Scorer`].
+pub struct ScoringParameters {
+ /// A fixed penalty in msats to apply to each channel.
+ ///
+ /// Default value: 500 msat
+ pub base_penalty_msat: u64,
+
+ /// A penalty in msats to apply to a channel upon failing to relay a payment.
+ ///
+ /// This accumulates for each failure but may be reduced over time based on
+ /// [`failure_penalty_half_life`].
+ ///
+ /// Default value: 1,024,000 msat
+ ///
+ /// [`failure_penalty_half_life`]: Self::failure_penalty_half_life
+ pub failure_penalty_msat: u64,
+
+ /// When the amount being sent over a channel is this many 1024ths of the total channel
+ /// capacity, we begin applying [`overuse_penalty_msat_per_1024th`].
+ ///
+ /// Default value: 128 1024ths (i.e. begin penalizing when an HTLC uses 1/8th of a channel)
+ ///
+ /// [`overuse_penalty_msat_per_1024th`]: Self::overuse_penalty_msat_per_1024th
+ pub overuse_penalty_start_1024th: u16,
+
+ /// A penalty applied, per whole 1024ths of the channel capacity which the amount being sent
+ /// over the channel exceeds [`overuse_penalty_start_1024th`] by.
+ ///
+ /// Default value: 20 msat (i.e. 2560 msat penalty to use 1/4th of a channel, 7680 msat penalty
+ /// to use half a channel, and 12,560 msat penalty to use 3/4ths of a channel)
+ ///
+ /// [`overuse_penalty_start_1024th`]: Self::overuse_penalty_start_1024th
+ pub overuse_penalty_msat_per_1024th: u64,
+
+ /// The time required to elapse before any accumulated [`failure_penalty_msat`] penalties are
+ /// cut in half.
+ ///
+ /// # Note
+ ///
+ /// When time is an [`Eternity`], as is default when enabling feature `no-std`, it will never
+ /// elapse. Therefore, this penalty will never decay.
+ ///
+ /// [`failure_penalty_msat`]: Self::failure_penalty_msat
+ pub failure_penalty_half_life: Duration,
+}
+
+impl_writeable_tlv_based!(ScoringParameters, {
+ (0, base_penalty_msat, required),
+ (1, overuse_penalty_start_1024th, (default_value, 128)),
+ (2, failure_penalty_msat, required),
+ (3, overuse_penalty_msat_per_1024th, (default_value, 20)),
+ (4, failure_penalty_half_life, required),
+});
+
+/// Accounting for penalties against a channel for failing to relay any payments.
+///
+/// Penalties decay over time, though accumulate as more failures occur.
+struct ChannelFailure<T: Time> {
+ /// Accumulated penalty in msats for the channel as of `last_failed`.
+ undecayed_penalty_msat: u64,
+
+ /// Last time the channel failed. Used to decay `undecayed_penalty_msat`.
+ last_failed: T,
+}
+
+/// A measurement of time.
+pub trait Time: Sub<Duration, Output = Self> where Self: Sized {
+ /// Returns an instance corresponding to the current moment.
+ fn now() -> Self;
+
+ /// Returns the amount of time elapsed since `self` was created.
+ fn elapsed(&self) -> Duration;
+
+ /// Returns the amount of time passed since the beginning of [`Time`].
+ ///
+ /// Used during (de-)serialization.
+ fn duration_since_epoch() -> Duration;
+}
+
+impl<T: Time> ScorerUsingTime<T> {
+ /// Creates a new scorer using the given scoring parameters.
+ pub fn new(params: ScoringParameters) -> Self {
+ Self {
+ params,
+ channel_failures: HashMap::new(),
+ }
+ }
+
+ /// Creates a new scorer using `penalty_msat` as a fixed channel penalty.
+ #[cfg(any(test, feature = "fuzztarget", feature = "_test_utils"))]
+ pub fn with_fixed_penalty(penalty_msat: u64) -> Self {
+ Self::new(ScoringParameters {
+ base_penalty_msat: penalty_msat,
+ failure_penalty_msat: 0,
+ failure_penalty_half_life: Duration::from_secs(0),
+ overuse_penalty_start_1024th: 1024,
+ overuse_penalty_msat_per_1024th: 0,
+ })
+ }
+}
+
+impl<T: Time> ChannelFailure<T> {
+ fn new(failure_penalty_msat: u64) -> Self {
+ Self {
+ undecayed_penalty_msat: failure_penalty_msat,
+ last_failed: T::now(),
+ }
+ }
+
+ fn add_penalty(&mut self, failure_penalty_msat: u64, half_life: Duration) {
+ self.undecayed_penalty_msat = self.decayed_penalty_msat(half_life) + failure_penalty_msat;
+ self.last_failed = T::now();
+ }
+
+ fn decayed_penalty_msat(&self, half_life: Duration) -> u64 {
+ let decays = self.last_failed.elapsed().as_secs().checked_div(half_life.as_secs());
+ match decays {
+ Some(decays) => self.undecayed_penalty_msat >> decays,
+ None => 0,
+ }
+ }
+}
+
+impl<T: Time> Default for ScorerUsingTime<T> {
+ fn default() -> Self {
+ Self::new(ScoringParameters::default())
+ }
+}
+
+impl Default for ScoringParameters {
+ fn default() -> Self {
+ Self {
+ base_penalty_msat: 500,
+ failure_penalty_msat: 1024 * 1000,
+ failure_penalty_half_life: Duration::from_secs(3600),
+ overuse_penalty_start_1024th: 1024 / 8,
+ overuse_penalty_msat_per_1024th: 20,
+ }
+ }
+}
+
+impl<T: Time> Score for ScorerUsingTime<T> {
+ fn channel_penalty_msat(
+ &self, short_channel_id: u64, send_amt_msat: u64, chan_capacity_opt: Option<u64>, _source: &NodeId, _target: &NodeId
+ ) -> u64 {
+ let failure_penalty_msat = self.channel_failures
+ .get(&short_channel_id)
+ .map_or(0, |value| value.decayed_penalty_msat(self.params.failure_penalty_half_life));
+
+ let mut penalty_msat = self.params.base_penalty_msat + failure_penalty_msat;
+
+ if let Some(chan_capacity_msat) = chan_capacity_opt {
+ let send_1024ths = send_amt_msat.checked_mul(1024).unwrap_or(u64::max_value()) / chan_capacity_msat;
+
+ if send_1024ths > self.params.overuse_penalty_start_1024th as u64 {
+ penalty_msat = penalty_msat.checked_add(
+ (send_1024ths - self.params.overuse_penalty_start_1024th as u64)
+ .checked_mul(self.params.overuse_penalty_msat_per_1024th).unwrap_or(u64::max_value()))
+ .unwrap_or(u64::max_value());
+ }
+ }
+
+ penalty_msat
+ }
+
+ fn payment_path_failed(&mut self, _path: &[&RouteHop], short_channel_id: u64) {
+ let failure_penalty_msat = self.params.failure_penalty_msat;
+ let half_life = self.params.failure_penalty_half_life;
+ self.channel_failures
+ .entry(short_channel_id)
+ .and_modify(|failure| failure.add_penalty(failure_penalty_msat, half_life))
+ .or_insert_with(|| ChannelFailure::new(failure_penalty_msat));
+ }
+}
+
+#[cfg(not(feature = "no-std"))]
+impl Time for std::time::Instant {
+ fn now() -> Self {
+ std::time::Instant::now()
+ }
+
+ fn duration_since_epoch() -> Duration {
+ use std::time::SystemTime;
+ SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap()
+ }
+
+ fn elapsed(&self) -> Duration {
+ std::time::Instant::elapsed(self)
+ }
+}
+
+/// A state in which time has no meaning.
+#[derive(Debug, PartialEq, Eq)]
+pub struct Eternity;
+
+impl Time for Eternity {
+ fn now() -> Self {
+ Self
+ }
+
+ fn duration_since_epoch() -> Duration {
+ Duration::from_secs(0)
+ }
+
+ fn elapsed(&self) -> Duration {
+ Duration::from_secs(0)
+ }
+}
+
+impl Sub<Duration> for Eternity {
+ type Output = Self;
+
+ fn sub(self, _other: Duration) -> Self {
+ self
+ }
+}
+
+impl<T: Time> Writeable for ScorerUsingTime<T> {
+ #[inline]
+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+ self.params.write(w)?;
+ self.channel_failures.write(w)?;
+ write_tlv_fields!(w, {});
+ Ok(())
+ }
+}
+
+impl<T: Time> Readable for ScorerUsingTime<T> {
+ #[inline]
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+ let res = Ok(Self {
+ params: Readable::read(r)?,
+ channel_failures: Readable::read(r)?,
+ });
+ read_tlv_fields!(r, {});
+ res
+ }
+}
+
+impl<T: Time> Writeable for ChannelFailure<T> {
+ #[inline]
+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+ let duration_since_epoch = T::duration_since_epoch() - self.last_failed.elapsed();
+ write_tlv_fields!(w, {
+ (0, self.undecayed_penalty_msat, required),
+ (2, duration_since_epoch, required),
+ });
+ Ok(())
+ }
+}
+
+impl<T: Time> Readable for ChannelFailure<T> {
+ #[inline]
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+ let mut undecayed_penalty_msat = 0;
+ let mut duration_since_epoch = Duration::from_secs(0);
+ read_tlv_fields!(r, {
+ (0, undecayed_penalty_msat, required),
+ (2, duration_since_epoch, required),
+ });
+ Ok(Self {
+ undecayed_penalty_msat,
+ last_failed: T::now() - (T::duration_since_epoch() - duration_since_epoch),
+ })
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{Eternity, ScoringParameters, ScorerUsingTime, Time};
+
+ use routing::scoring::Score;
+ use routing::network_graph::NodeId;
+ use util::ser::{Readable, Writeable};
+
+ use bitcoin::secp256k1::PublicKey;
+ use core::cell::Cell;
+ use core::ops::Sub;
+ use core::time::Duration;
+ use io;
+
+ /// Time that can be advanced manually in tests.
+ #[derive(Debug, PartialEq, Eq)]
+ struct SinceEpoch(Duration);
+
+ impl SinceEpoch {
+ thread_local! {
+ static ELAPSED: Cell<Duration> = core::cell::Cell::new(Duration::from_secs(0));
+ }
+
+ fn advance(duration: Duration) {
+ Self::ELAPSED.with(|elapsed| elapsed.set(elapsed.get() + duration))
+ }
+ }
+
+ impl Time for SinceEpoch {
+ fn now() -> Self {
+ Self(Self::duration_since_epoch())
+ }
+
+ fn duration_since_epoch() -> Duration {
+ Self::ELAPSED.with(|elapsed| elapsed.get())
+ }
+
+ fn elapsed(&self) -> Duration {
+ Self::duration_since_epoch() - self.0
+ }
+ }
+
+ impl Sub<Duration> for SinceEpoch {
+ type Output = Self;
+
+ fn sub(self, other: Duration) -> Self {
+ Self(self.0 - other)
+ }
+ }
+
+ #[test]
+ fn time_passes_when_advanced() {
+ let now = SinceEpoch::now();
+ assert_eq!(now.elapsed(), Duration::from_secs(0));
+
+ SinceEpoch::advance(Duration::from_secs(1));
+ SinceEpoch::advance(Duration::from_secs(1));
+
+ let elapsed = now.elapsed();
+ let later = SinceEpoch::now();
+
+ assert_eq!(elapsed, Duration::from_secs(2));
+ assert_eq!(later - elapsed, now);
+ }
+
+ #[test]
+ fn time_never_passes_in_an_eternity() {
+ let now = Eternity::now();
+ let elapsed = now.elapsed();
+ let later = Eternity::now();
+
+ assert_eq!(now.elapsed(), Duration::from_secs(0));
+ assert_eq!(later - elapsed, now);
+ }
+
+ /// A scorer for testing with time that can be manually advanced.
+ type Scorer = ScorerUsingTime::<SinceEpoch>;
+
+ fn source_node_id() -> NodeId {
+ NodeId::from_pubkey(&PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap())
+ }
+
+ fn target_node_id() -> NodeId {
+ NodeId::from_pubkey(&PublicKey::from_slice(&hex::decode("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap())
+ }
+
+ #[test]
+ fn penalizes_without_channel_failures() {
+ let scorer = Scorer::new(ScoringParameters {
+ base_penalty_msat: 1_000,
+ failure_penalty_msat: 512,
+ failure_penalty_half_life: Duration::from_secs(1),
+ overuse_penalty_start_1024th: 1024,
+ overuse_penalty_msat_per_1024th: 0,
+ });
+ let source = source_node_id();
+ let target = target_node_id();
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_000);
+
+ SinceEpoch::advance(Duration::from_secs(1));
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_000);
+ }
+
+ #[test]
+ fn accumulates_channel_failure_penalties() {
+ let mut scorer = Scorer::new(ScoringParameters {
+ base_penalty_msat: 1_000,
+ failure_penalty_msat: 64,
+ failure_penalty_half_life: Duration::from_secs(10),
+ overuse_penalty_start_1024th: 1024,
+ overuse_penalty_msat_per_1024th: 0,
+ });
+ let source = source_node_id();
+ let target = target_node_id();
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_000);
+
+ scorer.payment_path_failed(&[], 42);
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_064);
+
+ scorer.payment_path_failed(&[], 42);
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_128);
+
+ scorer.payment_path_failed(&[], 42);
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_192);
+ }
+
+ #[test]
+ fn decays_channel_failure_penalties_over_time() {
+ let mut scorer = Scorer::new(ScoringParameters {
+ base_penalty_msat: 1_000,
+ failure_penalty_msat: 512,
+ failure_penalty_half_life: Duration::from_secs(10),
+ overuse_penalty_start_1024th: 1024,
+ overuse_penalty_msat_per_1024th: 0,
+ });
+ let source = source_node_id();
+ let target = target_node_id();
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_000);
+
+ scorer.payment_path_failed(&[], 42);
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_512);
+
+ SinceEpoch::advance(Duration::from_secs(9));
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_512);
+
+ SinceEpoch::advance(Duration::from_secs(1));
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_256);
+
+ SinceEpoch::advance(Duration::from_secs(10 * 8));
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_001);
+
+ SinceEpoch::advance(Duration::from_secs(10));
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_000);
+
+ SinceEpoch::advance(Duration::from_secs(10));
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_000);
+ }
+
+ #[test]
+ fn accumulates_channel_failure_penalties_after_decay() {
+ let mut scorer = Scorer::new(ScoringParameters {
+ base_penalty_msat: 1_000,
+ failure_penalty_msat: 512,
+ failure_penalty_half_life: Duration::from_secs(10),
+ overuse_penalty_start_1024th: 1024,
+ overuse_penalty_msat_per_1024th: 0,
+ });
+ let source = source_node_id();
+ let target = target_node_id();
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_000);
+
+ scorer.payment_path_failed(&[], 42);
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_512);
+
+ SinceEpoch::advance(Duration::from_secs(10));
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_256);
+
+ scorer.payment_path_failed(&[], 42);
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_768);
+
+ SinceEpoch::advance(Duration::from_secs(10));
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_384);
+ }
+
+ #[test]
+ fn restores_persisted_channel_failure_penalties() {
+ let mut scorer = Scorer::new(ScoringParameters {
+ base_penalty_msat: 1_000,
+ failure_penalty_msat: 512,
+ failure_penalty_half_life: Duration::from_secs(10),
+ overuse_penalty_start_1024th: 1024,
+ overuse_penalty_msat_per_1024th: 0,
+ });
+ let source = source_node_id();
+ let target = target_node_id();
+
+ scorer.payment_path_failed(&[], 42);
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_512);
+
+ SinceEpoch::advance(Duration::from_secs(10));
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_256);
+
+ scorer.payment_path_failed(&[], 43);
+ assert_eq!(scorer.channel_penalty_msat(43, 1, Some(1), &source, &target), 1_512);
+
+ let mut serialized_scorer = Vec::new();
+ scorer.write(&mut serialized_scorer).unwrap();
+
+ let deserialized_scorer = <Scorer>::read(&mut io::Cursor::new(&serialized_scorer)).unwrap();
+ assert_eq!(deserialized_scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_256);
+ assert_eq!(deserialized_scorer.channel_penalty_msat(43, 1, Some(1), &source, &target), 1_512);
+ }
+
+ #[test]
+ fn decays_persisted_channel_failure_penalties() {
+ let mut scorer = Scorer::new(ScoringParameters {
+ base_penalty_msat: 1_000,
+ failure_penalty_msat: 512,
+ failure_penalty_half_life: Duration::from_secs(10),
+ overuse_penalty_start_1024th: 1024,
+ overuse_penalty_msat_per_1024th: 0,
+ });
+ let source = source_node_id();
+ let target = target_node_id();
+
+ scorer.payment_path_failed(&[], 42);
+ assert_eq!(scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_512);
+
+ let mut serialized_scorer = Vec::new();
+ scorer.write(&mut serialized_scorer).unwrap();
+
+ SinceEpoch::advance(Duration::from_secs(10));
+
+ let deserialized_scorer = <Scorer>::read(&mut io::Cursor::new(&serialized_scorer)).unwrap();
+ assert_eq!(deserialized_scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_256);
+
+ SinceEpoch::advance(Duration::from_secs(10));
+ assert_eq!(deserialized_scorer.channel_penalty_msat(42, 1, Some(1), &source, &target), 1_128);
+ }
+
+ #[test]
+ fn charges_per_1024th_penalty() {
+ let scorer = Scorer::new(ScoringParameters {
+ base_penalty_msat: 0,
+ failure_penalty_msat: 0,
+ failure_penalty_half_life: Duration::from_secs(0),
+ overuse_penalty_start_1024th: 256,
+ overuse_penalty_msat_per_1024th: 100,
+ });
+ let source = source_node_id();
+ let target = target_node_id();
+
+ assert_eq!(scorer.channel_penalty_msat(42, 1_000, None, &source, &target), 0);
+ assert_eq!(scorer.channel_penalty_msat(42, 1_000, Some(1_024_000), &source, &target), 0);
+ assert_eq!(scorer.channel_penalty_msat(42, 256_999, Some(1_024_000), &source, &target), 0);
+ assert_eq!(scorer.channel_penalty_msat(42, 257_000, Some(1_024_000), &source, &target), 100);
+ assert_eq!(scorer.channel_penalty_msat(42, 258_000, Some(1_024_000), &source, &target), 200);
+ assert_eq!(scorer.channel_penalty_msat(42, 512_000, Some(1_024_000), &source, &target), 256 * 100);
+ }
+}
use ln::msgs;
use ln::msgs::OptionalField;
use ln::script::ShutdownScript;
-use routing::scorer::{Eternity, ScorerUsingTime};
+use routing::scoring::{Eternity, ScorerUsingTime};
use util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
use util::events;
use util::logger::{Logger, Level, Record};
projects / rust-lightning / commitdiff