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: 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, 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,19 +158,9 @@ 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 {
+	let channel_pubkey_selector = |channel: ChannelDetails| channel.counterparty.node_id;
+	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 {
@@ -179,9 +169,15 @@ where
 			},
 			cltv_expiry_delta: forwarding_info.cltv_expiry_delta,
 			htlc_minimum_msat: None,
-			htlc_maximum_msat: None,
-		}]));
-	}
+			htlc_maximum_msat: None,}])
+	};
+	let route_hints = filter_channels(
+		channelmanager.list_usable_channels(),
+		amt_msat,
+		true, // If any of our channels are private, the sender should look at our public channels instead
+		channel_pubkey_selector,
+		route_hint_from_channel
+	);
 
 	// `create_inbound_payment` only returns an error if the amount is greater than the total bitcoin
 	// supply.
@@ -218,6 +214,81 @@ 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 for the pubkey returned by the map_channels_to_pubkey. Channels with a lower inbound
+/// capacity than the invoice amount aren't included in the hints.
+///
+/// `channels`: The channels to filter.
+/// `min_inbound_capacity_required`: Defines the lowest inbound capacity a channel must have to not
+/// be filtered out.
+/// `empty_result_if_private_channels_exists`: If set to `true`, this entire function will return
+/// zero route hints if any of the inputed channels is a private channel.
+/// `channel_pubkey_selector`: Function that is called for every channel evaluated in the filtering
+/// that the required fields and has an high enough inbound_capacity. The route hint for the
+/// highest inbound capacity channel will be returned for each unique `PublicKey` returned by
+/// `channel_pubkey_selector`. The `ChannelDetails` parameter in `channel_pubkey_selector`, is the
+/// current channel evaluated for filtering.
+/// `route_hint_from_channel`: Mapping function that defines how a channel should be mapped into a
+/// `RouteHint`. The `ChannelDetails` parameter in `channel_pubkey_selector`, is the current channel evaluated
+/// for filtering. The `u64` parameter is the channel's `short_channel_id`.
+fn filter_channels<F1, F2>(
+	channels: Vec<ChannelDetails>,
+	min_inbound_capacity_required: Option<u64>,
+	empty_result_if_private_channels_exists: bool,
+	channel_pubkey_selector: F1,
+	route_hint_from_channel: F2
+) -> Vec<RouteHint> where
+	F1: Fn(ChannelDetails) -> PublicKey,
+	F2: Fn(ChannelDetails, u64, CounterpartyForwardingInfo) -> RouteHint
+{
+	let mut filtered_channels: HashMap<PublicKey, (u64, RouteHint)> = HashMap::new();
+	let min_capacity_required = match min_inbound_capacity_required {
+		Some(amt) => amt,
+		None => 0,
+	};
+	for channel in channels {
+		if empty_result_if_private_channels_exists && !channel.is_public {
+			filtered_channels.clear();
+			break;
+		}
+		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_pubkey_selector(channel.clone())) {
+			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),
+				));
+			}
+		}
+	}
+	filtered_channels.iter()
+		.map(|(_channel, (_max_capacity, route_hint))| route_hint.clone())
+		.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,