Filter route hints for create invoice

Filter the route hints in `create_invoice_from_channelmanager` based on
the following criteria:

* Only one channel per counterparty node
* Always select the channel with the highest inbound capacity
* Filter out channels with a lower inbound capacity than the invoice
amount, if any channel exists with enough capacity to cover the invoice
amount
* If any public channel exists, the invoice route_hints should be empty,
and the sender will need to find the path to the payment-receiving node
by looking at the public channels instead

Author: ViktorT-11

lightning-invoice/src/utils.rs

@@ -10,7 +10,7 @@ use lightning::chain;
 use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
 use lightning::chain::keysinterface::{Recipient, KeysInterface, Sign};
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
-use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, PaymentSendFailure, MIN_FINAL_CLTV_EXPIRY};
+use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, PaymentSendFailure, CounterpartyForwardingInfo, MIN_FINAL_CLTV_EXPIRY};
 #[cfg(feature = "std")]
 use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::msgs::LightningError;
@@ -161,30 +161,10 @@ where
 	F::Target: FeeEstimator,
 	L::Target: Logger,
 {
-	// Marshall route hints.
-	let our_channels = channelmanager.list_usable_channels();
-	let mut route_hints = vec![];
-	for channel in our_channels {
-		let short_channel_id = match channel.get_inbound_payment_scid() {
-			Some(id) => id,
-			None => continue,
-		};
-		let forwarding_info = match channel.counterparty.forwarding_info {
-			Some(info) => info,
-			None => continue,
-		};
-		route_hints.push(RouteHint(vec![RouteHintHop {
-			src_node_id: channel.counterparty.node_id,
-			short_channel_id,
-			fees: RoutingFees {
-				base_msat: forwarding_info.fee_base_msat,
-				proportional_millionths: forwarding_info.fee_proportional_millionths,
-			},
-			cltv_expiry_delta: forwarding_info.cltv_expiry_delta,
-			htlc_minimum_msat: None,
-			htlc_maximum_msat: None,
-		}]));
-	}
+	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.
@@ -221,6 +201,91 @@ where
 	}
 }
 
+/// Filters channels for an invoice, and returns the corresponding route hints to include
+/// in the invoice.
+///
+/// The filtering ensures that the `RouteHints` returned only include the highest inbound capacity
+/// channel per counterparty node. If any channel with a higher inbound capacity than the given
+/// `min_inbound_capacity_msat` exists, channels to other counterparty nodes with a lower inbound
+/// capacity than `min_inbound_capacity_msat` will be filtered out, even if they are the highest
+/// inbound capacity channel for that specific counterparty node.
+/// If any public channel exists, the function returns no RouteHints, and the sender will need to
+/// look at the public channels to find a path instead.
+///
+/// Input:
+/// `channels`: The channels to filter.
+/// `min_inbound_capacity_msat`: Defines the lowest inbound capacity channels must have to not
+/// be filtered out, if any other channel above that amount exists.
+///
+/// Result:
+/// `Vec<RouteHint>`: The filtered `RouteHints`, which will be empty if any public channel exists.
+fn filter_channels(channels: Vec<ChannelDetails>, min_inbound_capacity_msat: Option<u64>) -> Vec<RouteHint>{
+	let mut filtered_channels: HashMap<PublicKey, (u64, RouteHint)> = HashMap::new();
+	let min_inbound_capacity = min_inbound_capacity_msat.unwrap_or(0);
+	let mut min_capacity_channel_exists = false;
+
+	let route_hint_from_channel = |channel: &ChannelDetails, short_channel_id: u64, forwarding_info: &CounterpartyForwardingInfo| {
+		RouteHint(vec![RouteHintHop {
+			src_node_id: channel.counterparty.node_id,
+			short_channel_id,
+			fees: RoutingFees {
+				base_msat: forwarding_info.fee_base_msat,
+				proportional_millionths: forwarding_info.fee_proportional_millionths,
+			},
+			cltv_expiry_delta: forwarding_info.cltv_expiry_delta,
+			htlc_minimum_msat: None,
+			htlc_maximum_msat: None,}])
+	};
+	for channel in channels {
+		let short_channel_id = match channel.get_inbound_payment_scid() {
+			Some(id) => id,
+			None => continue,
+		};
+		let forwarding_info = match &channel.counterparty.forwarding_info {
+			Some(info) => info,
+			None => continue,
+		};
+		if channel.is_public {
+			// If any public channel exists, return no hints and let the sender
+			// look at the public channels instead.
+			return vec![]
+		}
+
+		if channel.inbound_capacity_msat >= min_inbound_capacity {
+			min_capacity_channel_exists = true;
+		};
+		match filtered_channels.entry(channel.counterparty.node_id) {
+			hash_map::Entry::Occupied(mut entry) => {
+				let current_max_capacity = entry.get().0;
+				if channel.inbound_capacity_msat < current_max_capacity {
+					continue;
+				}
+				entry.insert((
+					channel.inbound_capacity_msat,
+					route_hint_from_channel(&channel, short_channel_id, forwarding_info),
+				));
+			}
+			hash_map::Entry::Vacant(entry) => {
+				entry.insert((
+					channel.inbound_capacity_msat,
+					route_hint_from_channel(&channel, short_channel_id, forwarding_info),
+				));
+			}
+		}
+	}
+
+	// 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(|(_channel, (capacity, _route_hint))| {
+			min_capacity_channel_exists && capacity >= &min_inbound_capacity ||
+			!min_capacity_channel_exists
+		})
+		.map(|(_channel, (_max_capacity, route_hint))| route_hint)
+		.collect::<Vec<RouteHint>>()
+}
+
 /// A [`Router`] implemented using [`find_route`].
 pub struct DefaultRouter<G: Deref<Target = NetworkGraph>, L: Deref> where L::Target: Logger {
 	network_graph: G,
@@ -308,6 +373,7 @@ mod test {
 	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;
 
@@ -317,7 +383,9 @@ 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 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+		let mut private_chan_cfg = UserConfig::default();
+		private_chan_cfg.channel_options.announced_channel = false;
+		create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
 		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)).unwrap();