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

@@ -783,6 +783,9 @@ pub struct ChannelManager<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: D
 	/// See `ChannelManager` struct-level documentation for lock order requirements.
 	pending_outbound_payments: Mutex<HashMap<PaymentId, PendingOutboundPayment>>,
 
+	/// HTLCs that may be retried using the given `RouteParameters`.
+	retryable_htlcs: Mutex<Vec<(PaymentId, RouteParameters)>>,
+
 	/// SCID/SCID Alias -> forward infos. Key of 0 means payments received.
 	///
 	/// Note that because we may have an SCID Alias as the key we can have two entries per channel,
@@ -1614,6 +1617,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> ChannelManager<
 			outbound_scid_aliases: Mutex::new(HashSet::new()),
 			pending_inbound_payments: Mutex::new(HashMap::new()),
 			pending_outbound_payments: Mutex::new(HashMap::new()),
+			retryable_htlcs: Mutex::new(Vec::new()),
 			forward_htlcs: Mutex::new(HashMap::new()),
 			claimable_payments: Mutex::new(ClaimablePayments { claimable_htlcs: HashMap::new(), pending_claiming_payments: HashMap::new() }),
 			pending_intercepted_htlcs: Mutex::new(HashMap::new()),
@@ -7137,12 +7141,19 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> Writeable for C
 			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.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),
@@ -7473,6 +7484,7 @@ impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>
 		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;
@@ -7484,6 +7496,7 @@ impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>
 			(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),
@@ -7754,6 +7767,7 @@ impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>
 			pending_inbound_payments: Mutex::new(pending_inbound_payments),
 			pending_outbound_payments: Mutex::new(pending_outbound_payments.unwrap()),
 			pending_intercepted_htlcs: Mutex::new(pending_intercepted_htlcs.unwrap()),
+			retryable_htlcs: Mutex::new(retryable_htlcs.unwrap()),
 
 			forward_htlcs: Mutex::new(forward_htlcs),
 			claimable_payments: Mutex::new(ClaimablePayments { claimable_htlcs, pending_claiming_payments: pending_claiming_payments.unwrap() }),

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> {