Multi-path payments if can't find a sufficient path

Author: naumenkogs

lightning/src/routing/router.rs

@@ -13,7 +13,7 @@ use util::ser::{Writeable, Readable};
 use util::logger::Logger;
 
 use std::cmp;
-use std::collections::{HashMap,BinaryHeap};
+use std::collections::{HashMap, BinaryHeap, HashSet};
 use std::ops::Deref;
 
 /// A hop in a route
@@ -119,7 +119,7 @@ pub struct RouteHint {
 	pub htlc_maximum_msat: Option<u64>,
 }
 
-#[derive(Eq, PartialEq)]
+#[derive(Eq, PartialEq, Clone)]
 struct RouteGraphNode {
 	pubkey: PublicKey,
 	lowest_fee_to_peer_through_node: u64,
@@ -336,7 +336,7 @@ pub fn get_route<L: Deref>(our_node_id: &PublicKey, network: &NetworkGraph, targ
 	}
 
 	macro_rules! add_entries_to_cheapest_to_target_node {
-		( $node: expr, $node_id: expr, $fee_to_target_msat: expr ) => {
+		( $node: expr, $node_id: expr, $fee_to_target_msat: expr, $channels_to_avoid: expr ) => {
 			if first_hops.is_some() {
 				if let Some(&(ref first_hop, ref features)) = first_hop_targets.get(&$node_id) {
 					add_entry!(first_hop, *our_node_id, $node_id, dummy_directional_info, None::<u64>, features.to_context(), $fee_to_target_msat);
@@ -352,6 +352,9 @@ pub fn get_route<L: Deref>(our_node_id: &PublicKey, network: &NetworkGraph, targ
 
 			if !features.requires_unknown_bits() {
 				for chan_id in $node.channels.iter() {
+					if $channels_to_avoid.contains(chan_id) {
+						continue;
+					}
 					let chan = network.get_channels().get(chan_id).unwrap();
 					if !chan.features.requires_unknown_bits() {
 						if chan.node_one == *$node_id {
@@ -382,7 +385,7 @@ pub fn get_route<L: Deref>(our_node_id: &PublicKey, network: &NetworkGraph, targ
 	match network.get_nodes().get(target) {
 		None => {},
 		Some(node) => {
-			add_entries_to_cheapest_to_target_node!(node, target, 0);
+			add_entries_to_cheapest_to_target_node!(node, target, 0, HashSet::<u64>::new());
 		},
 	}
 
@@ -405,53 +408,85 @@ pub fn get_route<L: Deref>(our_node_id: &PublicKey, network: &NetworkGraph, targ
 		}
 	}
 
-	while let Some(RouteGraphNode { pubkey, lowest_fee_to_node, .. }) = targets.pop() {
-		if pubkey == *our_node_id {
-			let mut res = vec!(dist.remove(&our_node_id).unwrap().3);
-			loop {
-				if let Some(&(_, ref features)) = first_hop_targets.get(&res.last().unwrap().pubkey) {
-					res.last_mut().unwrap().node_features = features.to_context();
-				} else if let Some(node) = network.get_nodes().get(&res.last().unwrap().pubkey) {
-					if let Some(node_info) = node.announcement_info.as_ref() {
-						res.last_mut().unwrap().node_features = node_info.features.clone();
+	let mut payment_paths = Vec::new();
+	let mut channels_to_avoid = HashSet::new();
+	let mut paths_cap = 3; // TODO: be smarter at limiting paths number considering the known available capacity.
+	'route_finding: loop {
+		let mut cur_dist = dist.clone();
+		let mut cur_targets = targets.clone();
+		let mut using_low_capacity_channel = false;
+		while let Some(RouteGraphNode { pubkey, lowest_fee_to_node, .. }) = cur_targets.pop() {
+			if pubkey == *our_node_id {
+				let mut new_entry = cur_dist.remove(&our_node_id).unwrap();
+				let mut res = vec!(new_entry.3.clone());
+				loop {
+					if let Some(&(_, ref features)) = first_hop_targets.get(&res.last().unwrap().pubkey) {
+						res.last_mut().unwrap().node_features = features.to_context();
+					} else if let Some(node) = network.get_nodes().get(&res.last().unwrap().pubkey) {
+						if let Some(node_info) = node.announcement_info.as_ref() {
+							res.last_mut().unwrap().node_features = node_info.features.clone();
+						} else {
+							res.last_mut().unwrap().node_features = NodeFeatures::empty();
+						}
 					} else {
-						res.last_mut().unwrap().node_features = NodeFeatures::empty();
+						// We should be able to fill in features for everything except the last
+						// hop, if the last hop was provided via a BOLT 11 invoice (though we
+						// should be able to extend it further as BOLT 11 does have feature
+						// flags for the last hop node itself).
+						assert!(res.last().unwrap().pubkey == *target);
 					}
-				} else {
-					// We should be able to fill in features for everything except the last
-					// hop, if the last hop was provided via a BOLT 11 invoice (though we
-					// should be able to extend it further as BOLT 11 does have feature
-					// flags for the last hop node itself).
-					assert!(res.last().unwrap().pubkey == *target);
+
+					if let Some(available_msat) = new_entry.4 {
+						if available_msat < recommended_available_msat {
+							using_low_capacity_channel = true;
+						}
+					} else {
+						using_low_capacity_channel = true;
+					}
+
+					if using_low_capacity_channel {
+						// Do not use low-capacity channel for next MPP try.
+						channels_to_avoid.insert(new_entry.3.short_channel_id);
+					}
+
+					// TODO: for next MPP path, reduce the available capacity of channels
+					// used in the MPP path of current iteration.
+
+					if res.last().unwrap().pubkey == *target {
+						break;
+					}
+
+					new_entry = match cur_dist.remove(&res.last().unwrap().pubkey) {
+						Some(hop) => hop,
+						None => return Err(LightningError{err: "Failed to find a non-fee-overflowing path to the given destination".to_owned(), action: ErrorAction::IgnoreError}),
+					};
+					res.last_mut().unwrap().fee_msat = new_entry.3.fee_msat;
+					res.last_mut().unwrap().cltv_expiry_delta = new_entry.3.cltv_expiry_delta;
+					res.push(new_entry.3.clone());
 				}
-				if res.last().unwrap().pubkey == *target {
-					break;
+				res.last_mut().unwrap().fee_msat = final_value_msat;
+				res.last_mut().unwrap().cltv_expiry_delta = final_cltv;
+				payment_paths.push(res);
+				tries += 1;
+				if !using_low_capacity_channel || tries == 5 {
+					break 'route_finding;
 				}
+			}
 
-				let new_entry = match dist.remove(&res.last().unwrap().pubkey) {
-					Some(hop) => hop.3,
-					None => return Err(LightningError{err: "Failed to find a non-fee-overflowing path to the given destination".to_owned(), action: ErrorAction::IgnoreError}),
-				};
-				res.last_mut().unwrap().fee_msat = new_entry.fee_msat;
-				res.last_mut().unwrap().cltv_expiry_delta = new_entry.cltv_expiry_delta;
-				res.push(new_entry);
+			match network.get_nodes().get(&pubkey) {
+				None => {},
+				Some(node) => {
+					add_entries_to_cheapest_to_target_node!(node, &pubkey, lowest_fee_to_node, channels_to_avoid);
+				},
 			}
-			res.last_mut().unwrap().fee_msat = final_value_msat;
-			res.last_mut().unwrap().cltv_expiry_delta = final_cltv;
-			let route = Route { paths: vec![res] };
-			log_trace!(logger, "Got route: {}", log_route!(route));
-			return Ok(route);
 		}
 
-		match network.get_nodes().get(&pubkey) {
-			None => {},
-			Some(node) => {
-				add_entries_to_cheapest_to_target_node!(node, &pubkey, lowest_fee_to_node);
-			},
-		}
+		return Err(LightningError{err: "Failed to find a path to the given destination".to_owned(), action: ErrorAction::IgnoreError});
 	}
 
-	Err(LightningError{err: "Failed to find a path to the given destination".to_owned(), action: ErrorAction::IgnoreError})
+	let route = Route { paths: payment_paths };
+	log_trace!(logger, "Got route: {}", log_route!(route));
+	return Ok(route);
 }
 
 #[cfg(test)]