//! # extern crate lightning_invoice;
//! # extern crate secp256k1;
//! #
+//! # #[cfg(feature = "no-std")]
+//! # extern crate core2;
+//! #
//! # use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
//! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
//! # use lightning::ln::msgs::LightningError;
//! # use std::cell::RefCell;
//! # use std::ops::Deref;
//! #
+//! # #[cfg(not(feature = "std"))]
+//! # use core2::io;
+//! # #[cfg(feature = "std")]
+//! # use std::io;
+//! #
//! # struct FakeEventProvider {}
//! # impl EventsProvider for FakeEventProvider {
//! # fn process_pending_events<H: Deref>(&self, handler: H) where H::Target: EventHandler {}
//! #
//! # struct FakeScorer {}
//! # impl Writeable for FakeScorer {
-//! # fn write<W: Writer>(&self, w: &mut W) -> Result<(), std::io::Error> { unimplemented!(); }
+//! # fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> { unimplemented!(); }
//! # }
//! # impl Score for FakeScorer {
//! # fn channel_penalty_msat(
-//! # &self, _short_channel_id: u64, _send_amt: u64, _chan_amt: Option<u64>, _source: &NodeId, _target: &NodeId
+//! # &self, _short_channel_id: u64, _send_amt: u64, _chan_amt: u64, _source: &NodeId, _target: &NodeId
//! # ) -> u64 { 0 }
//! # fn payment_path_failed(&mut self, _path: &[&RouteHop], _short_channel_id: u64) {}
//! # fn payment_path_successful(&mut self, _path: &[&RouteHop]) {}
use bitcoin_hashes::Hash;
use bitcoin_hashes::sha256::Hash as Sha256;
+use crate::prelude::*;
use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
use lightning::ln::msgs::LightningError;
use lightning::routing::scoring::{LockableScore, Score};
-use lightning::routing::router::{Payee, Route, RouteParameters};
+use lightning::routing::router::{PaymentParameters, Route, RouteParameters};
use lightning::util::events::{Event, EventHandler};
use lightning::util::logger::Logger;
+use crate::sync::Mutex;
use secp256k1::key::PublicKey;
-use std::collections::hash_map::{self, HashMap};
-use std::ops::Deref;
-use std::sync::Mutex;
-use std::time::{Duration, SystemTime};
+use core::ops::Deref;
+use core::time::Duration;
+#[cfg(feature = "std")]
+use std::time::SystemTime;
/// A utility for paying [`Invoice`]s and sending spontaneous payments.
///
/// See [module-level documentation] for details.
///
/// [module-level documentation]: crate::payment
-pub struct InvoicePayer<P: Deref, R, S: Deref, L: Deref, E>
+pub struct InvoicePayer<P: Deref, R, S: Deref, L: Deref, E: EventHandler>
where
P::Target: Payer,
R: for <'a> Router<<<S as Deref>::Target as LockableScore<'a>>::Locked>,
S::Target: for <'a> LockableScore<'a>,
L::Target: Logger,
- E: EventHandler,
{
payer: P,
router: R,
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, payment_hash: &PaymentHash,
+ &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
first_hops: Option<&[&ChannelDetails]>, scorer: &S
) -> Result<Route, LightningError>;
}
Sending(PaymentSendFailure),
}
-impl<P: Deref, R, S: Deref, L: Deref, E> InvoicePayer<P, R, S, L, E>
+impl<P: Deref, R, S: Deref, L: Deref, E: EventHandler> InvoicePayer<P, R, S, L, E>
where
P::Target: Payer,
R: for <'a> Router<<<S as Deref>::Target as LockableScore<'a>>::Locked>,
S::Target: for <'a> LockableScore<'a>,
L::Target: Logger,
- E: EventHandler,
{
/// Creates an invoice payer that retries failed payment paths.
///
};
let payment_secret = Some(invoice.payment_secret().clone());
- let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key())
+ let mut payment_params = PaymentParameters::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());
+ payment_params = payment_params.with_features(features.clone());
}
- let params = RouteParameters {
- payee,
+ let route_params = RouteParameters {
+ payment_params,
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)
+ self.pay_internal(&route_params, payment_hash, send_payment)
.map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e })
}
hash_map::Entry::Vacant(entry) => entry.insert(0),
};
- let params = RouteParameters {
- payee: Payee::for_keysend(pubkey),
+ let route_params = RouteParameters {
+ payment_params: PaymentParameters::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)
+ self.pay_internal(&route_params, payment_hash, send_payment)
.map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e })
}
fn pay_internal<F: FnOnce(&Route) -> Result<PaymentId, PaymentSendFailure> + Copy>(
&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"));
+ #[cfg(feature = "std")] {
+ 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 payer = self.payer.node_id();
Err(e)
} else {
*retry_count += 1;
- std::mem::drop(payment_cache);
+ core::mem::drop(payment_cache);
Ok(self.pay_internal(params, payment_hash, send_payment)?)
}
},
return Err(());
}
- if has_expired(params) {
- log_trace!(self.logger, "Invoice expired for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
- return Err(());
+ #[cfg(feature = "std")] {
+ if has_expired(params) {
+ log_trace!(self.logger, "Invoice expired for payment {}; not retrying (attempts: {})", log_bytes!(payment_hash.0), attempts);
+ return Err(());
+ }
}
let payer = self.payer.node_id();
}
fn expiry_time_from_unix_epoch(invoice: &Invoice) -> Duration {
- invoice.timestamp().duration_since(SystemTime::UNIX_EPOCH).unwrap() + invoice.expiry_time()
+ invoice.signed_invoice.raw_invoice.data.timestamp.0 + invoice.expiry_time()
}
-fn has_expired(params: &RouteParameters) -> bool {
- if let Some(expiry_time) = params.payee.expiry_time {
+#[cfg(feature = "std")]
+fn has_expired(route_params: &RouteParameters) -> bool {
+ if let Some(expiry_time) = route_params.payment_params.expiry_time {
Invoice::is_expired_from_epoch(&SystemTime::UNIX_EPOCH, Duration::from_secs(expiry_time))
} else { false }
}
-impl<P: Deref, R, S: Deref, L: Deref, E> EventHandler for InvoicePayer<P, R, S, L, E>
+impl<P: Deref, R, S: Deref, L: Deref, E: EventHandler> EventHandler for InvoicePayer<P, R, S, L, E>
where
P::Target: Payer,
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 {
#[cfg(test)]
mod tests {
use super::*;
- use crate::{DEFAULT_EXPIRY_TIME, InvoiceBuilder, Currency};
- use utils::create_invoice_from_channelmanager;
+ use crate::{InvoiceBuilder, Currency};
+ use utils::create_invoice_from_channelmanager_and_duration_since_epoch;
use bitcoin_hashes::sha256::Hash as Sha256;
use lightning::ln::PaymentPreimage;
use lightning::ln::features::{ChannelFeatures, NodeFeatures, InitFeatures};
use lightning::ln::functional_test_utils::*;
use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
use lightning::routing::network_graph::NodeId;
- use lightning::routing::router::{Payee, Route, RouteHop};
+ use lightning::routing::router::{PaymentParameters, Route, RouteHop};
use lightning::util::test_utils::TestLogger;
use lightning::util::errors::APIError;
use lightning::util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
use std::cell::RefCell;
use std::collections::VecDeque;
use std::time::{SystemTime, Duration};
+ use DEFAULT_EXPIRY_TIME;
fn invoice(payment_preimage: PaymentPreimage) -> Invoice {
let payment_hash = Sha256::hash(&payment_preimage.0);
let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
+
InvoiceBuilder::new(Currency::Bitcoin)
.description("test".into())
.payment_hash(payment_hash)
.payment_secret(PaymentSecret([0; 32]))
- .current_timestamp()
+ .duration_since_epoch(duration_since_epoch())
.min_final_cltv_expiry(144)
.amount_milli_satoshis(128)
.build_signed(|hash| {
.unwrap()
}
+ fn duration_since_epoch() -> Duration {
+ #[cfg(feature = "std")]
+ let duration_since_epoch =
+ SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+ #[cfg(not(feature = "std"))]
+ let duration_since_epoch = Duration::from_secs(1234567);
+ duration_since_epoch
+ }
+
fn zero_value_invoice(payment_preimage: PaymentPreimage) -> Invoice {
let payment_hash = Sha256::hash(&payment_preimage.0);
let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
+
InvoiceBuilder::new(Currency::Bitcoin)
.description("test".into())
.payment_hash(payment_hash)
.payment_secret(PaymentSecret([0; 32]))
- .current_timestamp()
+ .duration_since_epoch(duration_since_epoch())
.min_final_cltv_expiry(144)
.build_signed(|hash| {
Secp256k1::new().sign_recoverable(hash, &private_key)
.unwrap()
}
+ #[cfg(feature = "std")]
fn expired_invoice(payment_preimage: PaymentPreimage) -> Invoice {
let payment_hash = Sha256::hash(&payment_preimage.0);
let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
- let timestamp = SystemTime::now()
+ let duration = duration_since_epoch()
.checked_sub(Duration::from_secs(DEFAULT_EXPIRY_TIME * 2))
.unwrap();
InvoiceBuilder::new(Currency::Bitcoin)
.description("test".into())
.payment_hash(payment_hash)
.payment_secret(PaymentSecret([0; 32]))
- .timestamp(timestamp)
+ .duration_since_epoch(duration)
.min_final_cltv_expiry(144)
.amount_milli_satoshis(128)
.build_signed(|hash| {
assert_eq!(*payer.attempts.borrow(), 1);
}
+ // Expiration is checked only in an std environment
+ #[cfg(feature = "std")]
#[test]
fn fails_paying_invoice_after_expiration() {
let event_handled = core::cell::RefCell::new(false);
} else { panic!("Expected Invoice Error"); }
}
+ // Expiration is checked only in an std environment
+ #[cfg(feature = "std")]
#[test]
fn fails_retrying_invoice_after_expiration() {
let event_handled = core::cell::RefCell::new(false);
assert_eq!(*payer.attempts.borrow(), 1);
let mut retry_data = TestRouter::retry_for_invoice(&invoice);
- retry_data.payee.expiry_time = Some(SystemTime::now()
+ retry_data.payment_params.expiry_time = Some(SystemTime::now()
.checked_sub(Duration::from_secs(2)).unwrap()
.duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs());
let event = Event::PaymentPathFailed {
assert_eq!(*payer.attempts.borrow(), 1);
let retry = RouteParameters {
- payee: Payee::for_keysend(pubkey),
+ payment_params: PaymentParameters::for_keysend(pubkey),
final_value_msat,
final_cltv_expiry_delta,
};
short_channel_id: 1, fee_msat: final_value_msat / 2, cltv_expiry_delta: 144
}],
],
- payee: None,
+ payment_params: None,
}
}
}
fn retry_for_invoice(invoice: &Invoice) -> RouteParameters {
- let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key())
+ let mut payment_params = PaymentParameters::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());
+ payment_params = payment_params.with_features(features.clone());
}
let final_value_msat = invoice.amount_milli_satoshis().unwrap() / 2;
RouteParameters {
- payee,
+ payment_params,
final_value_msat,
final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
}
impl<S: Score> Router<S> for TestRouter {
fn find_route(
- &self, _payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
+ &self, _payer: &PublicKey, route_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)
+ payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
})
}
}
impl Score for TestScorer {
fn channel_penalty_msat(
- &self, _short_channel_id: u64, _send_amt: u64, _chan_amt: Option<u64>, _source: &NodeId, _target: &NodeId
+ &self, _short_channel_id: u64, _send_amt: u64, _chan_amt: u64, _source: &NodeId, _target: &NodeId
) -> u64 { 0 }
fn payment_path_failed(&mut self, actual_path: &[&RouteHop], actual_short_channel_id: u64) {
cltv_expiry_delta: 100,
}],
],
- payee: Some(Payee::from_node_id(nodes[1].node.get_our_node_id())),
+ payment_params: Some(PaymentParameters::from_node_id(nodes[1].node.get_our_node_id())),
};
let router = ManualRouter(RefCell::new(VecDeque::new()));
router.expect_find_route(Ok(route.clone()));
let scorer = RefCell::new(TestScorer::new());
let invoice_payer = InvoicePayer::new(nodes[0].node, router, &scorer, nodes[0].logger, event_handler, RetryAttempts(1));
- assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager(
- &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string()).unwrap())
+ assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager_and_duration_since_epoch(
+ &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string(),
+ duration_since_epoch()).unwrap())
.is_ok());
let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events();
assert_eq!(htlc_msgs.len(), 2);
cltv_expiry_delta: 100,
}],
],
- payee: Some(Payee::from_node_id(nodes[1].node.get_our_node_id())),
+ payment_params: Some(PaymentParameters::from_node_id(nodes[1].node.get_our_node_id())),
};
let router = ManualRouter(RefCell::new(VecDeque::new()));
router.expect_find_route(Ok(route.clone()));
let scorer = RefCell::new(TestScorer::new());
let invoice_payer = InvoicePayer::new(nodes[0].node, router, &scorer, nodes[0].logger, event_handler, RetryAttempts(1));
- assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager(
- &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string()).unwrap())
+ assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager_and_duration_since_epoch(
+ &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string(),
+ duration_since_epoch()).unwrap())
.is_ok());
let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events();
assert_eq!(htlc_msgs.len(), 2);
cltv_expiry_delta: 100,
}]
],
- payee: Some(Payee::from_node_id(nodes[2].node.get_our_node_id())),
+ payment_params: Some(PaymentParameters::from_node_id(nodes[2].node.get_our_node_id())),
};
let router = ManualRouter(RefCell::new(VecDeque::new()));
router.expect_find_route(Ok(route.clone()));
let scorer = RefCell::new(TestScorer::new());
let invoice_payer = InvoicePayer::new(nodes[0].node, router, &scorer, nodes[0].logger, event_handler, RetryAttempts(1));
- assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager(
- &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string()).unwrap())
+ assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager_and_duration_since_epoch(
+ &nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string(),
+ duration_since_epoch()).unwrap())
.is_ok());
let htlc_updates = SendEvent::from_node(&nodes[0]);
check_added_monitors!(nodes[0], 1);