Persist retryable HTLCs in ChannelManager

Used in upcoming commits to store retries when payment paths fail, then retry
when processing pending HTLC forwards.

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -46,7 +46,7 @@ use crate::ln::channel::{Channel, ChannelError, ChannelUpdateStatus, UpdateFulfi
 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
 #[cfg(any(feature = "_test_utils", test))]
 use crate::ln::features::InvoiceFeatures;
-use crate::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RoutePath, Router};
+use crate::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, RoutePath, Router};
 use crate::ln::msgs;
 use crate::ln::onion_utils;
 use crate::ln::onion_utils::HTLCFailReason;
@@ -6517,12 +6517,19 @@ where
 			debug_assert!(false, "While we have code to serialize pending_claiming_payments, the map should always be empty until a later PR");
 		}
 
+		let mut retryable_htlcs = None;
+		let our_retryable_htlcs = self.pending_outbound_payments.retryable_htlcs.lock().unwrap();
+		if our_retryable_htlcs.len() != 0 {
+			retryable_htlcs = Some(our_retryable_htlcs);
+		}
+
 		write_tlv_fields!(writer, {
 			(1, pending_outbound_payments_no_retry, required),
 			(2, pending_intercepted_htlcs, option),
 			(3, pending_outbound_payments, required),
 			(4, pending_claiming_payments, option),
 			(5, self.our_network_pubkey, required),
+			(6, retryable_htlcs, option),
 			(7, self.fake_scid_rand_bytes, required),
 			(9, htlc_purposes, vec_type),
 			(11, self.probing_cookie_secret, required),
@@ -6857,6 +6864,7 @@ where
 		let mut pending_outbound_payments_no_retry: Option<HashMap<PaymentId, HashSet<[u8; 32]>>> = None;
 		let mut pending_outbound_payments = None;
 		let mut pending_intercepted_htlcs: Option<HashMap<InterceptId, PendingAddHTLCInfo>> = Some(HashMap::new());
+		let mut retryable_htlcs: Option<Vec<(PaymentId, RouteParameters)>> = Some(Vec::new());
 		let mut received_network_pubkey: Option<PublicKey> = None;
 		let mut fake_scid_rand_bytes: Option<[u8; 32]> = None;
 		let mut probing_cookie_secret: Option<[u8; 32]> = None;
@@ -6868,6 +6876,7 @@ where
 			(3, pending_outbound_payments, option),
 			(4, pending_claiming_payments, option),
 			(5, received_network_pubkey, option),
+			(6, retryable_htlcs, option),
 			(7, fake_scid_rand_bytes, option),
 			(9, claimable_htlc_purposes, vec_type),
 			(11, probing_cookie_secret, option),
@@ -7136,7 +7145,9 @@ where
 			}),
 			inbound_payment_key: expanded_inbound_key,
 			pending_inbound_payments: Mutex::new(pending_inbound_payments),
-			pending_outbound_payments: OutboundPayments { pending_outbound_payments: Mutex::new(pending_outbound_payments.unwrap()) },
+			pending_outbound_payments: OutboundPayments::from_outbounds(
+				pending_outbound_payments.unwrap(),
+				retryable_htlcs.unwrap()),
 			pending_intercepted_htlcs: Mutex::new(pending_intercepted_htlcs.unwrap()),
 
 			forward_htlcs: Mutex::new(forward_htlcs),

lightning/src/ln/outbound_payment.rs

@@ -341,12 +341,25 @@ pub enum PaymentSendFailure {
 
 pub(super) struct OutboundPayments {
 	pub(super) pending_outbound_payments: Mutex<HashMap<PaymentId, PendingOutboundPayment>>,
+	/// HTLCs that may be retried using the given `RouteParameters`.
+	pub(super) retryable_htlcs: Mutex<Vec<(PaymentId, RouteParameters)>>,
 }
 
 impl OutboundPayments {
 	pub(super) fn new() -> Self {
 		Self {
-			pending_outbound_payments: Mutex::new(HashMap::new())
+			pending_outbound_payments: Mutex::new(HashMap::new()),
+			retryable_htlcs: Mutex::new(Vec::new()),
+		}
+	}
+
+	pub(super) fn from_outbounds(
+		pending_outbound_payments: HashMap<PaymentId, PendingOutboundPayment>,
+		retryable_htlcs: Vec<(PaymentId, RouteParameters)>)
+	-> Self {
+		Self {
+			pending_outbound_payments: Mutex::new(pending_outbound_payments),
+			retryable_htlcs: Mutex::new(retryable_htlcs),
 		}
 	}
 

lightning/src/util/ser.rs

@@ -665,6 +665,30 @@ impl Readable for Vec<u8> {
 		Ok(ret)
 	}
 }
+
+impl<A: Writeable, B: Writeable> Writeable for Vec<(A, B)> {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		(self.len() as u16).write(w)?;
+		for item in self.iter() {
+			item.write(w)?;
+		}
+		Ok(())
+	}
+}
+
+impl<A: Readable, B: Readable> Readable for Vec<(A, B)> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let len: u16 = Readable::read(r)?;
+		let mut ret = Vec::with_capacity(len as usize);
+		for _ in 0..len {
+			ret.push(<(A, B) as Readable>::read(r)?);
+		}
+		Ok(ret)
+	}
+}
+
 impl Writeable for Vec<ecdsa::Signature> {
 	#[inline]
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {