Add a ChannelTypeFeatures features object for the new channel_type

Its semantics are somewhat different from existing features,
however not enough to merit a different struct entirely.
Specifically, it only supports required features (if you send a
channel_type, the counterparty has to accept it wholesale or try
again, it cannot select only a subset of the flags) and it is
serialized differently (only appearing in TLVs).

Author: TheBlueMatt

lightning/src/ln/features.rs

@@ -194,6 +194,30 @@ mod sealed {
 			BasicMPP,
 		],
 	});
+	// This isn't a "real" feature context, and is only used in the channel_type field in an
+	// `OpenChannel` message.
+	define_context!(ChannelTypeContext {
+		required_features: [
+			// Byte 0
+			,
+			// Byte 1
+			StaticRemoteKey,
+			// Byte 2
+			,
+			// Byte 3
+			,
+		],
+		optional_features: [
+			// Byte 0
+			,
+			// Byte 1
+			,
+			// Byte 2
+			,
+			// Byte 3
+			,
+		],
+	});
 
 	/// Defines a feature with the given bits for the specified [`Context`]s. The generated trait is
 	/// useful for manipulating feature flags.
@@ -325,7 +349,7 @@ mod sealed {
 	define_feature!(9, VariableLengthOnion, [InitContext, NodeContext, InvoiceContext],
 		"Feature flags for `var_onion_optin`.", set_variable_length_onion_optional,
 		set_variable_length_onion_required);
-	define_feature!(13, StaticRemoteKey, [InitContext, NodeContext],
+	define_feature!(13, StaticRemoteKey, [InitContext, NodeContext, ChannelTypeContext],
 		"Feature flags for `option_static_remotekey`.", set_static_remote_key_optional,
 		set_static_remote_key_required);
 	define_feature!(15, PaymentSecret, [InitContext, NodeContext, InvoiceContext],
@@ -388,6 +412,18 @@ pub type ChannelFeatures = Features<sealed::ChannelContext>;
 /// Features used within an invoice.
 pub type InvoiceFeatures = Features<sealed::InvoiceContext>;
 
+/// Features used within the channel_type field in an OpenChannel message.
+///
+/// A channel is always of some known "type", describing the transaction formats used and the exact
+/// semantics of our interaction with our peer.
+///
+/// Note that because a channel is a specific type which is proposed by the opener and accepted by
+/// the counterparty, only required features are allowed here.
+///
+/// This is serialized differently from other feature types - it is not prefixed by a length, and
+/// thus must only appear inside a TLV where its length is known in advance.
+pub type ChannelTypeFeatures = Features<sealed::ChannelTypeContext>;
+
 impl InitFeatures {
 	/// Writes all features present up to, and including, 13.
 	pub(crate) fn write_up_to_13<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
@@ -442,6 +478,21 @@ impl InvoiceFeatures {
 	}
 }
 
+impl ChannelTypeFeatures {
+	/// Constructs the implicit channel type based on the common supported types between us and our
+	/// counterparty
+	pub(crate) fn from_counterparty_init(counterparty_init: &InitFeatures) -> Self {
+		counterparty_init.to_context_internal()
+	}
+
+	/// Constructs a ChannelTypeFeatures with only static_remotekey set
+	pub(crate) fn only_static_remote_key() -> Self {
+		let mut ret = Self::empty();
+		<sealed::ChannelTypeContext as sealed::StaticRemoteKey>::set_required_bit(&mut ret.flags);
+		ret
+	}
+}
+
 impl ToBase32 for InvoiceFeatures {
 	fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
 		// Explanation for the "4": the normal way to round up when dividing is to add the divisor
@@ -553,6 +604,20 @@ impl<T: sealed::Context> Features<T> {
 		&self.flags
 	}
 
+	fn write_be<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		for f in self.flags.iter().rev() { // Swap back to big-endian
+			f.write(w)?;
+		}
+		Ok(())
+	}
+	fn from_be_bytes(mut flags: Vec<u8>) -> Features<T> {
+		flags.reverse(); // Swap to little-endian
+		Self {
+			flags,
+			mark: PhantomData,
+		}
+	}
+
 	/// Returns true if this `Features` object contains unknown feature flags which are set as
 	/// "required".
 	pub fn requires_unknown_bits(&self) -> bool {
@@ -692,25 +757,36 @@ impl<T: sealed::ShutdownAnySegwit> Features<T> {
 		self
 	}
 }
-
-impl<T: sealed::Context> Writeable for Features<T> {
-	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
-		(self.flags.len() as u16).write(w)?;
-		for f in self.flags.iter().rev() { // Swap back to big-endian
-			f.write(w)?;
+macro_rules! impl_feature_len_prefixed_write {
+	($features: ident) => {
+		impl Writeable for $features {
+			fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+				(self.flags.len() as u16).write(w)?;
+				self.write_be(w)
+			}
+		}
+		impl Readable for $features {
+			fn read<R: io::Read>(r: &mut R) -> Result<Self, DecodeError> {
+				Ok(Self::from_be_bytes(Vec::<u8>::read(r)?))
+			}
 		}
-		Ok(())
 	}
 }
+impl_feature_len_prefixed_write!(InitFeatures);
+impl_feature_len_prefixed_write!(ChannelFeatures);
+impl_feature_len_prefixed_write!(NodeFeatures);
+impl_feature_len_prefixed_write!(InvoiceFeatures);
 
-impl<T: sealed::Context> Readable for Features<T> {
+impl Writeable for ChannelTypeFeatures {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		self.write_be(w)
+	}
+}
+impl Readable for ChannelTypeFeatures {
 	fn read<R: io::Read>(r: &mut R) -> Result<Self, DecodeError> {
-		let mut flags: Vec<u8> = Readable::read(r)?;
-		flags.reverse(); // Swap to little-endian
-		Ok(Self {
-			flags,
-			mark: PhantomData,
-		})
+		let mut v = Vec::new();
+		r.read_to_end(&mut v)?;
+		Ok(Self::from_be_bytes(v))
 	}
 }