f clarify payee node id vars in get_route and switch to debug assertion

Author: valentinewallace

lightning/src/routing/router.rs

@@ -1138,13 +1138,16 @@ pub(crate) fn get_route<L: Deref, S: Score>(
 	_random_seed_bytes: &[u8; 32]
 ) -> Result<Route, LightningError>
 where L::Target: Logger {
-	let payee_node_id = payment_params.payee.node_id().map(|pk| NodeId::from_pubkey(&pk));
+	// If we're routing to a blinded recipient, we won't have their node id. Therefore, keep the
+	// unblinded payee id as an option. We also need a non-optional "payee id" for path construction,
+	// so use a dummy id for this in the blinded case.
+	let payee_node_id_opt = payment_params.payee.node_id().map(|pk| NodeId::from_pubkey(&pk));
 	const DUMMY_BLINDED_PAYEE_ID: [u8; 33] = [42u8; 33];
-	let target_pubkey = payment_params.payee.node_id().unwrap_or_else(|| PublicKey::from_slice(&DUMMY_BLINDED_PAYEE_ID).unwrap());
-	let target_node_id = NodeId::from_pubkey(&target_pubkey);
+	let maybe_dummy_payee_pk = payment_params.payee.node_id().unwrap_or_else(|| PublicKey::from_slice(&DUMMY_BLINDED_PAYEE_ID).unwrap());
+	let maybe_dummy_payee_node_id = NodeId::from_pubkey(&maybe_dummy_payee_pk);
 	let our_node_id = NodeId::from_pubkey(&our_node_pubkey);
 
-	if payee_node_id.map_or(false, |payee| payee == our_node_id) {
+	if payee_node_id_opt.map_or(false, |payee| payee == our_node_id) {
 		return Err(LightningError{err: "Cannot generate a route to ourselves".to_owned(), action: ErrorAction::IgnoreError});
 	}
 
@@ -1243,7 +1246,7 @@ where L::Target: Logger {
 		false
 	} else if let Some(features) = &payment_params.features {
 		features.supports_basic_mpp()
-	} else if let Some(payee) = payee_node_id {
+	} else if let Some(payee) = payee_node_id_opt {
 		network_nodes.get(&payee).map_or(false, |node| node.announcement_info.as_ref().map_or(false,
 			|info| info.features.supports_basic_mpp()))
 	} else { false };
@@ -1603,7 +1606,7 @@ where L::Target: Logger {
 				// Entries are added to dist in add_entry!() when there is a channel from a node.
 				// Because there are no channels from payee, it will not have a dist entry at this point.
 				// If we're processing any other node, it is always be the result of a channel from it.
-				assert_eq!($node_id, target_node_id);
+				debug_assert_eq!($node_id, maybe_dummy_payee_node_id);
 				false
 			};
 
@@ -1663,7 +1666,7 @@ where L::Target: Logger {
 
 		// If first hop is a private channel and the only way to reach the payee, this is the only
 		// place where it could be added.
-		payee_node_id.map(|payee| first_hop_targets.get(&payee).map(|first_channels| {
+		payee_node_id_opt.map(|payee| first_hop_targets.get(&payee).map(|first_channels| {
 			for details in first_channels {
 				let candidate = CandidateRouteHop::FirstHop { details };
 				let added = add_entry!(candidate, our_node_id, payee, 0, path_value_msat,
@@ -1675,7 +1678,7 @@ where L::Target: Logger {
 
 		// Add the payee as a target, so that the payee-to-payer
 		// search algorithm knows what to start with.
-		payee_node_id.map(|payee| match network_nodes.get(&payee) {
+		payee_node_id_opt.map(|payee| match network_nodes.get(&payee) {
 			// The payee is not in our network graph, so nothing to add here.
 			// There is still a chance of reaching them via last_hops though,
 			// so don't yet fail the payment here.
@@ -1706,7 +1709,7 @@ where L::Target: Logger {
 				// We start building the path from reverse, i.e., from payee
 				// to the first RouteHintHop in the path.
 				let hop_iter = route.0.iter().rev();
-				let prev_hop_iter = core::iter::once(&target_pubkey).chain(
+				let prev_hop_iter = core::iter::once(&maybe_dummy_payee_pk).chain(
 					route.0.iter().skip(1).rev().map(|hop| &hop.src_node_id));
 				let mut hop_used = true;
 				let mut aggregate_next_hops_fee_msat: u64 = 0;
@@ -1866,7 +1869,7 @@ 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.node_id == target_node_id {
+					if ordered_hops.last().unwrap().0.node_id == maybe_dummy_payee_node_id {
 						break 'path_walk;
 					}
 
@@ -1949,7 +1952,7 @@ where L::Target: Logger {
 			// If we found a path back to the payee, we shouldn't try to process it again. This is
 			// the equivalent of the `elem.was_processed` check in
 			// add_entries_to_cheapest_to_target_node!() (see comment there for more info).
-			if node_id == target_node_id { continue 'path_construction; }
+			if node_id == maybe_dummy_payee_node_id { continue 'path_construction; }
 
 			// Otherwise, since the current target node is not us,
 			// keep "unrolling" the payment graph from payee to payer by