Define methods on ChannelTypeFeatures for anchors-related logic.

Specifically, introduce a new constructor for an anchors-supporting feature set, as well as methods that will maintain forwards-compatible deserialization in older versions.

Author: arik-so

lightning/src/ln/features.rs

@@ -581,6 +581,66 @@ impl ChannelTypeFeatures {
 		<sealed::ChannelTypeContext as sealed::StaticRemoteKey>::set_required_bit(&mut ret.flags);
 		ret
 	}
+
+	#[cfg(any(anchors, test))]
+	/// Constructs a ChannelTypeFeatures with anchors support
+	pub(crate) fn static_remote_key_with_anchors() -> Self {
+		let mut ret = Self::empty();
+		<sealed::ChannelTypeContext as sealed::StaticRemoteKey>::set_required_bit(&mut ret.flags);
+		<sealed::ChannelTypeContext as sealed::AnchorsZeroFeeHtlcTx>::set_required_bit(&mut ret.flags);
+		ret
+	}
+
+	/// Simplified accessor for checking if anchors are supported
+	pub fn supports_anchors(&self) -> bool {
+		self.supports_anchors_zero_fee_htlc_tx()
+	}
+
+	/// Simplified accessor for verifying support for anchors with nonzero fees
+	pub fn supports_nonzero_fee_anchors(&self) -> bool {
+		self.supports_anchors_nonzero_fee_htlc_tx()
+	}
+
+	/// There are six legacy structs where we need [`ChannelTypeFeatures`] for keeping track of
+	/// anchors and Taproot support. Those six structs are
+	/// — [`ChannelTransactionParameters`]
+	/// — [`CommitmentTransaction`]
+	/// — [`CounterpartyOfferedHTLCOutput`]
+	/// — [`CounterpartyReceivedHTLCOutput`]
+	/// — [`HolderHTLCOutput`]
+	/// — [`HolderFundingOutput`]
+	/// Because pre-anchors versions of LDK do not expect additional fields on those structs,
+	/// non-anchor channels must serialize non-anchor features as empty options, i. e. not
+	/// serialize them at all.
+	/// However, when instantiating those objects based on the full set of features determined
+	/// in at channel construction, any additional feature bits will be lost in legacy channels.
+	/// That would typically trigger an pre- and post-serialization equality check failure, so to
+	/// avoid that, we hereby introduce a method that creates a watered-down, deserialization-safe
+	/// copy.
+	///
+	/// [`ChannelTransactionParameters`]: crate::ln::chan_utils::ChannelTransactionParameters
+	/// [`CommitmentTransaction`]: crate::ln::chan_utils::CommitmentTransaction
+	/// [`CounterpartyOfferedHTLCOutput`]: crate::chain::package::CounterpartyOfferedHTLCOutput
+	/// [`CounterpartyReceivedHTLCOutput`]: crate::chain::package::CounterpartyReceivedHTLCOutput
+	/// [`HolderHTLCOutput`]: crate::chain::package::HolderHTLCOutput
+	/// [`HolderFundingOutput`]: crate::chain::package::HolderFundingOutput
+	pub(crate) fn legacy_serialization_safe_version(&self) -> Self {
+		if self.supports_anchors() {
+			self.clone()
+		} else {
+			Self::only_static_remote_key()
+		}
+	}
+
+	/// To actually serialize the features in a manner that won't break the structs read by
+	/// older versions of LDK, we should skip serialization entirely if anchors are not supported.
+	/// This is a helper method to do just that.
+	pub(crate) fn serializable_option(&self) -> Option<Self> {
+		if !self.supports_anchors() {
+			return None;
+		}
+		Some(self.clone())
+	}
 }
 
 impl ToBase32 for InvoiceFeatures {