X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-invoice%2Fsrc%2Futils.rs;h=38f3a597871a8327e9dd33c0c912f5c70688d843;hb=5b8af341e84bac7d7eb2344b12d4c43918922804;hp=b9303e56f341cedc106ad3817f58ed3529f70838;hpb=ce6bcf68a15331c082b34d09902241583bc6ff71;p=rust-lightning diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index b9303e56..38f3a597 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -1,7 +1,6 @@ //! Convenient utilities to create an invoice. use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError}; -use crate::payment::Payer; use crate::{prelude::*, Description, InvoiceDescription, Sha256}; use bech32::ToBase32; @@ -9,19 +8,17 @@ use bitcoin_hashes::Hash; use lightning::chain; use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; use lightning::chain::keysinterface::{Recipient, NodeSigner, SignerProvider, EntropySource}; -use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; -use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, PaymentSendFailure, MIN_FINAL_CLTV_EXPIRY}; -#[cfg(feature = "std")] +use lightning::ln::{PaymentHash, PaymentSecret}; +use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, MIN_FINAL_CLTV_EXPIRY_DELTA}; use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA}; use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey}; use lightning::routing::gossip::RoutingFees; -use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, Router}; +use lightning::routing::router::{RouteHint, RouteHintHop, Router}; use lightning::util::logger::Logger; use secp256k1::PublicKey; use core::ops::Deref; use core::time::Duration; -#[cfg(feature = "std")] /// Utility to create an invoice that can be paid to one of multiple nodes, or a "phantom invoice." /// See [`PhantomKeysManager`] for more information on phantom node payments. /// @@ -42,6 +39,13 @@ use core::time::Duration; /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for /// in excess of the current time. /// +/// `duration_since_epoch` is the current time since epoch in seconds. +/// +/// You can specify a custom `min_final_cltv_expiry_delta`, or let LDK default it to +/// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]. The provided expiry must be at least [`MIN_FINAL_CLTV_EXPIRY_DELTA`] - 3. +/// Note that LDK will add a buffer of 3 blocks to the delta to allow for up to a few new block +/// confirmations during routing. +/// /// Note that the provided `keys_manager`'s `NodeSigner` implementation must support phantom /// invoices in its `sign_invoice` implementation ([`PhantomKeysManager`] satisfies this /// requirement). @@ -51,10 +55,14 @@ use core::time::Duration; /// [`ChannelManager::create_inbound_payment`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment /// [`ChannelManager::create_inbound_payment_for_hash`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash /// [`PhantomRouteHints::channels`]: lightning::ln::channelmanager::PhantomRouteHints::channels +/// [`MIN_FINAL_CLTV_EXPIRY_DETLA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA +/// +/// This can be used in a `no_std` environment, where [`std::time::SystemTime`] is not +/// available and the current time is supplied by the caller. pub fn create_phantom_invoice( amt_msat: Option, payment_hash: Option, description: String, invoice_expiry_delta_secs: u32, phantom_route_hints: Vec, entropy_source: ES, - node_signer: NS, logger: L, network: Currency, + node_signer: NS, logger: L, network: Currency, min_final_cltv_expiry_delta: Option, duration_since_epoch: Duration, ) -> Result> where ES::Target: EntropySource, @@ -65,11 +73,10 @@ where let description = InvoiceDescription::Direct(&description,); _create_phantom_invoice::( amt_msat, payment_hash, description, invoice_expiry_delta_secs, phantom_route_hints, - entropy_source, node_signer, logger, network, + entropy_source, node_signer, logger, network, min_final_cltv_expiry_delta, duration_since_epoch, ) } -#[cfg(feature = "std")] /// Utility to create an invoice that can be paid to one of multiple nodes, or a "phantom invoice." /// See [`PhantomKeysManager`] for more information on phantom node payments. /// @@ -92,6 +99,8 @@ where /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for /// in excess of the current time. /// +/// `duration_since_epoch` is the current time since epoch in seconds. +/// /// Note that the provided `keys_manager`'s `NodeSigner` implementation must support phantom /// invoices in its `sign_invoice` implementation ([`PhantomKeysManager`] satisfies this /// requirement). @@ -101,10 +110,13 @@ where /// [`ChannelManager::create_inbound_payment`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment /// [`ChannelManager::create_inbound_payment_for_hash`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash /// [`PhantomRouteHints::channels`]: lightning::ln::channelmanager::PhantomRouteHints::channels +/// +/// This can be used in a `no_std` environment, where [`std::time::SystemTime`] is not +/// available and the current time is supplied by the caller. pub fn create_phantom_invoice_with_description_hash( amt_msat: Option, payment_hash: Option, invoice_expiry_delta_secs: u32, description_hash: Sha256, phantom_route_hints: Vec, entropy_source: ES, - node_signer: NS, logger: L, network: Currency + node_signer: NS, logger: L, network: Currency, min_final_cltv_expiry_delta: Option, duration_since_epoch: Duration, ) -> Result> where ES::Target: EntropySource, @@ -114,28 +126,31 @@ where _create_phantom_invoice::( amt_msat, payment_hash, InvoiceDescription::Hash(&description_hash), invoice_expiry_delta_secs, phantom_route_hints, entropy_source, node_signer, logger, network, + min_final_cltv_expiry_delta, duration_since_epoch, ) } -#[cfg(feature = "std")] fn _create_phantom_invoice( amt_msat: Option, payment_hash: Option, description: InvoiceDescription, invoice_expiry_delta_secs: u32, phantom_route_hints: Vec, entropy_source: ES, - node_signer: NS, logger: L, network: Currency, + node_signer: NS, logger: L, network: Currency, min_final_cltv_expiry_delta: Option, duration_since_epoch: Duration, ) -> Result> where ES::Target: EntropySource, NS::Target: NodeSigner, L::Target: Logger, { - use std::time::{SystemTime, UNIX_EPOCH}; - if phantom_route_hints.len() == 0 { + if phantom_route_hints.is_empty() { return Err(SignOrCreationError::CreationError( CreationError::MissingRouteHints, )); } + if min_final_cltv_expiry_delta.is_some() && min_final_cltv_expiry_delta.unwrap().saturating_add(3) < MIN_FINAL_CLTV_EXPIRY_DELTA { + return Err(SignOrCreationError::CreationError(CreationError::MinFinalCltvExpiryDeltaTooShort)); + } + let invoice = match description { InvoiceDescription::Direct(description) => { InvoiceBuilder::new(network).description(description.0.clone()) @@ -151,10 +166,9 @@ where amt_msat, payment_hash, invoice_expiry_delta_secs, - SystemTime::now() - .duration_since(UNIX_EPOCH) - .expect("Time must be > 1970") + duration_since_epoch .as_secs(), + min_final_cltv_expiry_delta, ) .map_err(|_| SignOrCreationError::CreationError(CreationError::InvalidAmount))?; (payment_hash, payment_secret) @@ -164,10 +178,9 @@ where amt_msat, invoice_expiry_delta_secs, &entropy_source, - SystemTime::now() - .duration_since(UNIX_EPOCH) - .expect("Time must be > 1970") + duration_since_epoch .as_secs(), + min_final_cltv_expiry_delta, ) .map_err(|_| SignOrCreationError::CreationError(CreationError::InvalidAmount))? }; @@ -176,10 +189,12 @@ where phantom_route_hints.len(), log_bytes!(payment_hash.0)); let mut invoice = invoice - .current_timestamp() + .duration_since_epoch(duration_since_epoch) .payment_hash(Hash::from_slice(&payment_hash.0).unwrap()) .payment_secret(payment_secret) - .min_final_cltv_expiry(MIN_FINAL_CLTV_EXPIRY.into()) + .min_final_cltv_expiry_delta( + // Add a buffer of 3 to the delta if present, otherwise use LDK's minimum. + min_final_cltv_expiry_delta.map(|x| x.saturating_add(3)).unwrap_or(MIN_FINAL_CLTV_EXPIRY_DELTA).into()) .expiry_time(Duration::from_secs(invoice_expiry_delta_secs.into())); if let Some(amt) = amt_msat { invoice = invoice.amount_milli_satoshis(amt); @@ -235,9 +250,17 @@ where /// /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for /// in excess of the current time. +/// +/// You can specify a custom `min_final_cltv_expiry_delta`, or let LDK default it to +/// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]. The provided expiry must be at least [`MIN_FINAL_CLTV_EXPIRY_DELTA`]. +/// Note that LDK will add a buffer of 3 blocks to the delta to allow for up to a few new block +/// confirmations during routing. +/// +/// [`MIN_FINAL_CLTV_EXPIRY_DETLA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA pub fn create_invoice_from_channelmanager( channelmanager: &ChannelManager, node_signer: NS, logger: L, - network: Currency, amt_msat: Option, description: String, invoice_expiry_delta_secs: u32 + network: Currency, amt_msat: Option, description: String, invoice_expiry_delta_secs: u32, + min_final_cltv_expiry_delta: Option, ) -> Result> where M::Target: chain::Watch<::Signer>, @@ -254,7 +277,7 @@ where .expect("for the foreseeable future this shouldn't happen"); create_invoice_from_channelmanager_and_duration_since_epoch( channelmanager, node_signer, logger, network, amt_msat, - description, duration, invoice_expiry_delta_secs + description, duration, invoice_expiry_delta_secs, min_final_cltv_expiry_delta, ) } @@ -268,10 +291,17 @@ where /// /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for /// in excess of the current time. +/// +/// You can specify a custom `min_final_cltv_expiry_delta`, or let LDK default it to +/// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]. The provided expiry must be at least [`MIN_FINAL_CLTV_EXPIRY_DELTA`]. +/// Note that LDK will add a buffer of 3 blocks to the delta to allow for up to a few new block +/// confirmations during routing. +/// +/// [`MIN_FINAL_CLTV_EXPIRY_DETLA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA pub fn create_invoice_from_channelmanager_with_description_hash( channelmanager: &ChannelManager, node_signer: NS, logger: L, network: Currency, amt_msat: Option, description_hash: Sha256, - invoice_expiry_delta_secs: u32 + invoice_expiry_delta_secs: u32, min_final_cltv_expiry_delta: Option, ) -> Result> where M::Target: chain::Watch<::Signer>, @@ -291,7 +321,7 @@ where create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch( channelmanager, node_signer, logger, network, amt_msat, - description_hash, duration, invoice_expiry_delta_secs + description_hash, duration, invoice_expiry_delta_secs, min_final_cltv_expiry_delta, ) } @@ -301,7 +331,7 @@ where pub fn create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch( channelmanager: &ChannelManager, node_signer: NS, logger: L, network: Currency, amt_msat: Option, description_hash: Sha256, - duration_since_epoch: Duration, invoice_expiry_delta_secs: u32 + duration_since_epoch: Duration, invoice_expiry_delta_secs: u32, min_final_cltv_expiry_delta: Option, ) -> Result> where M::Target: chain::Watch<::Signer>, @@ -316,7 +346,7 @@ pub fn create_invoice_from_channelmanager_with_description_hash_and_duration_sin _create_invoice_from_channelmanager_and_duration_since_epoch( channelmanager, node_signer, logger, network, amt_msat, InvoiceDescription::Hash(&description_hash), - duration_since_epoch, invoice_expiry_delta_secs + duration_since_epoch, invoice_expiry_delta_secs, min_final_cltv_expiry_delta, ) } @@ -326,7 +356,7 @@ pub fn create_invoice_from_channelmanager_with_description_hash_and_duration_sin pub fn create_invoice_from_channelmanager_and_duration_since_epoch( channelmanager: &ChannelManager, node_signer: NS, logger: L, network: Currency, amt_msat: Option, description: String, duration_since_epoch: Duration, - invoice_expiry_delta_secs: u32 + invoice_expiry_delta_secs: u32, min_final_cltv_expiry_delta: Option, ) -> Result> where M::Target: chain::Watch<::Signer>, @@ -343,14 +373,14 @@ pub fn create_invoice_from_channelmanager_and_duration_since_epoch( channelmanager: &ChannelManager, node_signer: NS, logger: L, network: Currency, amt_msat: Option, description: InvoiceDescription, - duration_since_epoch: Duration, invoice_expiry_delta_secs: u32 + duration_since_epoch: Duration, invoice_expiry_delta_secs: u32, min_final_cltv_expiry_delta: Option, ) -> Result> where M::Target: chain::Watch<::Signer>, @@ -362,13 +392,18 @@ fn _create_invoice_from_channelmanager_and_duration_since_epoch( channelmanager: &ChannelManager, node_signer: NS, logger: L, network: Currency, amt_msat: Option, description: String, duration_since_epoch: Duration, - invoice_expiry_delta_secs: u32, payment_hash: PaymentHash + invoice_expiry_delta_secs: u32, payment_hash: PaymentHash, min_final_cltv_expiry_delta: Option, ) -> Result> where M::Target: chain::Watch<::Signer>, @@ -391,21 +426,24 @@ pub fn create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_ L::Target: Logger, { let payment_secret = channelmanager - .create_inbound_payment_for_hash(payment_hash,amt_msat, invoice_expiry_delta_secs) + .create_inbound_payment_for_hash(payment_hash, amt_msat, invoice_expiry_delta_secs, + min_final_cltv_expiry_delta) .map_err(|()| SignOrCreationError::CreationError(CreationError::InvalidAmount))?; _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash( channelmanager, node_signer, logger, network, amt_msat, InvoiceDescription::Direct( &Description::new(description).map_err(SignOrCreationError::CreationError)?, ), - duration_since_epoch, invoice_expiry_delta_secs, payment_hash, payment_secret + duration_since_epoch, invoice_expiry_delta_secs, payment_hash, payment_secret, + min_final_cltv_expiry_delta, ) } fn _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash( channelmanager: &ChannelManager, node_signer: NS, logger: L, network: Currency, amt_msat: Option, description: InvoiceDescription, duration_since_epoch: Duration, - invoice_expiry_delta_secs: u32, payment_hash: PaymentHash, payment_secret: PaymentSecret + invoice_expiry_delta_secs: u32, payment_hash: PaymentHash, payment_secret: PaymentSecret, + min_final_cltv_expiry_delta: Option, ) -> Result> where M::Target: chain::Watch<::Signer>, @@ -420,6 +458,10 @@ fn _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_has let our_node_pubkey = channelmanager.get_our_node_id(); let channels = channelmanager.list_channels(); + if min_final_cltv_expiry_delta.is_some() && min_final_cltv_expiry_delta.unwrap().saturating_add(3) < MIN_FINAL_CLTV_EXPIRY_DELTA { + return Err(SignOrCreationError::CreationError(CreationError::MinFinalCltvExpiryDeltaTooShort)); + } + log_trace!(logger, "Creating invoice with payment hash {}", log_bytes!(payment_hash.0)); let invoice = match description { @@ -435,7 +477,9 @@ fn _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_has .payment_hash(Hash::from_slice(&payment_hash.0).unwrap()) .payment_secret(payment_secret) .basic_mpp() - .min_final_cltv_expiry(MIN_FINAL_CLTV_EXPIRY.into()) + .min_final_cltv_expiry_delta( + // Add a buffer of 3 to the delta if present, otherwise use LDK's minimum. + min_final_cltv_expiry_delta.map(|x| x.saturating_add(3)).unwrap_or(MIN_FINAL_CLTV_EXPIRY_DELTA).into()) .expiry_time(Duration::from_secs(invoice_expiry_delta_secs.into())); if let Some(amt) = amt_msat { invoice = invoice.amount_milli_satoshis(amt); @@ -465,11 +509,17 @@ fn _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_has /// /// The filtering is based on the following criteria: /// * Only one channel per counterparty node -/// * Always select the channel with the highest inbound capacity per counterparty node +/// * If the counterparty has a channel that is above the `min_inbound_capacity_msat` + 10% scaling +/// factor (to allow some margin for change in inbound), select the channel with the lowest +/// inbound capacity that is above this threshold. +/// * If no `min_inbound_capacity_msat` is specified, or the counterparty has no channels above the +/// minimum + 10% scaling factor, select the channel with the highest inbound capacity per counterparty. /// * Prefer channels with capacity at least `min_inbound_capacity_msat` and where the channel /// `is_usable` (i.e. the peer is connected). -/// * If any public channel exists, the returned `RouteHint`s will be empty, and the sender will -/// need to find the path by looking at the public channels instead +/// * If any public channel exists, only public [`RouteHint`]s will be returned. +/// * If any public, announced, channel exists (i.e. a channel with 7+ confs, to ensure the +/// announcement has had a chance to propagate), no [`RouteHint`]s will be returned, as the +/// sender is expected to find the path by looking at the public channels instead. fn filter_channels( channels: Vec, min_inbound_capacity_msat: Option, logger: &L ) -> Vec where L::Target: Logger { @@ -478,6 +528,7 @@ fn filter_channels( let mut min_capacity_channel_exists = false; let mut online_channel_exists = false; let mut online_min_capacity_channel_exists = false; + let mut has_pub_unconf_chan = false; log_trace!(logger, "Considering {} channels for invoice route hints", channels.len()); for channel in channels.into_iter().filter(|chan| chan.is_channel_ready) { @@ -487,11 +538,18 @@ fn filter_channels( } if channel.is_public { - // If any public channel exists, return no hints and let the sender - // look at the public channels instead. - log_trace!(logger, "Not including channels in invoice route hints on account of public channel {}", - log_bytes!(channel.channel_id)); - return vec![] + if channel.confirmations.is_some() && channel.confirmations < Some(7) { + // If we have a public channel, but it doesn't have enough confirmations to (yet) + // be in the public network graph (and have gotten a chance to propagate), include + // route hints but only for public channels to protect private channel privacy. + has_pub_unconf_chan = true; + } else { + // If any public channel exists, return no hints and let the sender + // look at the public channels instead. + log_trace!(logger, "Not including channels in invoice route hints on account of public channel {}", + log_bytes!(channel.channel_id)); + return vec![] + } } if channel.inbound_capacity_msat >= min_inbound_capacity { @@ -505,30 +563,44 @@ fn filter_channels( } } - if channel.is_usable { - if !online_channel_exists { - log_trace!(logger, "Channel with connected peer exists for invoice route hints"); - online_channel_exists = true; - } + if channel.is_usable && !online_channel_exists { + log_trace!(logger, "Channel with connected peer exists for invoice route hints"); + online_channel_exists = true; } match filtered_channels.entry(channel.counterparty.node_id) { hash_map::Entry::Occupied(mut entry) => { let current_max_capacity = entry.get().inbound_capacity_msat; - if channel.inbound_capacity_msat < current_max_capacity { + // If this channel is public and the previous channel is not, ensure we replace the + // previous channel to avoid announcing non-public channels. + let new_now_public = channel.is_public && !entry.get().is_public; + // Decide whether we prefer the currently selected channel with the node to the new one, + // based on their inbound capacity. + let prefer_current = prefer_current_channel(min_inbound_capacity_msat, current_max_capacity, + channel.inbound_capacity_msat); + // If the public-ness of the channel has not changed (in which case simply defer to + // `new_now_public), and this channel has more desirable inbound than the incumbent, + // prefer to include this channel. + let new_channel_preferable = channel.is_public == entry.get().is_public && !prefer_current; + + if new_now_public || new_channel_preferable { log_trace!(logger, - "Preferring counterparty {} channel {} ({} msats) over {} ({} msats) for invoice route hints", + "Preferring counterparty {} channel {} (SCID {:?}, {} msats) over {} (SCID {:?}, {} msats) for invoice route hints", log_pubkey!(channel.counterparty.node_id), - log_bytes!(entry.get().channel_id), current_max_capacity, - log_bytes!(channel.channel_id), channel.inbound_capacity_msat); - continue; + log_bytes!(channel.channel_id), channel.short_channel_id, + channel.inbound_capacity_msat, + log_bytes!(entry.get().channel_id), entry.get().short_channel_id, + current_max_capacity); + entry.insert(channel); + } else { + log_trace!(logger, + "Preferring counterparty {} channel {} (SCID {:?}, {} msats) over {} (SCID {:?}, {} msats) for invoice route hints", + log_pubkey!(channel.counterparty.node_id), + log_bytes!(entry.get().channel_id), entry.get().short_channel_id, + current_max_capacity, + log_bytes!(channel.channel_id), channel.short_channel_id, + channel.inbound_capacity_msat); } - log_trace!(logger, - "Preferring counterparty {} channel {} ({} msats) over {} ({} msats) for invoice route hints", - log_pubkey!(channel.counterparty.node_id), - log_bytes!(channel.channel_id), channel.inbound_capacity_msat, - log_bytes!(entry.get().channel_id), current_max_capacity); - entry.insert(channel); } hash_map::Entry::Vacant(entry) => { entry.insert(channel); @@ -558,7 +630,12 @@ fn filter_channels( .map(|(_, channel)| channel) .filter(|channel| { let has_enough_capacity = channel.inbound_capacity_msat >= min_inbound_capacity; - let include_channel = if online_min_capacity_channel_exists { + let include_channel = if has_pub_unconf_chan { + // If we have a public channel, but it doesn't have enough confirmations to (yet) + // be in the public network graph (and have gotten a chance to propagate), include + // route hints but only for public channels to protect private channel privacy. + channel.is_public + } else if online_min_capacity_channel_exists { has_enough_capacity && channel.is_usable } else if min_capacity_channel_exists && online_channel_exists { // If there are some online channels and some min_capacity channels, but no @@ -578,7 +655,7 @@ fn filter_channels( log_trace!(logger, "Ignoring channel {} without enough capacity for invoice route hints", log_bytes!(channel.channel_id)); } else { - debug_assert!(!channel.is_usable); + debug_assert!(!channel.is_usable || (has_pub_unconf_chan && !channel.is_public)); log_trace!(logger, "Ignoring channel {} with disconnected peer", log_bytes!(channel.channel_id)); } @@ -589,69 +666,87 @@ fn filter_channels( .collect::>() } -impl Payer for ChannelManager -where - M::Target: chain::Watch<::Signer>, - T::Target: BroadcasterInterface, - ES::Target: EntropySource, - NS::Target: NodeSigner, - SP::Target: SignerProvider, - F::Target: FeeEstimator, - R::Target: Router, - L::Target: Logger, -{ - fn node_id(&self) -> PublicKey { - self.get_our_node_id() - } - - fn first_hops(&self) -> Vec { - self.list_usable_channels() - } - - fn send_payment( - &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option, - payment_id: PaymentId - ) -> Result<(), PaymentSendFailure> { - self.send_payment(route, payment_hash, payment_secret, payment_id) +/// prefer_current_channel chooses a channel to use for route hints between a currently selected and candidate +/// channel based on the inbound capacity of each channel and the minimum inbound capacity requested for the hints, +/// returning true if the current channel should be preferred over the candidate channel. +/// * If no minimum amount is requested, the channel with the most inbound is chosen to maximize the chances that a +/// payment of any size will succeed. +/// * If we have channels with inbound above our minimum requested inbound (plus a 10% scaling factor, expressed as a +/// percentage) then we choose the lowest inbound channel with above this amount. If we have sufficient inbound +/// channels, we don't want to deplete our larger channels with small payments (the off-chain version of "grinding +/// our change"). +/// * If no channel above our minimum amount exists, then we just prefer the channel with the most inbound to give +/// payments the best chance of succeeding in multiple parts. +fn prefer_current_channel(min_inbound_capacity_msat: Option, current_channel: u64, + candidate_channel: u64) -> bool { + + // If no min amount is given for the hints, err of the side of caution and choose the largest channel inbound to + // maximize chances of any payment succeeding. + if min_inbound_capacity_msat.is_none() { + return current_channel > candidate_channel } - fn send_spontaneous_payment( - &self, route: &Route, payment_preimage: PaymentPreimage, payment_id: PaymentId, - ) -> Result<(), PaymentSendFailure> { - self.send_spontaneous_payment(route, Some(payment_preimage), payment_id).map(|_| ()) - } - - fn retry_payment( - &self, route: &Route, payment_id: PaymentId - ) -> Result<(), PaymentSendFailure> { - self.retry_payment(route, payment_id) - } + let scaled_min_inbound = min_inbound_capacity_msat.unwrap() * 110; + let current_sufficient = current_channel * 100 >= scaled_min_inbound; + let candidate_sufficient = candidate_channel * 100 >= scaled_min_inbound; - fn abandon_payment(&self, payment_id: PaymentId) { - self.abandon_payment(payment_id) + if current_sufficient && candidate_sufficient { + return current_channel < candidate_channel + } else if current_sufficient { + return true + } else if candidate_sufficient { + return false } - fn inflight_htlcs(&self) -> InFlightHtlcs { self.compute_inflight_htlcs() } + current_channel > candidate_channel } #[cfg(test)] mod test { use core::time::Duration; - use crate::{Currency, Description, InvoiceDescription}; + use crate::{Currency, Description, InvoiceDescription, SignOrCreationError, CreationError}; use bitcoin_hashes::{Hash, sha256}; use bitcoin_hashes::sha256::Hash as Sha256; use lightning::chain::keysinterface::{EntropySource, PhantomKeysManager}; + use lightning::events::{MessageSendEvent, MessageSendEventsProvider, Event}; use lightning::ln::{PaymentPreimage, PaymentHash}; - use lightning::ln::channelmanager::{PhantomRouteHints, MIN_FINAL_CLTV_EXPIRY, PaymentId}; + use lightning::ln::channelmanager::{PhantomRouteHints, MIN_FINAL_CLTV_EXPIRY_DELTA, PaymentId}; use lightning::ln::functional_test_utils::*; use lightning::ln::msgs::ChannelMessageHandler; use lightning::routing::router::{PaymentParameters, RouteParameters, find_route}; - use lightning::util::events::{MessageSendEvent, MessageSendEventsProvider, Event}; use lightning::util::test_utils; use lightning::util::config::UserConfig; use crate::utils::create_invoice_from_channelmanager_and_duration_since_epoch; use std::collections::HashSet; + #[test] + fn test_prefer_current_channel() { + // No minimum, prefer larger candidate channel. + assert_eq!(crate::utils::prefer_current_channel(None, 100, 200), false); + + // No minimum, prefer larger current channel. + assert_eq!(crate::utils::prefer_current_channel(None, 200, 100), true); + + // Minimum set, prefer current channel over minimum + buffer. + assert_eq!(crate::utils::prefer_current_channel(Some(100), 115, 100), true); + + // Minimum set, prefer candidate channel over minimum + buffer. + assert_eq!(crate::utils::prefer_current_channel(Some(100), 105, 125), false); + + // Minimum set, both channels sufficient, prefer smaller current channel. + assert_eq!(crate::utils::prefer_current_channel(Some(100), 115, 125), true); + + // Minimum set, both channels sufficient, prefer smaller candidate channel. + assert_eq!(crate::utils::prefer_current_channel(Some(100), 200, 160), false); + + // Minimum set, neither sufficient, prefer larger current channel. + assert_eq!(crate::utils::prefer_current_channel(Some(200), 100, 50), true); + + // Minimum set, neither sufficient, prefer larger candidate channel. + assert_eq!(crate::utils::prefer_current_channel(Some(200), 100, 150), false); + } + + #[test] fn test_from_channelmanager() { let chanmon_cfgs = create_chanmon_cfgs(2); @@ -661,11 +756,12 @@ mod test { create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001); let non_default_invoice_expiry_secs = 4200; let invoice = create_invoice_from_channelmanager_and_duration_since_epoch( - &nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::BitcoinTestnet, + nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::BitcoinTestnet, Some(10_000), "test".to_string(), Duration::from_secs(1234567), - non_default_invoice_expiry_secs).unwrap(); + non_default_invoice_expiry_secs, None).unwrap(); assert_eq!(invoice.amount_pico_btc(), Some(100_000)); - assert_eq!(invoice.min_final_cltv_expiry(), MIN_FINAL_CLTV_EXPIRY as u64); + // If no `min_final_cltv_expiry_delta` is specified, then it should be `MIN_FINAL_CLTV_EXPIRY_DELTA`. + assert_eq!(invoice.min_final_cltv_expiry_delta(), MIN_FINAL_CLTV_EXPIRY_DELTA as u64); assert_eq!(invoice.description(), InvoiceDescription::Direct(&Description("test".to_string()))); assert_eq!(invoice.expiry_time(), Duration::from_secs(non_default_invoice_expiry_secs.into())); @@ -679,28 +775,28 @@ mod test { assert_eq!(invoice.route_hints()[0].0[0].htlc_minimum_msat, chan.inbound_htlc_minimum_msat); assert_eq!(invoice.route_hints()[0].0[0].htlc_maximum_msat, chan.inbound_htlc_maximum_msat); - let payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key()) + let payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key(), + invoice.min_final_cltv_expiry_delta() as u32) .with_features(invoice.features().unwrap().clone()) .with_route_hints(invoice.route_hints()); let route_params = RouteParameters { payment_params, final_value_msat: invoice.amount_milli_satoshis().unwrap(), - final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32, }; let first_hops = nodes[0].node.list_usable_channels(); let network_graph = &node_cfgs[0].network_graph; let logger = test_utils::TestLogger::new(); - let scorer = test_utils::TestScorer::with_penalty(0); + let scorer = test_utils::TestScorer::new(); let random_seed_bytes = chanmon_cfgs[1].keys_manager.get_secure_random_bytes(); let route = find_route( - &nodes[0].node.get_our_node_id(), &route_params, &network_graph, + &nodes[0].node.get_our_node_id(), &route_params, network_graph, Some(&first_hops.iter().collect::>()), &logger, &scorer, &random_seed_bytes ).unwrap(); let payment_event = { let mut payment_hash = PaymentHash([0; 32]); payment_hash.0.copy_from_slice(&invoice.payment_hash().as_ref()[0..32]); - nodes[0].node.send_payment(&route, payment_hash, &Some(invoice.payment_secret().clone()), PaymentId(payment_hash.0)).unwrap(); + nodes[0].node.send_payment(&route, payment_hash, &Some(*invoice.payment_secret()), PaymentId(payment_hash.0)).unwrap(); let mut added_monitors = nodes[0].chain_monitor.added_monitors.lock().unwrap(); assert_eq!(added_monitors.len(), 1); added_monitors.clear(); @@ -719,6 +815,44 @@ mod test { assert_eq!(events.len(), 2); } + fn do_create_invoice_min_final_cltv_delta(with_custom_delta: bool) { + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let custom_min_final_cltv_expiry_delta = Some(50); + + let invoice = crate::utils::create_invoice_from_channelmanager_and_duration_since_epoch( + nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::BitcoinTestnet, + Some(10_000), "".into(), Duration::from_secs(1234567), 3600, + if with_custom_delta { custom_min_final_cltv_expiry_delta } else { None }, + ).unwrap(); + assert_eq!(invoice.min_final_cltv_expiry_delta(), if with_custom_delta { + custom_min_final_cltv_expiry_delta.unwrap() + 3 /* Buffer */} else { MIN_FINAL_CLTV_EXPIRY_DELTA } as u64); + } + + #[test] + fn test_create_invoice_custom_min_final_cltv_delta() { + do_create_invoice_min_final_cltv_delta(true); + do_create_invoice_min_final_cltv_delta(false); + } + + #[test] + fn create_invoice_min_final_cltv_delta_equals_htlc_fail_buffer() { + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let custom_min_final_cltv_expiry_delta = Some(21); + + let invoice = crate::utils::create_invoice_from_channelmanager_and_duration_since_epoch( + nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::BitcoinTestnet, + Some(10_000), "".into(), Duration::from_secs(1234567), 3600, + custom_min_final_cltv_expiry_delta, + ).unwrap(); + assert_eq!(invoice.min_final_cltv_expiry_delta(), MIN_FINAL_CLTV_EXPIRY_DELTA as u64); + } + #[test] fn test_create_invoice_with_description_hash() { let chanmon_cfgs = create_chanmon_cfgs(2); @@ -727,11 +861,11 @@ mod test { let nodes = create_network(2, &node_cfgs, &node_chanmgrs); let description_hash = crate::Sha256(Hash::hash("Testing description_hash".as_bytes())); let invoice = crate::utils::create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch( - &nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::BitcoinTestnet, - Some(10_000), description_hash, Duration::from_secs(1234567), 3600 + nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::BitcoinTestnet, + Some(10_000), description_hash, Duration::from_secs(1234567), 3600, None, ).unwrap(); assert_eq!(invoice.amount_pico_btc(), Some(100_000)); - assert_eq!(invoice.min_final_cltv_expiry(), MIN_FINAL_CLTV_EXPIRY as u64); + assert_eq!(invoice.min_final_cltv_expiry_delta(), MIN_FINAL_CLTV_EXPIRY_DELTA as u64); assert_eq!(invoice.description(), InvoiceDescription::Hash(&crate::Sha256(Sha256::hash("Testing description_hash".as_bytes())))); } @@ -743,16 +877,73 @@ mod test { let nodes = create_network(2, &node_cfgs, &node_chanmgrs); let payment_hash = PaymentHash([0; 32]); let invoice = crate::utils::create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash( - &nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::BitcoinTestnet, + nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::BitcoinTestnet, Some(10_000), "test".to_string(), Duration::from_secs(1234567), 3600, - payment_hash + payment_hash, None, ).unwrap(); assert_eq!(invoice.amount_pico_btc(), Some(100_000)); - assert_eq!(invoice.min_final_cltv_expiry(), MIN_FINAL_CLTV_EXPIRY as u64); + assert_eq!(invoice.min_final_cltv_expiry_delta(), MIN_FINAL_CLTV_EXPIRY_DELTA as u64); assert_eq!(invoice.description(), InvoiceDescription::Direct(&Description("test".to_string()))); assert_eq!(invoice.payment_hash(), &sha256::Hash::from_slice(&payment_hash.0[..]).unwrap()); } + #[test] + fn test_hints_has_only_public_confd_channels() { + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let mut config = test_default_channel_config(); + config.channel_handshake_config.minimum_depth = 1; + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(config), Some(config)]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + + // Create a private channel with lots of capacity and a lower value public channel (without + // confirming the funding tx yet). + let unannounced_scid = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0); + let conf_tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 10_000, 0); + + // Before the channel is available, we should include the unannounced_scid. + let mut scid_aliases = HashSet::new(); + scid_aliases.insert(unannounced_scid.0.short_channel_id_alias.unwrap()); + match_invoice_routes(Some(5000), &nodes[1], scid_aliases.clone()); + + // However after we mine the funding tx and exchange channel_ready messages for the public + // channel we'll immediately switch to including it as a route hint, even though it isn't + // yet announced. + let pub_channel_scid = mine_transaction(&nodes[0], &conf_tx); + let node_a_pub_channel_ready = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id()); + nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &node_a_pub_channel_ready); + + assert_eq!(mine_transaction(&nodes[1], &conf_tx), pub_channel_scid); + let events = nodes[1].node.get_and_clear_pending_msg_events(); + assert_eq!(events.len(), 2); + if let MessageSendEvent::SendChannelReady { msg, .. } = &events[0] { + nodes[0].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), msg); + } else { panic!(); } + if let MessageSendEvent::SendChannelUpdate { msg, .. } = &events[1] { + nodes[0].node.handle_channel_update(&nodes[1].node.get_our_node_id(), msg); + } else { panic!(); } + + nodes[1].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id())); + + expect_channel_ready_event(&nodes[0], &nodes[1].node.get_our_node_id()); + expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); + + scid_aliases.clear(); + scid_aliases.insert(node_a_pub_channel_ready.short_channel_id_alias.unwrap()); + match_invoice_routes(Some(5000), &nodes[1], scid_aliases.clone()); + // This also applies even if the amount is more than the payment amount, to ensure users + // dont screw up their privacy. + match_invoice_routes(Some(50_000_000), &nodes[1], scid_aliases.clone()); + + // The same remains true until the channel has 7 confirmations, at which point we include + // no hints. + connect_blocks(&nodes[1], 5); + match_invoice_routes(Some(5000), &nodes[1], scid_aliases.clone()); + connect_blocks(&nodes[1], 1); + get_event_msg!(nodes[1], MessageSendEvent::SendAnnouncementSignatures, nodes[0].node.get_our_node_id()); + match_invoice_routes(Some(5000), &nodes[1], HashSet::new()); + } + #[test] fn test_hints_includes_single_channels_to_nodes() { let chanmon_cfgs = create_chanmon_cfgs(3); @@ -771,17 +962,19 @@ mod test { } #[test] - fn test_hints_has_only_highest_inbound_capacity_channel() { + fn test_hints_has_only_lowest_inbound_capacity_channel_above_minimum() { let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let _chan_1_0_low_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100_000, 0); - let chan_1_0_high_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 10_000_000, 0); - let _chan_1_0_medium_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 1_000_000, 0); + + let _chan_1_0_inbound_below_amt = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 10_000, 0); + let _chan_1_0_large_inbound_above_amt = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 500_000, 0); + let chan_1_0_low_inbound_above_amt = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 200_000, 0); + let mut scid_aliases = HashSet::new(); - scid_aliases.insert(chan_1_0_high_inbound_capacity.0.short_channel_id_alias.unwrap()); - match_invoice_routes(Some(5000), &nodes[0], scid_aliases); + scid_aliases.insert(chan_1_0_low_inbound_above_amt.0.short_channel_id_alias.unwrap()); + match_invoice_routes(Some(100_000_000), &nodes[0], scid_aliases); } #[test] @@ -803,13 +996,13 @@ mod test { // With only one sufficient-value peer connected we should only get its hint scid_aliases.remove(&chan_b.0.short_channel_id_alias.unwrap()); - nodes[0].node.peer_disconnected(&nodes[2].node.get_our_node_id(), false); + nodes[0].node.peer_disconnected(&nodes[2].node.get_our_node_id()); match_invoice_routes(Some(1_000_000_000), &nodes[0], scid_aliases.clone()); // If we don't have any sufficient-value peers connected we should get all hints with // sufficient value, even though there is a connected insufficient-value peer. scid_aliases.insert(chan_b.0.short_channel_id_alias.unwrap()); - nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false); + nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id()); match_invoice_routes(Some(1_000_000_000), &nodes[0], scid_aliases); } @@ -828,9 +1021,9 @@ mod test { private_chan_cfg.channel_handshake_config.announced_channel = false; let temporary_channel_id = nodes[2].node.create_channel(nodes[0].node.get_our_node_id(), 1_000_000, 500_000_000, 42, Some(private_chan_cfg)).unwrap(); let open_channel = get_event_msg!(nodes[2], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_open_channel(&nodes[2].node.get_our_node_id(), nodes[2].node.init_features(), &open_channel); + nodes[0].node.handle_open_channel(&nodes[2].node.get_our_node_id(), &open_channel); let accept_channel = get_event_msg!(nodes[0], MessageSendEvent::SendAcceptChannel, nodes[2].node.get_our_node_id()); - nodes[2].node.handle_accept_channel(&nodes[0].node.get_our_node_id(), nodes[0].node.init_features(), &accept_channel); + nodes[2].node.handle_accept_channel(&nodes[0].node.get_our_node_id(), &accept_channel); let tx = sign_funding_transaction(&nodes[2], &nodes[0], 1_000_000, temporary_channel_id); @@ -934,9 +1127,9 @@ mod test { mut chan_ids_to_match: HashSet ) { let invoice = create_invoice_from_channelmanager_and_duration_since_epoch( - &invoice_node.node, invoice_node.keys_manager, invoice_node.logger, + invoice_node.node, invoice_node.keys_manager, invoice_node.logger, Currency::BitcoinTestnet, invoice_amt, "test".to_string(), Duration::from_secs(1234567), - 3600).unwrap(); + 3600, None).unwrap(); let hints = invoice.private_routes(); for hint in hints { @@ -956,9 +1149,9 @@ mod test { #[cfg(feature = "std")] fn do_test_multi_node_receive(user_generated_pmt_hash: bool) { let mut chanmon_cfgs = create_chanmon_cfgs(3); - let seed_1 = [42 as u8; 32]; - let seed_2 = [43 as u8; 32]; - let cross_node_seed = [44 as u8; 32]; + let seed_1 = [42u8; 32]; + let seed_2 = [43u8; 32]; + let cross_node_seed = [44u8; 32]; chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed); chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed); let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); @@ -988,7 +1181,8 @@ mod test { let invoice = crate::utils::create_phantom_invoice::<&test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestLogger>( Some(payment_amt), payment_hash, "test".to_string(), non_default_invoice_expiry_secs, - route_hints, &nodes[1].keys_manager, &nodes[1].keys_manager, &nodes[1].logger, Currency::BitcoinTestnet + route_hints, nodes[1].keys_manager, nodes[1].keys_manager, nodes[1].logger, + Currency::BitcoinTestnet, None, Duration::from_secs(1234567) ).unwrap(); let (payment_hash, payment_secret) = (PaymentHash(invoice.payment_hash().into_inner()), *invoice.payment_secret()); let payment_preimage = if user_generated_pmt_hash { @@ -997,33 +1191,33 @@ mod test { nodes[1].node.get_payment_preimage(payment_hash, payment_secret).unwrap() }; - assert_eq!(invoice.min_final_cltv_expiry(), MIN_FINAL_CLTV_EXPIRY as u64); + assert_eq!(invoice.min_final_cltv_expiry_delta(), MIN_FINAL_CLTV_EXPIRY_DELTA as u64); assert_eq!(invoice.description(), InvoiceDescription::Direct(&Description("test".to_string()))); assert_eq!(invoice.route_hints().len(), 2); assert_eq!(invoice.expiry_time(), Duration::from_secs(non_default_invoice_expiry_secs.into())); assert!(!invoice.features().unwrap().supports_basic_mpp()); - let payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key()) + let payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key(), + invoice.min_final_cltv_expiry_delta() as u32) .with_features(invoice.features().unwrap().clone()) .with_route_hints(invoice.route_hints()); let params = RouteParameters { payment_params, final_value_msat: invoice.amount_milli_satoshis().unwrap(), - final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32, }; let first_hops = nodes[0].node.list_usable_channels(); let network_graph = &node_cfgs[0].network_graph; let logger = test_utils::TestLogger::new(); - let scorer = test_utils::TestScorer::with_penalty(0); + let scorer = test_utils::TestScorer::new(); let random_seed_bytes = chanmon_cfgs[1].keys_manager.get_secure_random_bytes(); let route = find_route( - &nodes[0].node.get_our_node_id(), ¶ms, &network_graph, + &nodes[0].node.get_our_node_id(), ¶ms, network_graph, Some(&first_hops.iter().collect::>()), &logger, &scorer, &random_seed_bytes ).unwrap(); let (payment_event, fwd_idx) = { let mut payment_hash = PaymentHash([0; 32]); payment_hash.0.copy_from_slice(&invoice.payment_hash().as_ref()[0..32]); - nodes[0].node.send_payment(&route, payment_hash, &Some(invoice.payment_secret().clone()), PaymentId(payment_hash.0)).unwrap(); + nodes[0].node.send_payment(&route, payment_hash, &Some(*invoice.payment_secret()), PaymentId(payment_hash.0)).unwrap(); let mut added_monitors = nodes[0].chain_monitor.added_monitors.lock().unwrap(); assert_eq!(added_monitors.len(), 1); added_monitors.clear(); @@ -1053,7 +1247,7 @@ mod test { let payment_preimage_opt = if user_generated_pmt_hash { None } else { Some(payment_preimage) }; expect_payment_claimable!(&nodes[fwd_idx], payment_hash, payment_secret, payment_amt, payment_preimage_opt, route.paths[0].last().unwrap().pubkey); - do_claim_payment_along_route(&nodes[0], &vec!(&vec!(&nodes[fwd_idx])[..]), false, payment_preimage); + do_claim_payment_along_route(&nodes[0], &[&vec!(&nodes[fwd_idx])[..]], false, payment_preimage); let events = nodes[0].node.get_and_clear_pending_events(); assert_eq!(events.len(), 2); match events[0] { @@ -1076,9 +1270,9 @@ mod test { #[cfg(feature = "std")] fn test_multi_node_hints_has_htlc_min_max_values() { let mut chanmon_cfgs = create_chanmon_cfgs(3); - let seed_1 = [42 as u8; 32]; - let seed_2 = [43 as u8; 32]; - let cross_node_seed = [44 as u8; 32]; + let seed_1 = [42u8; 32]; + let seed_2 = [43u8; 32]; + let cross_node_seed = [44u8; 32]; chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed); chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed); let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); @@ -1089,13 +1283,16 @@ mod test { create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001); let payment_amt = 20_000; - let (payment_hash, _payment_secret) = nodes[1].node.create_inbound_payment(Some(payment_amt), 3600).unwrap(); + let (payment_hash, _payment_secret) = nodes[1].node.create_inbound_payment(Some(payment_amt), 3600, None).unwrap(); let route_hints = vec![ nodes[1].node.get_phantom_route_hints(), nodes[2].node.get_phantom_route_hints(), ]; - let invoice = crate::utils::create_phantom_invoice::<&test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestLogger>(Some(payment_amt), Some(payment_hash), "test".to_string(), 3600, route_hints, &nodes[1].keys_manager, &nodes[1].keys_manager, &nodes[1].logger, Currency::BitcoinTestnet).unwrap(); + let invoice = crate::utils::create_phantom_invoice::<&test_utils::TestKeysInterface, + &test_utils::TestKeysInterface, &test_utils::TestLogger>(Some(payment_amt), Some(payment_hash), + "test".to_string(), 3600, route_hints, nodes[1].keys_manager, nodes[1].keys_manager, + nodes[1].logger, Currency::BitcoinTestnet, None, Duration::from_secs(1234567)).unwrap(); let chan_0_1 = &nodes[1].node.list_usable_channels()[0]; assert_eq!(invoice.route_hints()[0].0[0].htlc_minimum_msat, chan_0_1.inbound_htlc_minimum_msat); @@ -1126,22 +1323,50 @@ mod test { &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestLogger, >( Some(payment_amt), None, non_default_invoice_expiry_secs, description_hash, - route_hints, &nodes[1].keys_manager, &nodes[1].keys_manager, &nodes[1].logger, Currency::BitcoinTestnet + route_hints, nodes[1].keys_manager, nodes[1].keys_manager, nodes[1].logger, + Currency::BitcoinTestnet, None, Duration::from_secs(1234567), ) .unwrap(); assert_eq!(invoice.amount_pico_btc(), Some(200_000)); - assert_eq!(invoice.min_final_cltv_expiry(), MIN_FINAL_CLTV_EXPIRY as u64); + assert_eq!(invoice.min_final_cltv_expiry_delta(), MIN_FINAL_CLTV_EXPIRY_DELTA as u64); assert_eq!(invoice.expiry_time(), Duration::from_secs(non_default_invoice_expiry_secs.into())); assert_eq!(invoice.description(), InvoiceDescription::Hash(&crate::Sha256(Sha256::hash("Description hash phantom invoice".as_bytes())))); } + #[test] + #[cfg(feature = "std")] + fn create_phantom_invoice_with_custom_payment_hash_and_custom_min_final_cltv_delta() { + let chanmon_cfgs = create_chanmon_cfgs(3); + let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); + let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + + let payment_amt = 20_000; + let route_hints = vec![ + nodes[1].node.get_phantom_route_hints(), + nodes[2].node.get_phantom_route_hints(), + ]; + let user_payment_preimage = PaymentPreimage([1; 32]); + let payment_hash = Some(PaymentHash(Sha256::hash(&user_payment_preimage.0[..]).into_inner())); + let non_default_invoice_expiry_secs = 4200; + let min_final_cltv_expiry_delta = Some(100); + let duration_since_epoch = Duration::from_secs(1234567); + let invoice = crate::utils::create_phantom_invoice::<&test_utils::TestKeysInterface, + &test_utils::TestKeysInterface, &test_utils::TestLogger>(Some(payment_amt), payment_hash, + "".to_string(), non_default_invoice_expiry_secs, route_hints, nodes[1].keys_manager, nodes[1].keys_manager, + nodes[1].logger, Currency::BitcoinTestnet, min_final_cltv_expiry_delta, duration_since_epoch).unwrap(); + assert_eq!(invoice.amount_pico_btc(), Some(200_000)); + assert_eq!(invoice.min_final_cltv_expiry_delta(), (min_final_cltv_expiry_delta.unwrap() + 3) as u64); + assert_eq!(invoice.expiry_time(), Duration::from_secs(non_default_invoice_expiry_secs.into())); + } + #[test] #[cfg(feature = "std")] fn test_multi_node_hints_includes_single_channels_to_participating_nodes() { let mut chanmon_cfgs = create_chanmon_cfgs(3); - let seed_1 = [42 as u8; 32]; - let seed_2 = [43 as u8; 32]; - let cross_node_seed = [44 as u8; 32]; + let seed_1 = [42u8; 32]; + let seed_2 = [43u8; 32]; + let cross_node_seed = [44u8; 32]; chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed); chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed); let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); @@ -1168,9 +1393,9 @@ mod test { #[cfg(feature = "std")] fn test_multi_node_hints_includes_one_channel_of_each_counterparty_nodes_per_participating_node() { let mut chanmon_cfgs = create_chanmon_cfgs(4); - let seed_1 = [42 as u8; 32]; - let seed_2 = [43 as u8; 32]; - let cross_node_seed = [44 as u8; 32]; + let seed_1 = [42u8; 32]; + let seed_2 = [43u8; 32]; + let cross_node_seed = [44u8; 32]; chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed); chanmon_cfgs[3].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed); let node_cfgs = create_node_cfgs(4, &chanmon_cfgs); @@ -1199,9 +1424,9 @@ mod test { #[cfg(feature = "std")] fn test_multi_node_forwarding_info_not_assigned_channel_excluded_from_hints() { let mut chanmon_cfgs = create_chanmon_cfgs(4); - let seed_1 = [42 as u8; 32]; - let seed_2 = [43 as u8; 32]; - let cross_node_seed = [44 as u8; 32]; + let seed_1 = [42u8; 32]; + let seed_2 = [43u8; 32]; + let cross_node_seed = [44u8; 32]; chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed); chanmon_cfgs[3].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed); let node_cfgs = create_node_cfgs(4, &chanmon_cfgs); @@ -1218,9 +1443,9 @@ mod test { private_chan_cfg.channel_handshake_config.announced_channel = false; let temporary_channel_id = nodes[1].node.create_channel(nodes[3].node.get_our_node_id(), 1_000_000, 500_000_000, 42, Some(private_chan_cfg)).unwrap(); let open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[3].node.get_our_node_id()); - nodes[3].node.handle_open_channel(&nodes[1].node.get_our_node_id(), nodes[1].node.init_features(), &open_channel); + nodes[3].node.handle_open_channel(&nodes[1].node.get_our_node_id(), &open_channel); let accept_channel = get_event_msg!(nodes[3], MessageSendEvent::SendAcceptChannel, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_accept_channel(&nodes[3].node.get_our_node_id(), nodes[3].node.init_features(), &accept_channel); + nodes[1].node.handle_accept_channel(&nodes[3].node.get_our_node_id(), &accept_channel); let tx = sign_funding_transaction(&nodes[1], &nodes[3], 1_000_000, temporary_channel_id); @@ -1257,9 +1482,9 @@ mod test { #[cfg(feature = "std")] fn test_multi_node_with_only_public_channels_hints_includes_only_phantom_route() { let mut chanmon_cfgs = create_chanmon_cfgs(3); - let seed_1 = [42 as u8; 32]; - let seed_2 = [43 as u8; 32]; - let cross_node_seed = [44 as u8; 32]; + let seed_1 = [42u8; 32]; + let seed_2 = [43u8; 32]; + let cross_node_seed = [44u8; 32]; chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed); chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed); let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); @@ -1290,9 +1515,9 @@ mod test { #[cfg(feature = "std")] fn test_multi_node_with_mixed_public_and_private_channel_hints_includes_only_phantom_route() { let mut chanmon_cfgs = create_chanmon_cfgs(4); - let seed_1 = [42 as u8; 32]; - let seed_2 = [43 as u8; 32]; - let cross_node_seed = [44 as u8; 32]; + let seed_1 = [42u8; 32]; + let seed_2 = [43u8; 32]; + let cross_node_seed = [44u8; 32]; chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed); chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed); let node_cfgs = create_node_cfgs(4, &chanmon_cfgs); @@ -1322,28 +1547,28 @@ mod test { #[test] #[cfg(feature = "std")] - fn test_multi_node_hints_has_only_highest_inbound_capacity_channel() { + fn test_multi_node_hints_has_only_lowest_inbound_channel_above_minimum() { let mut chanmon_cfgs = create_chanmon_cfgs(3); - let seed_1 = [42 as u8; 32]; - let seed_2 = [43 as u8; 32]; - let cross_node_seed = [44 as u8; 32]; + let seed_1 = [42u8; 32]; + let seed_2 = [43u8; 32]; + let cross_node_seed = [44u8; 32]; chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed); chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed); let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - let _chan_0_1_low_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0); - let chan_0_1_high_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0); - let _chan_0_1_medium_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + let _chan_0_1_below_amt = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0); + let _chan_0_1_above_amt_high_inbound = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 500_000, 0); + let chan_0_1_above_amt_low_inbound = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 180_000, 0); let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001); let mut scid_aliases = HashSet::new(); - scid_aliases.insert(chan_0_1_high_inbound_capacity.0.short_channel_id_alias.unwrap()); + scid_aliases.insert(chan_0_1_above_amt_low_inbound.0.short_channel_id_alias.unwrap()); scid_aliases.insert(chan_0_2.0.short_channel_id_alias.unwrap()); match_multi_node_invoice_routes( - Some(10_000), + Some(100_000_000), &nodes[1], vec![&nodes[1], &nodes[2],], scid_aliases, @@ -1355,9 +1580,9 @@ mod test { #[cfg(feature = "std")] fn test_multi_node_channels_inbound_capacity_lower_than_invoice_amt_filtering() { let mut chanmon_cfgs = create_chanmon_cfgs(4); - let seed_1 = [42 as u8; 32]; - let seed_2 = [43 as u8; 32]; - let cross_node_seed = [44 as u8; 32]; + let seed_1 = [42u8; 32]; + let seed_2 = [43u8; 32]; + let cross_node_seed = [44u8; 32]; chanmon_cfgs[1].keys_manager.backing = PhantomKeysManager::new(&seed_1, 43, 44, &cross_node_seed); chanmon_cfgs[2].keys_manager.backing = PhantomKeysManager::new(&seed_2, 43, 44, &cross_node_seed); let node_cfgs = create_node_cfgs(4, &chanmon_cfgs); @@ -1440,7 +1665,10 @@ mod test { .map(|route_hint| route_hint.phantom_scid) .collect::>(); - let invoice = crate::utils::create_phantom_invoice::<&test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestLogger>(invoice_amt, None, "test".to_string(), 3600, phantom_route_hints, &invoice_node.keys_manager, &invoice_node.keys_manager, &invoice_node.logger, Currency::BitcoinTestnet).unwrap(); + let invoice = crate::utils::create_phantom_invoice::<&test_utils::TestKeysInterface, + &test_utils::TestKeysInterface, &test_utils::TestLogger>(invoice_amt, None, "test".to_string(), + 3600, phantom_route_hints, invoice_node.keys_manager, invoice_node.keys_manager, + invoice_node.logger, Currency::BitcoinTestnet, None, Duration::from_secs(1234567)).unwrap(); let invoice_hints = invoice.private_routes(); @@ -1463,4 +1691,20 @@ mod test { } assert!(chan_ids_to_match.is_empty(), "Unmatched short channel ids: {:?}", chan_ids_to_match); } + + #[test] + fn test_create_invoice_fails_with_invalid_custom_min_final_cltv_expiry_delta() { + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let result = crate::utils::create_invoice_from_channelmanager_and_duration_since_epoch( + nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::BitcoinTestnet, + Some(10_000), "Some description".into(), Duration::from_secs(1234567), 3600, Some(MIN_FINAL_CLTV_EXPIRY_DELTA - 4), + ); + match result { + Err(SignOrCreationError::CreationError(CreationError::MinFinalCltvExpiryDeltaTooShort)) => {}, + _ => panic!(), + } + } }