Add htcl min/max to CounterpartyForwardingInfo

Author: ViktorTigerstrom

lightning/src/ln/channel.rs

@@ -4310,6 +4310,11 @@ impl<Signer: Sign> Channel<Signer> {
 		self.counterparty_htlc_minimum_msat
 	}
 
+	/// Allowed in any state (including after shutdown), but will return none before TheirInitSent
+	pub fn get_counterparty_htlc_max_msat(&self) -> Option<u64> {
+		self.get_htlc_max_msat(self.counterparty_max_htlc_value_in_flight_msat)
+	}
+
 	/// Allowed in any state (including after shutdown), but will return none before TheirInitSent
 	fn get_htlc_max_msat(&self, inflight_value_of_party: u64)  -> Option<u64> {
 		if self.channel_state >= ChannelState::TheirInitSent as u32 {
@@ -5389,10 +5394,16 @@ impl<Signer: Sign> Channel<Signer> {
 		if msg.contents.htlc_minimum_msat >= self.channel_value_satoshis * 1000 {
 			return Err(ChannelError::Close("Minimum htlc value is greater than channel value".to_string()));
 		}
+		let htlc_maximum_msat = match msg.contents.htlc_maximum_msat {
+			OptionalField::Present(htcl_max) => Some(htcl_max),
+			OptionalField::Absent => None
+		};
 		self.counterparty_forwarding_info = Some(CounterpartyForwardingInfo {
 			fee_base_msat: msg.contents.fee_base_msat,
 			fee_proportional_millionths: msg.contents.fee_proportional_millionths,
-			cltv_expiry_delta: msg.contents.cltv_expiry_delta
+			cltv_expiry_delta: msg.contents.cltv_expiry_delta,
+			htlc_minimum_msat: msg.contents.htlc_minimum_msat,
+			htlc_maximum_msat,
 		});
 
 		Ok(())
@@ -5779,12 +5790,16 @@ impl<Signer: Sign> Writeable for Channel<Signer> {
 		// Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
 		self.minimum_depth.unwrap_or(0).write(writer)?;
 
+		let mut htlc_maximum_msat = None;
 		match &self.counterparty_forwarding_info {
 			Some(info) => {
 				1u8.write(writer)?;
 				info.fee_base_msat.write(writer)?;
 				info.fee_proportional_millionths.write(writer)?;
 				info.cltv_expiry_delta.write(writer)?;
+				// Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
+				info.htlc_maximum_msat.unwrap_or(0).write(writer)?;
+				htlc_maximum_msat = info.htlc_maximum_msat;
 			},
 			None => 0u8.write(writer)?
 		}
@@ -5847,6 +5862,7 @@ impl<Signer: Sign> Writeable for Channel<Signer> {
 			(17, self.announcement_sigs_state, required),
 			(19, self.latest_inbound_scid_alias, option),
 			(21, self.outbound_scid_alias, required),
+			(23, htlc_maximum_msat, option),
 		});
 
 		Ok(())
@@ -6045,13 +6061,29 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 			let _dummy: u32 = Readable::read(reader)?;
 		}
 
-		let counterparty_forwarding_info = match <u8 as Readable>::read(reader)? {
-			0 => None,
-			1 => Some(CounterpartyForwardingInfo {
-				fee_base_msat: Readable::read(reader)?,
-				fee_proportional_millionths: Readable::read(reader)?,
-				cltv_expiry_delta: Readable::read(reader)?,
-			}),
+		// Read fields for `CounterpartyForwardingInfo`. As the `htlc_maximum_msat` may be
+		// updated after the TLV Optional variant has been read depending on if they're used,
+		// we construct the `CounterpartyForwardingInfo` struct after TLV Optional variants
+		// have been read.
+		let mut fee_base_msat: u32 = 0;
+		let mut fee_proportional_millionths: u32 = 0;
+		let mut cltv_expiry_delta: u16 = 0;
+		let mut htlc_maximum_msat = None;
+		let has_forwarding_info = match <u8 as Readable>::read(reader)? {
+			0 => false,
+			1 => {
+				fee_base_msat = Readable::read(reader)?;
+				fee_proportional_millionths = Readable::read(reader)?;
+				cltv_expiry_delta = Readable::read(reader)?;
+				if ver == 1 {
+					// Read the old serialization from version 0.0.98.
+					htlc_maximum_msat = Some(Readable::read(reader)?);
+				} else {
+					// Read the 8 bytes of backwards-compatibility data.
+					let _dummy: u64 = Readable::read(reader)?;
+				}
+				true
+			},
 			_ => return Err(DecodeError::InvalidValue),
 		};
 
@@ -6121,8 +6153,22 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 			(17, announcement_sigs_state, option),
 			(19, latest_inbound_scid_alias, option),
 			(21, outbound_scid_alias, option),
+			(23, htlc_maximum_msat, option),
 		});
 
+		// Construct the `CounterpartyForwardingInfo` after the TLV Optional variant for
+		// `htlc_maximum_msat` has been read.
+		let counterparty_forwarding_info = match has_forwarding_info {
+			false => None,
+			true => Some(CounterpartyForwardingInfo {
+				fee_base_msat,
+				fee_proportional_millionths,
+				cltv_expiry_delta,
+				htlc_minimum_msat: counterparty_htlc_minimum_msat,
+				htlc_maximum_msat
+			})
+		};
+
 		if let Some(preimages) = preimages_opt {
 			let mut iter = preimages.into_iter();
 			for htlc in pending_outbound_htlcs.iter_mut() {

lightning/src/ln/channelmanager.rs

@@ -1159,6 +1159,10 @@ pub struct CounterpartyForwardingInfo {
 	/// such that the outgoing HTLC is forwardable to this counterparty. See `msgs::ChannelUpdate`'s
 	/// `cltv_expiry_delta` for more details.
 	pub cltv_expiry_delta: u16,
+	/// The smallest value HTLC (in msat) the remote peer will accept, for this channel.
+	pub htlc_minimum_msat: u64,
+	/// The largest value HTLC (in msat) the remote peer currently will accept, for this channel.
+	pub htlc_maximum_msat: Option<u64>,
 }
 
 /// Channel parameters which apply to our counterparty. These are split out from [`ChannelDetails`]
@@ -6054,6 +6058,8 @@ impl_writeable_tlv_based!(CounterpartyForwardingInfo, {
 	(2, fee_base_msat, required),
 	(4, fee_proportional_millionths, required),
 	(6, cltv_expiry_delta, required),
+	(8, htlc_minimum_msat, required),
+	(10, htlc_maximum_msat, option),
 });
 
 impl_writeable_tlv_based!(ChannelCounterparty, {