f adapt to having a RouteHop for the intro node

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -2531,7 +2531,7 @@ where
 		// The top-level caller should hold the total_consistency_lock read lock.
 		debug_assert!(self.total_consistency_lock.try_write().is_err());
 
-		log_trace!(self.logger, "Attempting to send payment for path with next hop {}", path.first_hop_scid());
+		log_trace!(self.logger, "Attempting to send payment for path with next hop {}", path.hops.first().unwrap().short_channel_id);
 		let prng_seed = self.entropy_source.get_secure_random_bytes();
 		let session_priv = SecretKey::from_slice(&session_priv_bytes[..]).expect("RNG is busted");
 
@@ -2544,7 +2544,7 @@ where
 		let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, prng_seed, payment_hash);
 
 		let err: Result<(), _> = loop {
-			let (counterparty_node_id, id) = match self.short_to_chan_info.read().unwrap().get(&path.first_hop_scid()) {
+			let (counterparty_node_id, id) = match self.short_to_chan_info.read().unwrap().get(&path.hops.first().unwrap().short_channel_id) {
 				None => return Err(APIError::ChannelUnavailable{err: "No channel available with first hop!".to_owned()}),
 				Some((cp_id, chan_id)) => (cp_id.clone(), chan_id.clone()),
 			};
@@ -2595,7 +2595,7 @@ where
 			return Ok(());
 		};
 
-		match handle_error!(self, err, path.first_hop_node_id()) {
+		match handle_error!(self, err, path.hops.first().unwrap().pubkey) {
 			Ok(_) => unreachable!(),
 			Err(e) => {
 				Err(APIError::ChannelUnavailable { err: e.err })
@@ -7588,7 +7588,7 @@ where
 				if id_to_peer.get(&monitor.get_funding_txo().0.to_channel_id()).is_none() {
 					for (htlc_source, (htlc, _)) in monitor.get_pending_or_resolved_outbound_htlcs() {
 						if let HTLCSource::OutboundRoute { payment_id, session_priv, path, .. } = htlc_source {
-							if path.len() == 0 {
+							if path.hops.is_empty() {
 								log_error!(args.logger, "Got an empty path for a pending payment");
 								return Err(DecodeError::InvalidValue);
 							}

lightning/src/ln/outbound_payment.rs

@@ -685,8 +685,8 @@ impl OutboundPayments {
 			}
 		};
 		for path in route.paths.iter() {
-			if path.len() == 0 {
-				log_error!(logger, "length-0 path in route");
+			if path.hops.len() == 0 {
+				log_error!(logger, "Unusable path in route (path.hops.len() must be at least 1)");
 				self.abandon_payment(payment_id, PaymentFailureReason::UnexpectedError, pending_events);
 				return
 			}
@@ -827,7 +827,7 @@ impl OutboundPayments {
 				log_error!(logger, "Failed to send along path due to error: {:?}", e);
 				let mut failed_scid = None;
 				if let APIError::ChannelUnavailable { .. } = e {
-					let scid = path.first_hop_scid();
+					let scid = path.hops[0].short_channel_id;
 					failed_scid = Some(scid);
 					route_params.payment_params.previously_failed_channels.push(scid);
 				}
@@ -953,14 +953,11 @@ impl OutboundPayments {
 				path_errs.push(Err(APIError::InvalidRoute{err: "Path didn't go anywhere/had bogus size".to_owned()}));
 				continue 'path_check;
 			}
-			let we_are_intermed_hop = path.blinded_tail.as_ref().map_or_else(
-				|| path.hops.split_last().map_or(false, |(_, path_prefix)| path_prefix.iter().any(|hop| hop.pubkey == our_node_id)),
-				|tail|
-					(tail.path.introduction_node_id == our_node_id && tail.path.blinded_hops.len() > 1)
-					|| path.hops.iter().any(|hop| hop.pubkey == our_node_id));
-			if we_are_intermed_hop {
-				path_errs.push(Err(APIError::InvalidRoute{err: "Path went through us but wasn't a simple rebalance loop to us".to_owned()}));
-				continue 'path_check;
+			for (idx, hop) in path.hops.iter().enumerate() {
+				if idx != path.hops.len() - 1 && hop.pubkey == our_node_id {
+					path_errs.push(Err(APIError::InvalidRoute{err: "Path went through us but wasn't a simple rebalance loop to us".to_owned()}));
+					continue 'path_check;
+				}
 			}
 			total_value += path.final_value_msat();
 			path_errs.push(Ok(()));

lightning/src/routing/router.rs

@@ -299,7 +299,7 @@ impl Path {
 	/// Returns the total amount of fees paid on this [`Path`].
 	pub fn fee_msat(&self) -> u64 {
 		match &self.blinded_tail {
-			Some(tail) => self.hops.iter().map(|hop| hop.fee_msat).sum::<u64>() + tail.fee_msat,
+			Some(_) => self.hops.iter().map(|hop| hop.fee_msat).sum::<u64>(),
 			None =>
 				self.hops.split_last().map_or(0,
 					|(_, path_prefix)| path_prefix.iter().map(|hop| hop.fee_msat).sum())
@@ -318,18 +318,6 @@ impl Path {
 	pub fn len(&self) -> usize {
 		self.hops.len() + self.blinded_tail.as_ref().map_or(0, |tail| tail.hops.len().saturating_sub(1)) // Don't double count the intro node
 	}
-
-	pub(crate) fn first_hop_node_id(&self) -> PublicKey {
-		self.hops.first().map_or_else(
-			|| self.blinded_tail.as_ref().expect("Path had 0 hops").path.introduction_node_id,
-			|hop| hop.pubkey)
-	}
-
-	pub(crate) fn first_hop_scid(&self) -> u64 {
-		self.hops.first().map_or_else(
-			|| self.blinded_tail.as_ref().expect("Path had 0 hops").intro_node_scid,
-			|hop| hop.short_channel_id)
-	}
 }
 
 /// A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP,