X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-invoice%2Fsrc%2Futils.rs;h=c2fe5e4aefc533557c0bba8cd9cfef646d4ee938;hb=ac690e8191aadd7e726f48bb7814941f655d404b;hp=e09fd836224b80a339564b94d2239bca29ec9347;hpb=44fa3acae85888982b2c808bc4b401e96d33822f;p=rust-lightning diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index e09fd836..c2fe5e4a 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -1,28 +1,25 @@ //! Convenient utilities to create an invoice. -use {CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError}; -use payment::{Payer, Router}; +use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError}; +use crate::payment::Payer; use crate::{prelude::*, Description, InvoiceDescription, Sha256}; use bech32::ToBase32; -use bitcoin_hashes::{Hash, sha256}; +use bitcoin_hashes::Hash; use lightning::chain; use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; -use lightning::chain::keysinterface::{Recipient, KeysInterface, Sign}; +use lightning::chain::keysinterface::{Recipient, KeysInterface, NodeSigner, SignerProvider}; use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, PaymentSendFailure, MIN_FINAL_CLTV_EXPIRY}; #[cfg(feature = "std")] use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA}; use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey}; -use lightning::ln::msgs::LightningError; -use lightning::routing::gossip::{NetworkGraph, RoutingFees}; -use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route}; -use lightning::routing::scoring::Score; +use lightning::routing::gossip::RoutingFees; +use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop}; use lightning::util::logger::Logger; use secp256k1::PublicKey; use core::ops::Deref; use core::time::Duration; -use sync::Mutex; #[cfg(feature = "std")] /// Utility to create an invoice that can be paid to one of multiple nodes, or a "phantom invoice." @@ -54,14 +51,20 @@ use sync::Mutex; /// [`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 -pub fn create_phantom_invoice( - amt_msat: Option, payment_hash: Option, description: String, invoice_expiry_delta_secs: u32, - phantom_route_hints: Vec, keys_manager: K, network: Currency, -) -> Result> where K::Target: KeysInterface { +pub fn create_phantom_invoice( + amt_msat: Option, payment_hash: Option, description: String, + invoice_expiry_delta_secs: u32, phantom_route_hints: Vec, keys_manager: K, + logger: L, network: Currency, +) -> Result> +where + K::Target: KeysInterface, + L::Target: Logger, +{ let description = Description::new(description).map_err(SignOrCreationError::CreationError)?; let description = InvoiceDescription::Direct(&description,); - _create_phantom_invoice::( - amt_msat, payment_hash, description, invoice_expiry_delta_secs, phantom_route_hints, keys_manager, network, + _create_phantom_invoice::( + amt_msat, payment_hash, description, invoice_expiry_delta_secs, phantom_route_hints, + keys_manager, logger, network, ) } @@ -97,22 +100,30 @@ pub fn create_phantom_invoice( /// [`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 -pub fn create_phantom_invoice_with_description_hash( +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, keys_manager: K, network: Currency, -) -> Result> where K::Target: KeysInterface + description_hash: Sha256, phantom_route_hints: Vec, keys_manager: K, + logger: L, network: Currency +) -> Result> +where + K::Target: KeysInterface, + L::Target: Logger, { - _create_phantom_invoice::( + _create_phantom_invoice::( amt_msat, payment_hash, InvoiceDescription::Hash(&description_hash), - invoice_expiry_delta_secs, phantom_route_hints, keys_manager, network, + invoice_expiry_delta_secs, phantom_route_hints, keys_manager, logger, network, ) } #[cfg(feature = "std")] -fn _create_phantom_invoice( +fn _create_phantom_invoice( amt_msat: Option, payment_hash: Option, description: InvoiceDescription, - invoice_expiry_delta_secs: u32, phantom_route_hints: Vec, keys_manager: K, network: Currency, -) -> Result> where K::Target: KeysInterface + invoice_expiry_delta_secs: u32, phantom_route_hints: Vec, keys_manager: K, + logger: L, network: Currency, +) -> Result> +where + K::Target: KeysInterface, + L::Target: Logger, { use std::time::{SystemTime, UNIX_EPOCH}; @@ -121,6 +132,7 @@ fn _create_phantom_invoice( CreationError::MissingRouteHints, )); } + let invoice = match description { InvoiceDescription::Direct(description) => { InvoiceBuilder::new(network).description(description.0.clone()) @@ -157,6 +169,9 @@ fn _create_phantom_invoice( .map_err(|_| SignOrCreationError::CreationError(CreationError::InvalidAmount))? }; + log_trace!(logger, "Creating phantom invoice from {} participating nodes with payment hash {}", + phantom_route_hints.len(), log_bytes!(payment_hash.0)); + let mut invoice = invoice .current_timestamp() .payment_hash(Hash::from_slice(&payment_hash.0).unwrap()) @@ -168,7 +183,9 @@ fn _create_phantom_invoice( } for PhantomRouteHints { channels, phantom_scid, real_node_pubkey } in phantom_route_hints { - let mut route_hints = filter_channels(channels, amt_msat); + log_trace!(logger, "Generating phantom route hints for node {}", + log_pubkey!(real_node_pubkey)); + let mut route_hints = filter_channels(channels, amt_msat, &logger); // If we have any public channel, the route hints from `filter_channels` will be empty. // In that case we create a RouteHint on which we will push a single hop with the phantom @@ -215,14 +232,14 @@ fn _create_phantom_invoice( /// /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for /// in excess of the current time. -pub fn create_invoice_from_channelmanager( - channelmanager: &ChannelManager, keys_manager: K, network: Currency, - amt_msat: Option, description: String, invoice_expiry_delta_secs: u32 +pub fn create_invoice_from_channelmanager( + channelmanager: &ChannelManager, keys_manager: K, logger: L, + network: Currency, amt_msat: Option, description: String, invoice_expiry_delta_secs: u32 ) -> Result> where - M::Target: chain::Watch, + M::Target: chain::Watch<::Signer>, T::Target: BroadcasterInterface, - K::Target: KeysInterface, + K::Target: KeysInterface, F::Target: FeeEstimator, L::Target: Logger, { @@ -230,7 +247,7 @@ where let duration = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) .expect("for the foreseeable future this shouldn't happen"); create_invoice_from_channelmanager_and_duration_since_epoch( - channelmanager, keys_manager, network, amt_msat, description, duration, + channelmanager, keys_manager, logger, network, amt_msat, description, duration, invoice_expiry_delta_secs ) } @@ -245,14 +262,15 @@ where /// /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for /// in excess of the current time. -pub fn create_invoice_from_channelmanager_with_description_hash( - channelmanager: &ChannelManager, keys_manager: K, network: Currency, - amt_msat: Option, description_hash: Sha256, invoice_expiry_delta_secs: u32 +pub fn create_invoice_from_channelmanager_with_description_hash( + channelmanager: &ChannelManager, keys_manager: K, logger: L, + network: Currency, amt_msat: Option, description_hash: Sha256, + invoice_expiry_delta_secs: u32 ) -> Result> where - M::Target: chain::Watch, + M::Target: chain::Watch<::Signer>, T::Target: BroadcasterInterface, - K::Target: KeysInterface, + K::Target: KeysInterface, F::Target: FeeEstimator, L::Target: Logger, { @@ -263,7 +281,7 @@ where .expect("for the foreseeable future this shouldn't happen"); create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch( - channelmanager, keys_manager, network, amt_msat, + channelmanager, keys_manager, logger, network, amt_msat, description_hash, duration, invoice_expiry_delta_secs ) } @@ -271,20 +289,20 @@ where /// See [`create_invoice_from_channelmanager_with_description_hash`] /// This version 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_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch( - channelmanager: &ChannelManager, keys_manager: K, network: Currency, - amt_msat: Option, description_hash: Sha256, duration_since_epoch: Duration, - invoice_expiry_delta_secs: u32 +pub fn create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch( + channelmanager: &ChannelManager, keys_manager: K, logger: L, + network: Currency, amt_msat: Option, description_hash: Sha256, + duration_since_epoch: Duration, invoice_expiry_delta_secs: u32 ) -> Result> -where - M::Target: chain::Watch, - T::Target: BroadcasterInterface, - K::Target: KeysInterface, - F::Target: FeeEstimator, - L::Target: Logger, + where + M::Target: chain::Watch<::Signer>, + T::Target: BroadcasterInterface, + K::Target: KeysInterface, + F::Target: FeeEstimator, + L::Target: Logger, { _create_invoice_from_channelmanager_and_duration_since_epoch( - channelmanager, keys_manager, network, amt_msat, + channelmanager, keys_manager, logger, network, amt_msat, InvoiceDescription::Hash(&description_hash), duration_since_epoch, invoice_expiry_delta_secs ) @@ -293,20 +311,20 @@ where /// See [`create_invoice_from_channelmanager`] /// This version 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_invoice_from_channelmanager_and_duration_since_epoch( - channelmanager: &ChannelManager, keys_manager: K, network: Currency, - amt_msat: Option, description: String, duration_since_epoch: Duration, +pub fn create_invoice_from_channelmanager_and_duration_since_epoch( + channelmanager: &ChannelManager, keys_manager: K, logger: L, + network: Currency, amt_msat: Option, description: String, duration_since_epoch: Duration, invoice_expiry_delta_secs: u32 ) -> Result> -where - M::Target: chain::Watch, - T::Target: BroadcasterInterface, - K::Target: KeysInterface, - F::Target: FeeEstimator, - L::Target: Logger, + where + M::Target: chain::Watch<::Signer>, + T::Target: BroadcasterInterface, + K::Target: KeysInterface, + F::Target: FeeEstimator, + L::Target: Logger, { _create_invoice_from_channelmanager_and_duration_since_epoch( - channelmanager, keys_manager, network, amt_msat, + channelmanager, keys_manager, logger, network, amt_msat, InvoiceDescription::Direct( &Description::new(description).map_err(SignOrCreationError::CreationError)?, ), @@ -314,26 +332,71 @@ where ) } -fn _create_invoice_from_channelmanager_and_duration_since_epoch( - channelmanager: &ChannelManager, keys_manager: K, network: Currency, - amt_msat: Option, description: InvoiceDescription, duration_since_epoch: Duration, - invoice_expiry_delta_secs: u32 +fn _create_invoice_from_channelmanager_and_duration_since_epoch( + channelmanager: &ChannelManager, keys_manager: K, logger: L, + network: Currency, amt_msat: Option, description: InvoiceDescription, + duration_since_epoch: Duration, invoice_expiry_delta_secs: u32 ) -> Result> -where - M::Target: chain::Watch, - T::Target: BroadcasterInterface, - K::Target: KeysInterface, - F::Target: FeeEstimator, - L::Target: Logger, + where + M::Target: chain::Watch<::Signer>, + T::Target: BroadcasterInterface, + K::Target: KeysInterface, + F::Target: FeeEstimator, + L::Target: Logger, { - let route_hints = filter_channels(channelmanager.list_usable_channels(), amt_msat); - // `create_inbound_payment` only returns an error if the amount is greater than the total bitcoin // supply. let (payment_hash, payment_secret) = channelmanager .create_inbound_payment(amt_msat, invoice_expiry_delta_secs) .map_err(|()| SignOrCreationError::CreationError(CreationError::InvalidAmount))?; + _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash( + channelmanager, keys_manager, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs, payment_hash, payment_secret) +} + +/// See [`create_invoice_from_channelmanager_and_duration_since_epoch`] +/// This version allows for providing a custom [`PaymentHash`] for the invoice. +/// This may be useful if you're building an on-chain swap or involving another protocol where +/// the payment hash is also involved outside the scope of lightning. +pub fn create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash( + channelmanager: &ChannelManager, keys_manager: K, logger: L, + network: Currency, amt_msat: Option, description: String, duration_since_epoch: Duration, + invoice_expiry_delta_secs: u32, payment_hash: PaymentHash +) -> Result> + where + M::Target: chain::Watch<::Signer>, + T::Target: BroadcasterInterface, + K::Target: KeysInterface, + F::Target: FeeEstimator, + L::Target: Logger, +{ + let payment_secret = channelmanager + .create_inbound_payment_for_hash(payment_hash,amt_msat, invoice_expiry_delta_secs) + .map_err(|()| SignOrCreationError::CreationError(CreationError::InvalidAmount))?; + _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash( + channelmanager, keys_manager, logger, network, amt_msat, + InvoiceDescription::Direct( + &Description::new(description).map_err(SignOrCreationError::CreationError)?, + ), + duration_since_epoch, invoice_expiry_delta_secs, payment_hash, payment_secret + ) +} + +fn _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash( + channelmanager: &ChannelManager, keys_manager: K, logger: L, + network: Currency, amt_msat: Option, description: InvoiceDescription, duration_since_epoch: Duration, + invoice_expiry_delta_secs: u32, payment_hash: PaymentHash, payment_secret: PaymentSecret +) -> Result> + where + M::Target: chain::Watch<::Signer>, + T::Target: BroadcasterInterface, + K::Target: KeysInterface, + F::Target: FeeEstimator, + L::Target: Logger, +{ let our_node_pubkey = channelmanager.get_our_node_id(); + let channels = channelmanager.list_channels(); + + log_trace!(logger, "Creating invoice with payment hash {}", log_bytes!(payment_hash.0)); let invoice = match description { InvoiceDescription::Direct(description) => { @@ -353,6 +416,8 @@ where if let Some(amt) = amt_msat { invoice = invoice.amount_milli_satoshis(amt); } + + let route_hints = filter_channels(channels, amt_msat, &logger); for hint in route_hints { invoice = invoice.private_route(hint); } @@ -377,35 +442,68 @@ where /// 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 -/// * Filter out channels with a lower inbound capacity than `min_inbound_capacity_msat`, if any -/// channel with a higher or equal inbound capacity than `min_inbound_capacity_msat` exists +/// * 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 -fn filter_channels(channels: Vec, min_inbound_capacity_msat: Option) -> Vec{ - let mut filtered_channels: HashMap = HashMap::new(); +/// need 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 { + let mut filtered_channels: HashMap = HashMap::new(); let min_inbound_capacity = min_inbound_capacity_msat.unwrap_or(0); let mut min_capacity_channel_exists = false; + let mut online_channel_exists = false; + let mut online_min_capacity_channel_exists = false; - for channel in channels.iter() { + log_trace!(logger, "Considering {} channels for invoice route hints", channels.len()); + for channel in channels.into_iter().filter(|chan| chan.is_channel_ready) { if channel.get_inbound_payment_scid().is_none() || channel.counterparty.forwarding_info.is_none() { + log_trace!(logger, "Ignoring channel {} for invoice route hints", log_bytes!(channel.channel_id)); continue; } 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.inbound_capacity_msat >= min_inbound_capacity { - min_capacity_channel_exists = true; - }; + if !min_capacity_channel_exists { + log_trace!(logger, "Channel with enough inbound capacity exists for invoice route hints"); + min_capacity_channel_exists = true; + } + + if channel.is_usable { + online_min_capacity_channel_exists = true; + } + } + + if channel.is_usable { + if !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 { + log_trace!(logger, + "Preferring counterparty {} channel {} ({} msats) over {} ({} 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_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) => { @@ -414,7 +512,7 @@ fn filter_channels(channels: Vec, min_inbound_capacity_msat: Opt } } - let route_hint_from_channel = |channel: &ChannelDetails| { + let route_hint_from_channel = |channel: ChannelDetails| { let forwarding_info = channel.counterparty.forwarding_info.as_ref().unwrap(); RouteHint(vec![RouteHintHop { src_node_id: channel.counterparty.node_id, @@ -427,55 +525,51 @@ fn filter_channels(channels: Vec, min_inbound_capacity_msat: Opt htlc_minimum_msat: channel.inbound_htlc_minimum_msat, htlc_maximum_msat: channel.inbound_htlc_maximum_msat,}]) }; - // If all channels are private, return the route hint for the highest inbound capacity channel - // per counterparty node. If channels with an higher inbound capacity than the - // min_inbound_capacity exists, filter out the channels with a lower capacity than that. - filtered_channels.into_iter() - .filter(|(_counterparty_id, channel)| { - min_capacity_channel_exists && channel.inbound_capacity_msat >= min_inbound_capacity || - !min_capacity_channel_exists + // If all channels are private, prefer to return route hints which have a higher capacity than + // the payment value and where we're currently connected to the channel counterparty. + // Even if we cannot satisfy both goals, always ensure we include *some* hints, preferring + // those which meet at least one criteria. + filtered_channels + .into_iter() + .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 { + 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 + // online-and-min_capacity channels, just include the min capacity ones and ignore + // online-ness. + has_enough_capacity + } else if min_capacity_channel_exists { + has_enough_capacity + } else if online_channel_exists { + channel.is_usable + } else { true }; + + if include_channel { + log_trace!(logger, "Including channel {} in invoice route hints", + log_bytes!(channel.channel_id)); + } else if !has_enough_capacity { + log_trace!(logger, "Ignoring channel {} without enough capacity for invoice route hints", + log_bytes!(channel.channel_id)); + } else { + debug_assert!(!channel.is_usable); + log_trace!(logger, "Ignoring channel {} with disconnected peer", + log_bytes!(channel.channel_id)); + } + + include_channel }) - .map(|(_counterparty_id, channel)| route_hint_from_channel(&channel)) + .map(route_hint_from_channel) .collect::>() } -/// A [`Router`] implemented using [`find_route`]. -pub struct DefaultRouter>, L: Deref> where L::Target: Logger { - network_graph: G, - logger: L, - random_seed_bytes: Mutex<[u8; 32]>, -} - -impl>, L: Deref> DefaultRouter where L::Target: Logger { - /// Creates a new router using the given [`NetworkGraph`], a [`Logger`], and a randomness source - /// `random_seed_bytes`. - pub fn new(network_graph: G, logger: L, random_seed_bytes: [u8; 32]) -> Self { - let random_seed_bytes = Mutex::new(random_seed_bytes); - Self { network_graph, logger, random_seed_bytes } - } -} - -impl>, L: Deref, S: Score> Router for DefaultRouter -where L::Target: Logger { - fn find_route( - &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash, - first_hops: Option<&[&ChannelDetails]>, scorer: &S - ) -> Result { - let network_graph = self.network_graph.read_only(); - let random_seed_bytes = { - let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap(); - *locked_random_seed_bytes = sha256::Hash::hash(&*locked_random_seed_bytes).into_inner(); - *locked_random_seed_bytes - }; - find_route(payer, params, &network_graph, first_hops, &*self.logger, scorer, &random_seed_bytes) - } -} - -impl Payer for ChannelManager +impl Payer for ChannelManager where - M::Target: chain::Watch, + M::Target: chain::Watch<::Signer>, T::Target: BroadcasterInterface, - K::Target: KeysInterface, + K::Target: KeysInterface, F::Target: FeeEstimator, L::Target: Logger, { @@ -488,16 +582,16 @@ where } fn send_payment( - &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option - ) -> Result { - self.send_payment(route, payment_hash, payment_secret) + &self, route: &Route, payment_hash: PaymentHash, payment_secret: &Option, + payment_id: PaymentId + ) -> Result<(), PaymentSendFailure> { + self.send_payment(route, payment_hash, payment_secret, payment_id) } fn send_spontaneous_payment( - &self, route: &Route, payment_preimage: PaymentPreimage, - ) -> Result { - self.send_spontaneous_payment(route, Some(payment_preimage)) - .map(|(_, payment_id)| payment_id) + &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( @@ -509,27 +603,27 @@ where fn abandon_payment(&self, payment_id: PaymentId) { self.abandon_payment(payment_id) } + + fn inflight_htlcs(&self) -> InFlightHtlcs { self.compute_inflight_htlcs() } } #[cfg(test)] mod test { use core::time::Duration; - use {Currency, Description, InvoiceDescription}; - use bitcoin_hashes::Hash; + use crate::{Currency, Description, InvoiceDescription}; + use bitcoin_hashes::{Hash, sha256}; use bitcoin_hashes::sha256::Hash as Sha256; - use lightning::chain::keysinterface::PhantomKeysManager; + use lightning::chain::keysinterface::{EntropySource, PhantomKeysManager}; use lightning::ln::{PaymentPreimage, PaymentHash}; - use lightning::ln::channelmanager::{PhantomRouteHints, MIN_FINAL_CLTV_EXPIRY}; + use lightning::ln::channelmanager::{self, PhantomRouteHints, MIN_FINAL_CLTV_EXPIRY, PaymentId}; use lightning::ln::functional_test_utils::*; - use lightning::ln::features::InitFeatures; use lightning::ln::msgs::ChannelMessageHandler; use lightning::routing::router::{PaymentParameters, RouteParameters, find_route}; - use lightning::util::enforcing_trait_impls::EnforcingSigner; use lightning::util::events::{MessageSendEvent, MessageSendEventsProvider, Event}; use lightning::util::test_utils; use lightning::util::config::UserConfig; use lightning::chain::keysinterface::KeysInterface; - use utils::create_invoice_from_channelmanager_and_duration_since_epoch; + use crate::utils::create_invoice_from_channelmanager_and_duration_since_epoch; use std::collections::HashSet; #[test] @@ -538,11 +632,12 @@ mod test { 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); - create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let non_default_invoice_expiry_secs = 4200; let invoice = create_invoice_from_channelmanager_and_duration_since_epoch( - &nodes[1].node, nodes[1].keys_manager, Currency::BitcoinTestnet, Some(10_000), "test".to_string(), - Duration::from_secs(1234567), non_default_invoice_expiry_secs).unwrap(); + &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(); 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.description(), InvoiceDescription::Direct(&Description("test".to_string()))); @@ -572,14 +667,14 @@ mod test { let scorer = test_utils::TestScorer::with_penalty(0); 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.read_only(), + &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())).unwrap(); + nodes[0].node.send_payment(&route, payment_hash, &Some(invoice.payment_secret().clone()), 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(); @@ -605,15 +700,33 @@ mod test { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); let description_hash = crate::Sha256(Hash::hash("Testing description_hash".as_bytes())); - let invoice = ::utils::create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch( - &nodes[1].node, nodes[1].keys_manager, Currency::BitcoinTestnet, Some(10_000), - description_hash, Duration::from_secs(1234567), 3600 + 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 ).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.description(), InvoiceDescription::Hash(&crate::Sha256(Sha256::hash("Testing description_hash".as_bytes())))); } + #[test] + fn test_create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash() { + 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 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, + Some(10_000), "test".to_string(), Duration::from_secs(1234567), 3600, + payment_hash + ).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.description(), InvoiceDescription::Direct(&Description("test".to_string()))); + assert_eq!(invoice.payment_hash(), &sha256::Hash::from_slice(&payment_hash.0[..]).unwrap()); + } + #[test] fn test_hints_includes_single_channels_to_nodes() { let chanmon_cfgs = create_chanmon_cfgs(3); @@ -621,8 +734,8 @@ mod test { let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - let chan_1_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100000, 10001, InitFeatures::known(), InitFeatures::known()); - let chan_2_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 2, 0, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_1_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_2_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 2, 0, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let mut scid_aliases = HashSet::new(); scid_aliases.insert(chan_1_0.0.short_channel_id_alias.unwrap()); @@ -637,23 +750,50 @@ mod test { 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, InitFeatures::known(), InitFeatures::known()); - let chan_1_0_high_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 10_000_000, 0, InitFeatures::known(), InitFeatures::known()); - let _chan_1_0_medium_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 1_000_000, 0, InitFeatures::known(), InitFeatures::known()); - + let _chan_1_0_low_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_1_0_high_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 10_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let _chan_1_0_medium_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); 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); } + #[test] + fn test_hints_has_only_online_channels() { + let chanmon_cfgs = create_chanmon_cfgs(4); + let node_cfgs = create_node_cfgs(4, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]); + let nodes = create_network(4, &node_cfgs, &node_chanmgrs); + let chan_a = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 10_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_b = create_unannounced_chan_between_nodes_with_value(&nodes, 2, 0, 10_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let _chan_c = create_unannounced_chan_between_nodes_with_value(&nodes, 3, 0, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + + // With all peers connected we should get all hints that have sufficient value + let mut scid_aliases = HashSet::new(); + scid_aliases.insert(chan_a.0.short_channel_id_alias.unwrap()); + scid_aliases.insert(chan_b.0.short_channel_id_alias.unwrap()); + + match_invoice_routes(Some(1_000_000_000), &nodes[0], scid_aliases.clone()); + + // 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); + 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); + match_invoice_routes(Some(1_000_000_000), &nodes[0], scid_aliases); + } + #[test] fn test_forwarding_info_not_assigned_channel_excluded_from_hints() { 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 chan_1_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_1_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); // Create an unannonced channel between `nodes[2]` and `nodes[0]`, for which the // `msgs::ChannelUpdate` is never handled for the node(s). As the `msgs::ChannelUpdate` @@ -662,9 +802,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(), InitFeatures::known(), &open_channel); + nodes[0].node.handle_open_channel(&nodes[2].node.get_our_node_id(), channelmanager::provided_init_features(), &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(), InitFeatures::known(), &accept_channel); + nodes[2].node.handle_accept_channel(&nodes[0].node.get_our_node_id(), channelmanager::provided_init_features(), &accept_channel); let tx = sign_funding_transaction(&nodes[2], &nodes[0], 1_000_000, temporary_channel_id); @@ -678,6 +818,8 @@ mod test { get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); nodes[0].node.handle_channel_ready(&nodes[2].node.get_our_node_id(), &as_channel_ready); get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[2].node.get_our_node_id()); + expect_channel_ready_event(&nodes[0], &nodes[2].node.get_our_node_id()); + expect_channel_ready_event(&nodes[2], &nodes[0].node.get_our_node_id()); // As `msgs::ChannelUpdate` was never handled for the participating node(s) of the second // channel, the channel will never be assigned any `counterparty.forwarding_info`. @@ -693,9 +835,9 @@ mod test { 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_1_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let _chan_1_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); - let chan_2_0 = create_announced_chan_between_nodes_with_value(&nodes, 2, 0, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_2_0 = create_announced_chan_between_nodes_with_value(&nodes, 2, 0, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_2_0.1); nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_2_0.0); @@ -711,11 +853,11 @@ mod test { 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_1_0 = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_1_0 = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); nodes[0].node.handle_channel_update(&nodes[1].node.get_our_node_id(), &chan_1_0.0); nodes[1].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_1_0.1); - let chan_2_0 = create_announced_chan_between_nodes_with_value(&nodes, 2, 0, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_2_0 = create_announced_chan_between_nodes_with_value(&nodes, 2, 0, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_2_0.1); nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_2_0.0); @@ -729,8 +871,8 @@ mod test { 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_1_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100_000, 0, InitFeatures::known(), InitFeatures::known()); - let chan_2_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 2, 0, 1_000_000, 0, InitFeatures::known(), InitFeatures::known()); + let chan_1_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 0, 100_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_2_0 = create_unannounced_chan_between_nodes_with_value(&nodes, 2, 0, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); // As the invoice amt is 1 msat above chan_1_0's inbound capacity, it shouldn't be included let mut scid_aliases_99_000_001_msat = HashSet::new(); @@ -766,8 +908,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, Currency::BitcoinTestnet, invoice_amt, "test".to_string(), - Duration::from_secs(1234567), 3600).unwrap(); + &invoice_node.node, invoice_node.keys_manager, invoice_node.logger, + Currency::BitcoinTestnet, invoice_amt, "test".to_string(), Duration::from_secs(1234567), + 3600).unwrap(); let hints = invoice.private_routes(); for hint in hints { @@ -795,10 +938,10 @@ mod test { 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 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_0_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); nodes[0].node.handle_channel_update(&nodes[1].node.get_our_node_id(), &chan_0_1.1); nodes[1].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_1.0); - let chan_0_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_0_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_0_2.1); nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_2.0); @@ -817,9 +960,9 @@ mod test { let non_default_invoice_expiry_secs = 4200; let invoice = - ::utils::create_phantom_invoice::( + crate::utils::create_phantom_invoice::<&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, Currency::BitcoinTestnet + route_hints, &nodes[1].keys_manager, &nodes[1].logger, Currency::BitcoinTestnet ).unwrap(); let (payment_hash, payment_secret) = (PaymentHash(invoice.payment_hash().into_inner()), *invoice.payment_secret()); let payment_preimage = if user_generated_pmt_hash { @@ -848,13 +991,13 @@ mod test { let scorer = test_utils::TestScorer::with_penalty(0); 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.read_only(), + &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())).unwrap(); + nodes[0].node.send_payment(&route, payment_hash, &Some(invoice.payment_secret().clone()), 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(); @@ -874,7 +1017,7 @@ mod test { nodes[fwd_idx].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]); commitment_signed_dance!(nodes[fwd_idx], nodes[0], &payment_event.commitment_msg, false, true); - // Note that we have to "forward pending HTLCs" twice before we see the PaymentReceived as + // Note that we have to "forward pending HTLCs" twice before we see the PaymentClaimable as // this "emulates" the payment taking two hops, providing some privacy to make phantom node // payments "look real" by taking more time. expect_pending_htlcs_forwardable_ignore!(nodes[fwd_idx]); @@ -883,7 +1026,7 @@ mod test { nodes[fwd_idx].node.process_pending_htlc_forwards(); let payment_preimage_opt = if user_generated_pmt_hash { None } else { Some(payment_preimage) }; - expect_payment_received!(&nodes[fwd_idx], payment_hash, payment_secret, payment_amt, payment_preimage_opt); + 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); let events = nodes[0].node.get_and_clear_pending_events(); assert_eq!(events.len(), 2); @@ -916,8 +1059,8 @@ mod test { let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known()); - create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let payment_amt = 20_000; let (payment_hash, _payment_secret) = nodes[1].node.create_inbound_payment(Some(payment_amt), 3600).unwrap(); @@ -926,7 +1069,7 @@ mod test { nodes[2].node.get_phantom_route_hints(), ]; - let invoice = ::utils::create_phantom_invoice::(Some(payment_amt), Some(payment_hash), "test".to_string(), 3600, route_hints, &nodes[1].keys_manager, Currency::BitcoinTestnet).unwrap(); + let invoice = crate::utils::create_phantom_invoice::<&test_utils::TestKeysInterface, &test_utils::TestLogger>(Some(payment_amt), Some(payment_hash), "test".to_string(), 3600, route_hints, &nodes[1].keys_manager, &nodes[1].logger, Currency::BitcoinTestnet).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); @@ -953,11 +1096,11 @@ mod test { let description_hash = crate::Sha256(Hash::hash("Description hash phantom invoice".as_bytes())); let non_default_invoice_expiry_secs = 4200; - let invoice = ::utils::create_phantom_invoice_with_description_hash::< - EnforcingSigner, &test_utils::TestKeysInterface, + let invoice = crate::utils::create_phantom_invoice_with_description_hash::< + &test_utils::TestKeysInterface, &test_utils::TestLogger, >( Some(payment_amt), None, non_default_invoice_expiry_secs, description_hash, - route_hints, &nodes[1].keys_manager, Currency::BitcoinTestnet + route_hints, &nodes[1].keys_manager, &nodes[1].logger, Currency::BitcoinTestnet ) .unwrap(); assert_eq!(invoice.amount_pico_btc(), Some(200_000)); @@ -979,8 +1122,8 @@ mod test { 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 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known()); - let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_0_1 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let mut scid_aliases = HashSet::new(); scid_aliases.insert(chan_0_1.0.short_channel_id_alias.unwrap()); @@ -1008,9 +1151,9 @@ mod test { let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]); let nodes = create_network(4, &node_cfgs, &node_chanmgrs); - let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known()); - let chan_0_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 3, 1000000, 10001, InitFeatures::known(), InitFeatures::known()); - let chan_1_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 3, 3_000_000, 10005, InitFeatures::known(), InitFeatures::known()); + let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_0_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 3, 1000000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_1_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 3, 3_000_000, 10005, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let mut scid_aliases = HashSet::new(); scid_aliases.insert(chan_0_2.0.short_channel_id_alias.unwrap()); @@ -1039,8 +1182,8 @@ mod test { let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]); let nodes = create_network(4, &node_cfgs, &node_chanmgrs); - let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known()); - let chan_0_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 3, 1000000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_0_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 3, 1000000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); // Create an unannonced channel between `nodes[1]` and `nodes[3]`, for which the // `msgs::ChannelUpdate` is never handled for the node(s). As the `msgs::ChannelUpdate` @@ -1049,9 +1192,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(), InitFeatures::known(), &open_channel); + nodes[3].node.handle_open_channel(&nodes[1].node.get_our_node_id(), channelmanager::provided_init_features(), &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(), InitFeatures::known(), &accept_channel); + nodes[1].node.handle_accept_channel(&nodes[3].node.get_our_node_id(), channelmanager::provided_init_features(), &accept_channel); let tx = sign_funding_transaction(&nodes[1], &nodes[3], 1_000_000, temporary_channel_id); @@ -1065,6 +1208,8 @@ mod test { get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[3].node.get_our_node_id()); nodes[3].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &as_channel_ready); get_event_msg!(nodes[3], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); + expect_channel_ready_event(&nodes[1], &nodes[3].node.get_our_node_id()); + expect_channel_ready_event(&nodes[3], &nodes[1].node.get_our_node_id()); // As `msgs::ChannelUpdate` was never handled for the participating node(s) of the third // channel, the channel will never be assigned any `counterparty.forwarding_info`. @@ -1095,9 +1240,9 @@ mod test { 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 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_0_1 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); - let chan_2_0 = create_announced_chan_between_nodes_with_value(&nodes, 2, 0, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_2_0 = create_announced_chan_between_nodes_with_value(&nodes, 2, 0, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_2_0.1); nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_2_0.0); @@ -1128,12 +1273,12 @@ mod test { let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]); let nodes = create_network(4, &node_cfgs, &node_chanmgrs); - let chan_0_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_0_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); nodes[0].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &chan_0_2.1); nodes[2].node.handle_channel_update(&nodes[0].node.get_our_node_id(), &chan_0_2.0); - let _chan_1_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let _chan_1_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); - let chan_0_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 3, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let chan_0_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 3, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); // Hints should include `chan_0_3` from as `nodes[3]` only have private channels, and no // channels for `nodes[2]` as it contains a mix of public and private channels. @@ -1162,10 +1307,10 @@ mod test { 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, InitFeatures::known(), InitFeatures::known()); - let chan_0_1_high_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0, InitFeatures::known(), InitFeatures::known()); - let _chan_0_1_medium_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known()); - let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, InitFeatures::known(), InitFeatures::known()); + let _chan_0_1_low_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_0_1_high_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let _chan_0_1_medium_inbound_capacity = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let mut scid_aliases = HashSet::new(); scid_aliases.insert(chan_0_1_high_inbound_capacity.0.short_channel_id_alias.unwrap()); @@ -1193,9 +1338,9 @@ mod test { let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]); let nodes = create_network(4, &node_cfgs, &node_chanmgrs); - let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0, InitFeatures::known(), InitFeatures::known()); - let chan_0_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 3, 100_000, 0, InitFeatures::known(), InitFeatures::known()); - let chan_1_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 3, 200_000, 0, InitFeatures::known(), InitFeatures::known()); + let chan_0_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_0_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 0, 3, 100_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); + let chan_1_3 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 3, 200_000, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()); // Since the invoice 1 msat above chan_0_3's inbound capacity, it should be filtered out. let mut scid_aliases_99_000_001_msat = HashSet::new(); @@ -1269,7 +1414,7 @@ mod test { .map(|route_hint| route_hint.phantom_scid) .collect::>(); - let invoice = ::utils::create_phantom_invoice::(invoice_amt, None, "test".to_string(), 3600, phantom_route_hints, &invoice_node.keys_manager, Currency::BitcoinTestnet).unwrap(); + let invoice = crate::utils::create_phantom_invoice::<&test_utils::TestKeysInterface, &test_utils::TestLogger>(invoice_amt, None, "test".to_string(), 3600, phantom_route_hints, &invoice_node.keys_manager, &invoice_node.logger, Currency::BitcoinTestnet).unwrap(); let invoice_hints = invoice.private_routes();