make target optional

Author: jbesraa

lightning/src/routing/gossip.rs

@@ -980,7 +980,7 @@ impl Readable for ChannelInfo {
 #[derive(Clone)]
 pub struct DirectedChannelInfo<'a> {
 	/// Provides information about a channel between two nodes.
-	pub channel: &'a ChannelInfo,
+	channel: &'a ChannelInfo,
 	direction: &'a ChannelUpdateInfo,
 	htlc_maximum_msat: u64,
 	effective_capacity: EffectiveCapacity,

lightning/src/routing/router.rs

@@ -131,11 +131,11 @@ impl<'a, S: Deref> ScorerAccountingForInFlightHtlcs<'a, S> where S::Target: Scor
 impl<'a, S: Deref> ScoreLookUp for ScorerAccountingForInFlightHtlcs<'a, S> where S::Target: ScoreLookUp {
 	type ScoreParams = <S::Target as ScoreLookUp>::ScoreParams;
 	fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &Self::ScoreParams) -> u64 {
-		let target = candidate.target();
 		let short_channel_id = match candidate.short_channel_id() {
 			Some(short_channel_id) => short_channel_id,
 			None => return self.scorer.channel_penalty_msat(candidate, usage, score_params),
 		};
+		let target = candidate.target().unwrap();
 		let source = candidate.source();
 		if let Some(used_liquidity) = self.inflight_htlcs.used_liquidity_msat(
 			&source, &target, short_channel_id
@@ -1036,7 +1036,7 @@ pub enum CandidateRouteHop<'a> {
 	/// The payee's identity is concealed behind blinded paths provided in a BOLT 12 invoice.
 	Blinded {
 		/// Hint provides information about a blinded hop, needed while routing through a blinded
-		/// channel.
+		/// path.
 		/// `BlindedPayInfo` provides information needed about the
 		/// payment while routing through a blinded
 		/// path.
@@ -1046,10 +1046,6 @@ pub enum CandidateRouteHop<'a> {
 		/// Provided to uniquely identify a hop as we are
 		/// route building.
 		hint_idx: usize,
-		/// The node id of current hop in route.
-		///
-		/// This will always equal to `maybe_dummy_payee_node_id` in `find_route` method.
-		target_node_id: NodeId,
 	},
 	/// Similar to [`Self::Blinded`], but the path here has 1 blinded hop. `BlindedPayInfo` provided
 	/// for 1-hop blinded paths is ignored because it is meant to apply to the hops *between* the
@@ -1065,10 +1061,6 @@ pub enum CandidateRouteHop<'a> {
 		/// Provided to uniquely identify a hop as we are
 		/// route building.
 		hint_idx: usize,
-		/// The node id of current hop in route.
-		///
-		/// This will always equal to `maybe_dummy_payee_node_id` in `find_route` method.
-		target_node_id: NodeId,
 	},
 }
 
@@ -1158,11 +1150,11 @@ impl<'a> CandidateRouteHop<'a> {
 	///  Returns the id of this hop.
 	///  For `Blinded` and `OneHopBlinded` we return `CandidateHopId::Blinded` because we don't know the channel id.
 	///  For any other option we return `CandidateHopId::Clear` because we know the channel id and the direction.
-	pub fn id(&self, channel_direction: bool /* src_node_id < target_node_id */) -> CandidateHopId {
+	pub fn id(&self, channel_direction: Option<bool> /* src_node_id < target_node_id */) -> CandidateHopId {
 		match self {
 			CandidateRouteHop::Blinded { hint_idx, .. } => CandidateHopId::Blinded(*hint_idx),
 			CandidateRouteHop::OneHopBlinded { hint_idx, .. } => CandidateHopId::Blinded(*hint_idx),
-			_ => CandidateHopId::Clear((self.short_channel_id().unwrap(), channel_direction)),
+			_ => CandidateHopId::Clear((self.short_channel_id().unwrap(), channel_direction.unwrap_or_else(|| self.source() < self.target().unwrap()))),
 		}
 	}
 	fn blinded_path(&self) -> Option<&'a BlindedPath> {
@@ -1195,13 +1187,13 @@ impl<'a> CandidateRouteHop<'a> {
 	/// Target node id refers to the current examined hop in route finding.
 	///
 	/// For `Blinded` and `OneHopBlinded` we return `maybe_dummy_payee_node_id` because we don't know the target.
- 	pub fn target(&self) -> NodeId {
+ 	pub fn target(&self) -> Option<NodeId> {
 		match self {
-			CandidateRouteHop::FirstHop { details, .. } => details.counterparty.node_id.into(),
-			CandidateRouteHop::PublicHop { target_node_id, .. } => *target_node_id,
-			CandidateRouteHop::PrivateHop { target_node_id, .. } => *target_node_id,
-			CandidateRouteHop::Blinded { target_node_id, .. } => *target_node_id,
-			CandidateRouteHop::OneHopBlinded { target_node_id, .. } => *target_node_id,
+			CandidateRouteHop::FirstHop { details, .. } => Some(details.counterparty.node_id.into()),
+			CandidateRouteHop::PublicHop { target_node_id, .. } => Some(*target_node_id),
+			CandidateRouteHop::PrivateHop { target_node_id, .. } => Some(*target_node_id),
+			CandidateRouteHop::Blinded { .. } => None,
+			CandidateRouteHop::OneHopBlinded { .. } => None,
 		}
 	}
 }
@@ -1289,7 +1281,7 @@ impl<'a> core::fmt::Debug for PathBuildingHop<'a> {
 	fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
 		let mut debug_struct = f.debug_struct("PathBuildingHop");
 		debug_struct
-			.field("node_id", &self.candidate.target())
+			.field("node_id", &self.candidate.target().unwrap())
 			.field("short_channel_id", &self.candidate.short_channel_id())
 			.field("total_fee_msat", &self.total_fee_msat)
 			.field("next_hops_fee_msat", &self.next_hops_fee_msat)
@@ -1815,7 +1807,7 @@ where L::Target: Logger {
 		// $next_hops_fee_msat represents the fees paid for using all the channels *after* this one,
 		// since that value has to be transferred over this channel.
 		// Returns the contribution amount of $candidate if the channel caused an update to `targets`.
-		( $candidate: expr, $src_node_id: expr, $dest_node_id: expr, $next_hops_fee_msat: expr,
+		( $candidate: expr, $next_hops_fee_msat: expr,
 			$next_hops_value_contribution: expr, $next_hops_path_htlc_minimum_msat: expr,
 			$next_hops_path_penalty_msat: expr, $next_hops_cltv_delta: expr, $next_hops_path_length: expr ) => { {
 			// We "return" whether we updated the path at the end, and how much we can route via
@@ -1825,7 +1817,9 @@ where L::Target: Logger {
 			// practice these cases should be caught earlier:
 			// - for regular channels at channel announcement (TODO)
 			// - for first and last hops early in get_route
-			if $src_node_id != $dest_node_id {
+			let src_node_id = $candidate.source();
+			let dest_node_id = $candidate.target().unwrap_or(maybe_dummy_payee_node_id);
+			if src_node_id != dest_node_id {
 				let scid_opt = $candidate.short_channel_id();
 				let effective_capacity = $candidate.effective_capacity();
 				let htlc_maximum_msat = max_htlc_from_capacity(effective_capacity, channel_saturation_pow_half);
@@ -1839,7 +1833,7 @@ where L::Target: Logger {
 				// We do this for now, but this is a subject for removal.
 				if let Some(mut available_value_contribution_msat) = htlc_maximum_msat.checked_sub($next_hops_fee_msat) {
 					let used_liquidity_msat = used_liquidities
-						.get(&$candidate.id($src_node_id < $dest_node_id))
+						.get(&$candidate.id(None))
 						.map_or(0, |used_liquidity_msat| {
 							available_value_contribution_msat = available_value_contribution_msat
 								.saturating_sub(*used_liquidity_msat);
@@ -1934,7 +1928,7 @@ where L::Target: Logger {
 						);
 						let path_htlc_minimum_msat = compute_fees_saturating(curr_min, $candidate.fees())
 							.saturating_add(curr_min);
-						let hm_entry = dist.entry($src_node_id);
+						let hm_entry = dist.entry($candidate.source());
 						let old_entry = hm_entry.or_insert_with(|| {
 							// If there was previously no known way to access the source node
 							// (recall it goes payee-to-payer) of short_channel_id, first add a
@@ -1970,7 +1964,7 @@ where L::Target: Logger {
 
 							// Ignore hop_use_fee_msat for channel-from-us as we assume all channels-from-us
 							// will have the same effective-fee
-							if $src_node_id != our_node_id {
+							if src_node_id != our_node_id {
 								// Note that `u64::max_value` means we'll always fail the
 								// `old_entry.total_fee_msat > total_fee_msat` check below
 								hop_use_fee_msat = compute_fees_saturating(amount_to_transfer_over_msat, $candidate.fees());
@@ -1996,7 +1990,7 @@ where L::Target: Logger {
 								let path_penalty_msat = $next_hops_path_penalty_msat
 									.saturating_add(channel_penalty_msat);
 								let new_graph_node = RouteGraphNode {
-									node_id: $src_node_id,
+									node_id: src_node_id,
 									lowest_fee_to_node: total_fee_msat,
 									total_cltv_delta: hop_total_cltv_delta,
 									value_contribution_msat,
@@ -2112,7 +2106,7 @@ where L::Target: Logger {
 				if let Some(first_channels) = first_hop_targets.get(&$node_id) {
 					for details in first_channels {
 						let candidate = CandidateRouteHop::FirstHop { details, node_id: our_node_id };
-						add_entry!(&candidate, our_node_id, $node_id, $fee_to_target_msat,
+						add_entry!(&candidate, $fee_to_target_msat,
 							$next_hops_value_contribution,
 							$next_hops_path_htlc_minimum_msat, $next_hops_path_penalty_msat,
 							$next_hops_cltv_delta, $next_hops_path_length);
@@ -2138,7 +2132,7 @@ where L::Target: Logger {
 											source_node_id: *source,
 											target_node_id: $node_id,
 										};
-										add_entry!(&candidate, *source, $node_id,
+										add_entry!(&candidate,
 											$fee_to_target_msat,
 											$next_hops_value_contribution,
 											$next_hops_path_htlc_minimum_msat,
@@ -2169,7 +2163,7 @@ where L::Target: Logger {
 		payee_node_id_opt.map(|payee| first_hop_targets.get(&payee).map(|first_channels| {
 			for details in first_channels {
 				let candidate = CandidateRouteHop::FirstHop { details, node_id: our_node_id };
-				let added = add_entry!(&candidate, our_node_id, payee, 0, path_value_msat,
+				let added = add_entry!(&candidate, 0, path_value_msat,
 									0, 0u64, 0, 0).is_some();
 				log_trace!(logger, "{} direct route to payee via {}",
 						if added { "Added" } else { "Skipped" }, LoggedCandidateHop(&candidate));
@@ -2203,10 +2197,10 @@ where L::Target: Logger {
 				network_nodes.get(&intro_node_id).is_some();
 			if !have_intro_node_in_graph || our_node_id == intro_node_id { continue }
 			let candidate = if hint.1.blinded_hops.len() == 1 {
-				CandidateRouteHop::OneHopBlinded { hint, hint_idx, target_node_id: maybe_dummy_payee_node_id }
-			} else { CandidateRouteHop::Blinded { hint, hint_idx, target_node_id: maybe_dummy_payee_node_id  } };
+				CandidateRouteHop::OneHopBlinded { hint, hint_idx }
+			} else { CandidateRouteHop::Blinded { hint, hint_idx } };
 			let mut path_contribution_msat = path_value_msat;
-			if let Some(hop_used_msat) = add_entry!(&candidate, intro_node_id, maybe_dummy_payee_node_id,
+			if let Some(hop_used_msat) = add_entry!(&candidate,
 				0, path_contribution_msat, 0, 0_u64, 0, 0)
 			{
 				path_contribution_msat = hop_used_msat;
@@ -2222,7 +2216,7 @@ where L::Target: Logger {
 					};
 					let path_min = candidate.htlc_minimum_msat().saturating_add(
 						compute_fees_saturating(candidate.htlc_minimum_msat(), candidate.fees()));
-					add_entry!(&first_hop_candidate, our_node_id, intro_node_id, blinded_path_fee,
+					add_entry!(&first_hop_candidate, blinded_path_fee,
 						path_contribution_msat, path_min, 0_u64, candidate.cltv_expiry_delta(),
 						candidate.blinded_path().map_or(1, |bp| bp.blinded_hops.len() as u8));
 				}
@@ -2276,7 +2270,7 @@ where L::Target: Logger {
 						})
 						.unwrap_or_else(|| CandidateRouteHop::PrivateHop { hint: hop, target_node_id: target });
 
-					if let Some(hop_used_msat) = add_entry!(&candidate, source, target,
+					if let Some(hop_used_msat) = add_entry!(&candidate,
 						aggregate_next_hops_fee_msat, aggregate_path_contribution_msat,
 						aggregate_next_hops_path_htlc_minimum_msat, aggregate_next_hops_path_penalty_msat,
 						aggregate_next_hops_cltv_delta, aggregate_next_hops_path_length)
@@ -2290,7 +2284,7 @@ where L::Target: Logger {
 					}
 
 					let used_liquidity_msat = used_liquidities
-						.get(&candidate.id(source < target)).copied()
+						.get(&candidate.id(None)).copied()
 						.unwrap_or(0);
 					let channel_usage = ChannelUsage {
 						amount_msat: final_value_msat + aggregate_next_hops_fee_msat,
@@ -2315,7 +2309,7 @@ where L::Target: Logger {
 							recommended_value_msat, our_node_pubkey);
 						for details in first_channels {
 							let first_hop_candidate = CandidateRouteHop::FirstHop { details, node_id: our_node_id};
-							add_entry!(&first_hop_candidate, our_node_id, NodeId::from_pubkey(&prev_hop_id),
+							add_entry!(&first_hop_candidate,
 								aggregate_next_hops_fee_msat, aggregate_path_contribution_msat,
 								aggregate_next_hops_path_htlc_minimum_msat, aggregate_next_hops_path_penalty_msat,
 								aggregate_next_hops_cltv_delta, aggregate_next_hops_path_length);
@@ -2360,8 +2354,7 @@ where L::Target: Logger {
 								recommended_value_msat, our_node_pubkey);
 							for details in first_channels {
 								let first_hop_candidate = CandidateRouteHop::FirstHop { details, node_id: our_node_id};
-								add_entry!(&first_hop_candidate, our_node_id,
-									NodeId::from_pubkey(&hop.src_node_id),
+								add_entry!(&first_hop_candidate,
 									aggregate_next_hops_fee_msat,
 									aggregate_path_contribution_msat,
 									aggregate_next_hops_path_htlc_minimum_msat,
@@ -2400,7 +2393,7 @@ where L::Target: Logger {
 
 				'path_walk: loop {
 					let mut features_set = false;
-					if let Some(first_channels) = first_hop_targets.get(&ordered_hops.last().unwrap().0.candidate.target()) {
+					if let Some(first_channels) = first_hop_targets.get(&ordered_hops.last().unwrap().0.candidate.target().unwrap_or(maybe_dummy_payee_node_id)) {
 						for details in first_channels {
 							if let Some(scid) = ordered_hops.last().unwrap().0.candidate.short_channel_id() {
 								if details.get_outbound_payment_scid().unwrap() == scid {
@@ -2412,7 +2405,7 @@ where L::Target: Logger {
 						}
 					}
 					if !features_set {
-						if let Some(node) = network_nodes.get(&ordered_hops.last().unwrap().0.candidate.target()) {
+						if let Some(node) = network_nodes.get(&ordered_hops.last().unwrap().0.candidate.target().unwrap_or(maybe_dummy_payee_node_id)) {
 							if let Some(node_info) = node.announcement_info.as_ref() {
 								ordered_hops.last_mut().unwrap().1 = node_info.features.clone();
 							} else {
@@ -2429,11 +2422,11 @@ where L::Target: Logger {
 					// save this path for the payment route. Also, update the liquidity
 					// remaining on the used hops, so that we take them into account
 					// while looking for more paths.
-					if ordered_hops.last().unwrap().0.candidate.target() == maybe_dummy_payee_node_id {
+					if ordered_hops.last().unwrap().0.candidate.target().unwrap_or(maybe_dummy_payee_node_id) == maybe_dummy_payee_node_id {
 						break 'path_walk;
 					}
 
-					new_entry = match dist.remove(&ordered_hops.last().unwrap().0.candidate.target()) {
+					new_entry = match dist.remove(&ordered_hops.last().unwrap().0.candidate.target().unwrap_or(maybe_dummy_payee_node_id)) {
 						Some(payment_hop) => payment_hop,
 						// We can't arrive at None because, if we ever add an entry to targets,
 						// we also fill in the entry in dist (see add_entry!).
@@ -2473,12 +2466,11 @@ where L::Target: Logger {
 				// on the same liquidity in future paths.
 				let mut prevented_redundant_path_selection = false;
 				let prev_hop_iter = core::iter::once(our_node_id)
-					.chain(payment_path.hops.iter().map(|(hop, _)| hop.candidate.target()));
-				for (prev_hop, (hop, _)) in prev_hop_iter.zip(payment_path.hops.iter()) {
-					let target = hop.candidate.target();
+					.chain(payment_path.hops.iter().map(|(hop, _)| hop.candidate.target().unwrap_or(maybe_dummy_payee_node_id)));
+				for (_, (hop, _)) in prev_hop_iter.zip(payment_path.hops.iter()) {
 					let spent_on_hop_msat = value_contribution_msat + hop.next_hops_fee_msat;
 					let used_liquidity_msat = used_liquidities
-						.entry(hop.candidate.id(prev_hop < target))
+						.entry(hop.candidate.id(None))
 						.and_modify(|used_liquidity_msat| *used_liquidity_msat += spent_on_hop_msat)
 						.or_insert(spent_on_hop_msat);
 					let hop_capacity = hop.candidate.effective_capacity();
@@ -2499,8 +2491,8 @@ where L::Target: Logger {
 					log_trace!(logger,
 						"Disabling route candidate {} for future path building iterations to avoid duplicates.",
 						LoggedCandidateHop(victim_candidate));
-					*used_liquidities.entry(victim_candidate.id(false)).or_default() = exhausted;
-					*used_liquidities.entry(victim_candidate.id(true)).or_default() = exhausted;
+					*used_liquidities.entry(victim_candidate.id(Some(false))).or_default() = exhausted;
+					*used_liquidities.entry(victim_candidate.id(Some(true))).or_default() = exhausted;
 				}
 
 				// Track the total amount all our collected paths allow to send so that we know
@@ -2646,15 +2638,15 @@ where L::Target: Logger {
 	selected_route.sort_unstable_by_key(|path| {
 		let mut key = [CandidateHopId::Clear((42, true)) ; MAX_PATH_LENGTH_ESTIMATE as usize];
 		debug_assert!(path.hops.len() <= key.len());
-		for (scid, key) in path.hops.iter() .map(|h| h.0.candidate.id(true)).zip(key.iter_mut()) {
+		for (scid, key) in path.hops.iter() .map(|h| h.0.candidate.id(Some(true))).zip(key.iter_mut()) {
 			*key = scid;
 		}
 		key
 	});
 	for idx in 0..(selected_route.len() - 1) {
 		if idx + 1 >= selected_route.len() { break; }
-		if iter_equal(selected_route[idx    ].hops.iter().map(|h| (h.0.candidate.id(true), h.0.candidate.target())),
-		              selected_route[idx + 1].hops.iter().map(|h| (h.0.candidate.id(true), h.0.candidate.target()))) {
+		if iter_equal(selected_route[idx    ].hops.iter().map(|h| (h.0.candidate.id(Some(true)), h.0.candidate.target().unwrap_or(maybe_dummy_payee_node_id))),
+		              selected_route[idx + 1].hops.iter().map(|h| (h.0.candidate.id(Some(true)), h.0.candidate.target().unwrap_or(maybe_dummy_payee_node_id)))) {
 			let new_value = selected_route[idx].get_value_msat() + selected_route[idx + 1].get_value_msat();
 			selected_route[idx].update_value_and_recompute_fees(new_value);
 			selected_route.remove(idx + 1);
@@ -2679,14 +2671,14 @@ where L::Target: Logger {
 				// there are announced channels between the endpoints. If so, the hop might be
 				// referring to any of the announced channels, as its `short_channel_id` might be
 				// an alias, in which case we don't take any chances here.
-				network_graph.node(&hop.candidate.target()).map_or(false, |hop_node|
+				network_graph.node(&hop.candidate.target().unwrap_or(maybe_dummy_payee_node_id)).map_or(false, |hop_node|
 					hop_node.channels.iter().any(|scid| network_graph.channel(*scid)
 							.map_or(false, |c| c.as_directed_from(&prev_hop_node_id).is_some()))
 				)
 			};
 
 			hops.push(RouteHop {
-				pubkey: PublicKey::from_slice(hop.candidate.target().as_slice()).map_err(|_| LightningError{err: format!("Public key {:?} is invalid", &hop.candidate.target()), action: ErrorAction::IgnoreAndLog(Level::Trace)})?,
+				pubkey: PublicKey::from_slice(hop.candidate.target().unwrap().as_slice()).map_err(|_| LightningError{err: format!("Public key {:?} is invalid", &hop.candidate.target().unwrap_or(maybe_dummy_payee_node_id).as_slice()), action: ErrorAction::IgnoreAndLog(Level::Trace)})?,
 				node_features: node_features.clone(),
 				short_channel_id: hop.candidate.short_channel_id().unwrap(),
 				channel_features: hop.candidate.features(),
@@ -2695,7 +2687,7 @@ where L::Target: Logger {
 				maybe_announced_channel,
 			});
 
-			prev_hop_node_id = hop.candidate.target();
+			prev_hop_node_id = hop.candidate.target().unwrap_or(maybe_dummy_payee_node_id);
 		}
 		let mut final_cltv_delta = final_cltv_expiry_delta;
 		let blinded_tail = payment_path.hops.last().and_then(|(h, _)| {
@@ -2861,7 +2853,7 @@ fn build_route_from_hops_internal<L: Deref>(
 		fn channel_penalty_msat(&self, candidate: &CandidateRouteHop,
 			_usage: ChannelUsage, _score_params: &Self::ScoreParams) -> u64
 		{
-			let target = candidate.target();
+			let target = candidate.target().unwrap();
 			let source = candidate.source();
 			let mut cur_id = self.our_node_id;
 			for i in 0..self.hop_ids.len() {
@@ -6237,7 +6229,7 @@ mod tests {
 	impl ScoreLookUp for BadNodeScorer {
 		type ScoreParams = ();
 		fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, _: ChannelUsage, _score_params:&Self::ScoreParams) -> u64 {
-			let target = candidate.target();
+			let target = candidate.target().unwrap();
 			if target == self.node_id { u64::max_value() } else { 0 }
 		}
 	}