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 amt
* If any private channel exists, the invoice rout_hints should be empty

Author: ViktorTigerstrom

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, PhantomRouteHints, MIN_FINAL_CLTV_EXPIRY, MIN_CLTV_EXPIRY_DELTA};
+use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, PaymentSendFailure, PhantomRouteHints, CounterpartyForwardingInfo, MIN_FINAL_CLTV_EXPIRY, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::scoring::Score;
 use lightning::routing::network_graph::{NetworkGraph, RoutingFees};
@@ -158,30 +158,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.short_channel_id {
-			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, _has_private_channels) = 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.
@@ -218,6 +198,85 @@ where
 	}
 }
 
+/// Utility to filter channels for an invoice, and return 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 for which channels are present. Channels with a lower inbound
+/// capacity than the invoice amount aren't included in the hints. If any of the channels are
+/// private, the function returns no RouteHints, and the sender will need to look at the public
+/// channels to find the path instead.
+///
+/// Input:
+/// `channels`: The channels to filter.
+/// `min_inbound_capacity_required`: Defines the lowest inbound capacity a channel must have to not
+/// be filtered out.
+///
+/// Result:
+/// `Vec<RouteHint>`: The filtered RouteHints
+/// `bool`: True if any of the inputted channels are private, else false
+fn filter_channels(channels: Vec<ChannelDetails>, min_inbound_capacity_required: Option<u64>) -> (Vec<RouteHint>, bool){
+	let mut filtered_channels: HashMap<PublicKey, (u64, RouteHint)> = HashMap::new();
+	let min_capacity_required = match min_inbound_capacity_required {
+		Some(amt) => amt,
+		None => 0,
+	};
+	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 {
+		if !channel.is_public {
+			// If any of the channels are private, return no hints and let the sender look at the
+			// public channels instead.
+			let has_private_channels = true;
+			return (vec![], has_private_channels);
+		}
+		let short_channel_id = match channel.clone().short_channel_id {
+			Some(id) => id,
+			None => continue,
+		};
+		let forwarding_info = match channel.clone().counterparty.forwarding_info {
+			Some(info) => info,
+			None => continue,
+		};
+		if channel.inbound_capacity_msat < min_capacity_required {
+			continue;
+		};
+		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),
+				));
+			}
+		}
+	}
+	let route_hints = filtered_channels.iter()
+		.map(|(_channel, (_max_capacity, route_hint))| route_hint.clone())
+		.collect::<Vec<RouteHint>>();
+	let has_private_channels = false;
+	(route_hints, has_private_channels)
+}
+
 /// A [`Router`] implemented using [`find_route`].
 pub struct DefaultRouter<G: Deref<Target = NetworkGraph>, L: Deref> where L::Target: Logger {
 	network_graph: G,