+
+ #[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());
+ }