f Fix CounterpartyForwardingInfo htlc min/max

Author: ViktorTigerstrom

lightning/src/ln/channel.rs

@@ -5384,16 +5384,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 {
+		let outbound_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,
-			htlc_minimum_msat: msg.contents.htlc_minimum_msat,
-			htlc_maximum_msat,
+			outbound_htlc_minimum_msat: msg.contents.htlc_minimum_msat,
+			outbound_htlc_maximum_msat,
 		});
 
 		Ok(())
@@ -5780,16 +5780,12 @@ 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)?
 		}
@@ -5852,7 +5848,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),
+			(23, self.counterparty_forwarding_info.as_ref().map(|info| info.outbound_htlc_maximum_msat).unwrap_or(None), option),
 		});
 
 		Ok(())
@@ -6051,28 +6047,16 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 			let _dummy: u32 = 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,
+		// Read fields for `CounterpartyForwardingInfo`. As the `outbound_htlc_maximum_msat` is a
+		// TLV Optional variant, we construct the `CounterpartyForwardingInfo` struct after it ha
+		// been read.
+		let (has_forwarding_info, fee_base_msat, fee_proportional_millionths, cltv_expiry_delta) = match <u8 as Readable>::read(reader)? {
+			0 => (false, 0, 0, 0),
 			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
+				let fee_base_msat: u32 = Readable::read(reader)?;
+				let fee_proportional_millionths: u32 = Readable::read(reader)?;
+				let cltv_expiry_delta: u16 = Readable::read(reader)?;
+				(true, fee_base_msat, fee_proportional_millionths, cltv_expiry_delta)
 			},
 			_ => return Err(DecodeError::InvalidValue),
 		};
@@ -6126,6 +6110,7 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 		let mut announcement_sigs_state = Some(AnnouncementSigsState::NotSent);
 		let mut latest_inbound_scid_alias = None;
 		let mut outbound_scid_alias = None;
+		let mut outbound_htlc_maximum_msat = None;
 
 		read_tlv_fields!(reader, {
 			(0, announcement_sigs, option),
@@ -6143,19 +6128,19 @@ 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),
+			(23, outbound_htlc_maximum_msat, option),
 		});
 
 		// Construct the `CounterpartyForwardingInfo` after the TLV Optional variant for
-		// `htlc_maximum_msat` has been read.
+		// `outbound_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
+				outbound_htlc_minimum_msat: counterparty_htlc_minimum_msat,
+				outbound_htlc_maximum_msat
 			})
 		};
 

lightning/src/ln/channelmanager.rs

@@ -1160,9 +1160,9 @@ pub struct CounterpartyForwardingInfo {
 	/// `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,
+	pub outbound_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>,
+	pub outbound_htlc_maximum_msat: Option<u64>,
 }
 
 /// Channel parameters which apply to our counterparty. These are split out from [`ChannelDetails`]
@@ -6058,8 +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),
+	(7, outbound_htlc_minimum_msat, required),
+	(8, outbound_htlc_maximum_msat, option),
 });
 
 impl_writeable_tlv_based!(ChannelCounterparty, {