+impl_feature_tlv_write!(ChannelTypeFeatures);
+
+// Some features may appear both in a TLV record and as part of a TLV subtype sequence. The latter
+// requires a length but the former does not.
+
+impl<T: sealed::Context> Writeable for WithoutLength<&Features<T>> {
+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+ self.0.write_be(w)
+ }
+}
+
+impl<T: sealed::Context> Readable for WithoutLength<Features<T>> {
+ fn read<R: io::Read>(r: &mut R) -> Result<Self, DecodeError> {
+ let v = io_extras::read_to_end(r)?;
+ Ok(WithoutLength(Features::<T>::from_be_bytes(v)))
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, Bolt11InvoiceFeatures, NodeFeatures, OfferFeatures, sealed};
+ use bitcoin::bech32::{Base32Len, FromBase32, ToBase32, u5};
+ use crate::util::ser::{Readable, WithoutLength, Writeable};
+
+ #[test]
+ fn sanity_test_unknown_bits() {
+ let features = ChannelFeatures::empty();
+ assert!(!features.requires_unknown_bits());
+ assert!(!features.supports_unknown_bits());
+
+ let mut features = ChannelFeatures::empty();
+ features.set_unknown_feature_required();
+ assert!(features.requires_unknown_bits());
+ assert!(features.supports_unknown_bits());
+
+ let mut features = ChannelFeatures::empty();
+ features.set_unknown_feature_optional();
+ assert!(!features.requires_unknown_bits());
+ assert!(features.supports_unknown_bits());
+ }
+
+ #[test]
+ fn requires_unknown_bits_from() {
+ let mut features1 = InitFeatures::empty();
+ let mut features2 = InitFeatures::empty();
+ assert!(!features1.requires_unknown_bits_from(&features2));
+ assert!(!features2.requires_unknown_bits_from(&features1));
+
+ features1.set_data_loss_protect_required();
+ assert!(features1.requires_unknown_bits_from(&features2));
+ assert!(!features2.requires_unknown_bits_from(&features1));
+
+ features2.set_data_loss_protect_optional();
+ assert!(!features1.requires_unknown_bits_from(&features2));
+ assert!(!features2.requires_unknown_bits_from(&features1));
+
+ features2.set_gossip_queries_required();
+ assert!(!features1.requires_unknown_bits_from(&features2));
+ assert!(features2.requires_unknown_bits_from(&features1));
+
+ features1.set_gossip_queries_optional();
+ assert!(!features1.requires_unknown_bits_from(&features2));
+ assert!(!features2.requires_unknown_bits_from(&features1));
+
+ features1.set_variable_length_onion_required();
+ assert!(features1.requires_unknown_bits_from(&features2));
+ assert!(!features2.requires_unknown_bits_from(&features1));
+
+ features2.set_variable_length_onion_optional();
+ assert!(!features1.requires_unknown_bits_from(&features2));
+ assert!(!features2.requires_unknown_bits_from(&features1));
+
+ features1.set_basic_mpp_required();
+ features2.set_wumbo_required();
+ assert!(features1.requires_unknown_bits_from(&features2));
+ assert!(features2.requires_unknown_bits_from(&features1));
+ }
+
+ #[test]
+ fn convert_to_context_with_relevant_flags() {
+ let mut init_features = InitFeatures::empty();
+ // Set a bunch of features we use, plus initial_routing_sync_required (which shouldn't get
+ // converted as it's only relevant in an init context).
+ init_features.set_initial_routing_sync_required();
+ init_features.set_data_loss_protect_required();
+ init_features.set_variable_length_onion_required();
+ init_features.set_static_remote_key_required();
+ init_features.set_payment_secret_required();
+ init_features.set_basic_mpp_optional();
+ init_features.set_wumbo_optional();
+ init_features.set_anchors_zero_fee_htlc_tx_optional();
+ init_features.set_route_blinding_optional();
+ init_features.set_shutdown_any_segwit_optional();
+ init_features.set_onion_messages_optional();
+ init_features.set_channel_type_optional();
+ init_features.set_scid_privacy_optional();
+ init_features.set_zero_conf_optional();
+
+ assert!(init_features.initial_routing_sync());
+ assert!(!init_features.supports_upfront_shutdown_script());
+ assert!(!init_features.supports_gossip_queries());
+
+ let node_features: NodeFeatures = init_features.to_context();
+ {
+ // Check that the flags are as expected:
+ // - option_data_loss_protect (req)
+ // - var_onion_optin (req) | static_remote_key (req) | payment_secret(req)
+ // - basic_mpp | wumbo | option_anchors_zero_fee_htlc_tx
+ // - option_route_blinding | opt_shutdown_anysegwit
+ // - onion_messages
+ // - option_channel_type | option_scid_alias
+ // - option_zeroconf
+ assert_eq!(node_features.flags.len(), 7);
+ assert_eq!(node_features.flags[0], 0b00000001);
+ assert_eq!(node_features.flags[1], 0b01010001);
+ assert_eq!(node_features.flags[2], 0b10001010);
+ assert_eq!(node_features.flags[3], 0b00001010);
+ assert_eq!(node_features.flags[4], 0b10000000);
+ assert_eq!(node_features.flags[5], 0b10100000);
+ assert_eq!(node_features.flags[6], 0b00001000);
+ }
+
+ // Check that cleared flags are kept blank when converting back:
+ // - initial_routing_sync was not applicable to NodeContext
+ // - upfront_shutdown_script was cleared before converting
+ // - gossip_queries was cleared before converting
+ let features: InitFeatures = node_features.to_context_internal();
+ assert!(!features.initial_routing_sync());
+ assert!(!features.supports_upfront_shutdown_script());
+ assert!(!init_features.supports_gossip_queries());
+ }
+
+ #[test]
+ fn convert_to_context_with_unknown_flags() {
+ // Ensure the `from` context has fewer known feature bytes than the `to` context.
+ assert!(<sealed::ChannelContext as sealed::Context>::KNOWN_FEATURE_MASK.len() <
+ <sealed::Bolt11InvoiceContext as sealed::Context>::KNOWN_FEATURE_MASK.len());
+ let mut channel_features = ChannelFeatures::empty();
+ channel_features.set_unknown_feature_optional();
+ assert!(channel_features.supports_unknown_bits());
+ let invoice_features: Bolt11InvoiceFeatures = channel_features.to_context_internal();
+ assert!(!invoice_features.supports_unknown_bits());
+ }
+
+ #[test]
+ fn set_feature_bits() {
+ let mut features = Bolt11InvoiceFeatures::empty();
+ features.set_basic_mpp_optional();
+ features.set_payment_secret_required();
+ assert!(features.supports_basic_mpp());
+ assert!(!features.requires_basic_mpp());
+ assert!(features.requires_payment_secret());
+ assert!(features.supports_payment_secret());
+
+ // Set flags manually
+ let mut features = NodeFeatures::empty();
+ assert!(features.set_optional_feature_bit(55).is_ok());
+ assert!(features.supports_keysend());
+ assert!(features.set_optional_feature_bit(255).is_ok());
+ assert!(features.set_required_feature_bit(256).is_err());
+ }
+
+ #[test]
+ fn set_custom_bits() {
+ let mut features = Bolt11InvoiceFeatures::empty();
+ features.set_variable_length_onion_optional();
+ assert_eq!(features.flags[1], 0b00000010);
+
+ assert!(features.set_optional_custom_bit(255).is_err());
+ assert!(features.set_required_custom_bit(256).is_ok());
+ assert!(features.set_required_custom_bit(258).is_ok());
+ assert_eq!(features.flags[31], 0b00000000);
+ assert_eq!(features.flags[32], 0b00000101);
+
+ let known_bit = <sealed::Bolt11InvoiceContext as sealed::PaymentSecret>::EVEN_BIT;
+ let byte_offset = <sealed::Bolt11InvoiceContext as sealed::PaymentSecret>::BYTE_OFFSET;
+ assert_eq!(byte_offset, 1);
+ assert_eq!(features.flags[byte_offset], 0b00000010);
+ assert!(features.set_required_custom_bit(known_bit).is_err());
+ assert_eq!(features.flags[byte_offset], 0b00000010);
+
+ let mut features = Bolt11InvoiceFeatures::empty();
+ assert!(features.set_optional_custom_bit(256).is_ok());
+ assert!(features.set_optional_custom_bit(259).is_ok());
+ assert_eq!(features.flags[32], 0b00001010);
+
+ let mut features = Bolt11InvoiceFeatures::empty();
+ assert!(features.set_required_custom_bit(257).is_ok());
+ assert!(features.set_required_custom_bit(258).is_ok());
+ assert_eq!(features.flags[32], 0b00000101);
+ }
+
+ #[test]
+ fn encodes_features_without_length() {
+ let features = OfferFeatures::from_le_bytes(vec![1, 2, 3, 4, 5, 42, 100, 101]);
+ assert_eq!(features.flags.len(), 8);
+
+ let mut serialized_features = Vec::new();
+ WithoutLength(&features).write(&mut serialized_features).unwrap();
+ assert_eq!(serialized_features.len(), 8);
+
+ let deserialized_features =
+ WithoutLength::<OfferFeatures>::read(&mut &serialized_features[..]).unwrap().0;
+ assert_eq!(features, deserialized_features);
+ }
+
+ #[test]
+ fn invoice_features_encoding() {
+ let features_as_u5s = vec![
+ u5::try_from_u8(6).unwrap(),
+ u5::try_from_u8(10).unwrap(),
+ u5::try_from_u8(25).unwrap(),
+ u5::try_from_u8(1).unwrap(),
+ u5::try_from_u8(10).unwrap(),
+ u5::try_from_u8(0).unwrap(),
+ u5::try_from_u8(20).unwrap(),
+ u5::try_from_u8(2).unwrap(),
+ u5::try_from_u8(0).unwrap(),
+ u5::try_from_u8(6).unwrap(),
+ u5::try_from_u8(0).unwrap(),
+ u5::try_from_u8(16).unwrap(),
+ u5::try_from_u8(1).unwrap(),
+ ];
+ let features = Bolt11InvoiceFeatures::from_le_bytes(vec![1, 2, 3, 4, 5, 42, 100, 101]);
+
+ // Test length calculation.
+ assert_eq!(features.base32_len(), 13);
+
+ // Test serialization.
+ let features_serialized = features.to_base32();
+ assert_eq!(features_as_u5s, features_serialized);
+
+ // Test deserialization.
+ let features_deserialized = Bolt11InvoiceFeatures::from_base32(&features_as_u5s).unwrap();
+ assert_eq!(features, features_deserialized);
+ }
+
+ #[test]
+ fn test_channel_type_mapping() {
+ // If we map an Bolt11InvoiceFeatures with StaticRemoteKey optional, it should map into a
+ // required-StaticRemoteKey ChannelTypeFeatures.
+ let mut init_features = InitFeatures::empty();
+ init_features.set_static_remote_key_optional();
+ let converted_features = ChannelTypeFeatures::from_init(&init_features);
+ assert_eq!(converted_features, ChannelTypeFeatures::only_static_remote_key());
+ assert!(!converted_features.supports_any_optional_bits());
+ assert!(converted_features.requires_static_remote_key());
+ }
+
+ #[test]
+ #[cfg(feature = "std")]
+ fn test_excess_zero_bytes_ignored() {
+ // Checks that `Hash` and `PartialEq` ignore excess zero bytes, which may appear due to
+ // feature conversion or because a peer serialized their feature poorly.
+ use std::collections::hash_map::DefaultHasher;
+ use std::hash::{Hash, Hasher};
+
+ let mut zerod_features = InitFeatures::empty();
+ zerod_features.flags = vec![0];
+ let empty_features = InitFeatures::empty();
+ assert!(empty_features.flags.is_empty());
+
+ assert_eq!(zerod_features, empty_features);
+
+ let mut zerod_hash = DefaultHasher::new();
+ zerod_features.hash(&mut zerod_hash);
+ let mut empty_hash = DefaultHasher::new();
+ empty_features.hash(&mut empty_hash);
+ assert_eq!(zerod_hash.finish(), empty_hash.finish());