f Create invoice cleanup

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, CounterpartyForwardingInfo, PaymentId, PaymentSendFailure, MIN_FINAL_CLTV_EXPIRY};
+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::msgs::LightningError;
@@ -198,50 +198,26 @@ where
 	}
 }
 
-/// Filters channels for an invoice, and returns the corresponding route hints to include
+/// Filters the `channels` for an invoice, and returns the corresponding `RouteHint`s 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.
+/// 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
+/// * 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<ChannelDetails>, min_inbound_capacity_msat: Option<u64>) -> Vec<RouteHint>{
-	let mut filtered_channels: HashMap<PublicKey, (u64, RouteHint)> = HashMap::new();
+	let mut filtered_channels: HashMap<PublicKey, ChannelDetails> = 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.get_inbound_payment_scid().is_none() || channel.counterparty.forwarding_info.is_none() {
+			continue;
+		}
+
 		if channel.is_public {
 			// If any public channel exists, return no hints and let the sender
 			// look at the public channels instead.
@@ -253,33 +229,40 @@ fn filter_channels(channels: Vec<ChannelDetails>, min_inbound_capacity_msat: Opt
 		};
 		match filtered_channels.entry(channel.counterparty.node_id) {
 			hash_map::Entry::Occupied(mut entry) => {
-				let current_max_capacity = entry.get().0;
+				let current_max_capacity = entry.get().inbound_capacity_msat;
 				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),
-				));
+				entry.insert(channel);
 			}
 			hash_map::Entry::Vacant(entry) => {
-				entry.insert((
-					channel.inbound_capacity_msat,
-					route_hint_from_channel(&channel, short_channel_id, forwarding_info),
-				));
+				entry.insert(channel);
 			}
 		}
 	}
 
+	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,
+			short_channel_id: channel.get_inbound_payment_scid().unwrap(),
+			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,}])
+	};
 	// 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 ||
+		.filter(|(_counterparty_id, channel)| {
+			min_capacity_channel_exists && channel.inbound_capacity_msat >= min_inbound_capacity ||
 			!min_capacity_channel_exists
 		})
-		.map(|(_channel, (_max_capacity, route_hint))| route_hint)
+		.map(|(_counterparty_id, channel)| route_hint_from_channel(&channel))
 		.collect::<Vec<RouteHint>>()
 }