Advertise keysend feature

[rust-lightning] / lightning / src / ln / features.rs

diff --git a/lightning/src/ln/features.rs b/lightning/src/ln/features.rs
index 99e5cd0994c9971cdc32383c70650184d024c879..492cf5ccd198c2829b73b81ab4e5558b9cd14028 100644 (file)
--- a/lightning/src/ln/features.rs
+++ b/lightning/src/ln/features.rs
@@ -22,8 +22,9 @@
 //! [BOLT #9]: https://github.com/lightningnetwork/lightning-rfc/blob/master/09-features.md
 //! [messages]: crate::ln::msgs
 
-use std::{cmp, fmt};
-use std::marker::PhantomData;
+use prelude::*;
+use core::{cmp, fmt};
+use core::marker::PhantomData;
 
 use bitcoin::bech32;
 use bitcoin::bech32::{Base32Len, FromBase32, ToBase32, u5, WriteBase32};
@@ -31,6 +32,7 @@ use ln::msgs::DecodeError;
 use util::ser::{Readable, Writeable, Writer};
 
 mod sealed {
+       use prelude::*;
        use ln::features::Features;
 
        /// The context in which [`Features`] are applicable. Defines which features are required and
@@ -122,6 +124,12 @@ mod sealed {
                        ,
                        // Byte 3
                        ,
+                       // Byte 4
+                       ,
+                       // Byte 5
+                       ,
+                       // Byte 6
+                       ,
                ],
                optional_features: [
                        // Byte 0
@@ -132,6 +140,12 @@ mod sealed {
                        BasicMPP,
                        // Byte 3
                        ShutdownAnySegwit,
+                       // Byte 4
+                       ,
+                       // Byte 5
+                       ,
+                       // Byte 6
+                       Keysend,
                ],
        });
        define_context!(ChannelContext {
@@ -297,29 +311,11 @@ mod sealed {
        define_feature!(27, ShutdownAnySegwit, [InitContext, NodeContext],
                "Feature flags for `opt_shutdown_anysegwit`.", set_shutdown_any_segwit_optional,
                set_shutdown_any_segwit_required);
+       define_feature!(55, Keysend, [NodeContext],
+               "Feature flags for keysend payments.", set_keysend_optional, set_keysend_required);
 
        #[cfg(test)]
-       define_context!(TestingContext {
-               required_features: [
-                       // Byte 0
-                       ,
-                       // Byte 1
-                       ,
-                       // Byte 2
-                       UnknownFeature,
-               ],
-               optional_features: [
-                       // Byte 0
-                       ,
-                       // Byte 1
-                       ,
-                       // Byte 2
-                       ,
-               ],
-       });
-
-       #[cfg(test)]
-       define_feature!(23, UnknownFeature, [TestingContext],
+       define_feature!(123456789, UnknownFeature, [NodeContext, ChannelContext, InvoiceContext],
                "Feature flags for an unknown feature used in testing.", set_unknown_feature_optional,
                set_unknown_feature_required);
 }
@@ -488,13 +484,14 @@ impl<T: sealed::Context> Features<T> {
        /// Converts `Features<T>` to `Features<C>`. Only known `T` features relevant to context `C` are
        /// included in the result.
        fn to_context_internal<C: sealed::Context>(&self) -> Features<C> {
-               let byte_count = C::KNOWN_FEATURE_MASK.len();
+               let from_byte_count = T::KNOWN_FEATURE_MASK.len();
+               let to_byte_count = C::KNOWN_FEATURE_MASK.len();
                let mut flags = Vec::new();
                for (i, byte) in self.flags.iter().enumerate() {
-                       if i < byte_count {
-                               let known_source_features = T::KNOWN_FEATURE_MASK[i];
-                               let known_target_features = C::KNOWN_FEATURE_MASK[i];
-                               flags.push(byte & known_source_features & known_target_features);
+                       if i < from_byte_count && i < to_byte_count {
+                               let from_known_features = T::KNOWN_FEATURE_MASK[i];
+                               let to_known_features = C::KNOWN_FEATURE_MASK[i];
+                               flags.push(byte & from_known_features & to_known_features);
                        }
                }
                Features::<C> { flags, mark: PhantomData, }
@@ -550,21 +547,6 @@ impl<T: sealed::Context> Features<T> {
        pub(crate) fn byte_count(&self) -> usize {
                self.flags.len()
        }
-
-       #[cfg(test)]
-       pub(crate) fn set_required_unknown_bits(&mut self) {
-               <sealed::TestingContext as sealed::UnknownFeature>::set_required_bit(&mut self.flags);
-       }
-
-       #[cfg(test)]
-       pub(crate) fn set_optional_unknown_bits(&mut self) {
-               <sealed::TestingContext as sealed::UnknownFeature>::set_optional_bit(&mut self.flags);
-       }
-
-       #[cfg(test)]
-       pub(crate) fn clear_unknown_bits(&mut self) {
-               <sealed::TestingContext as sealed::UnknownFeature>::clear_bits(&mut self.flags);
-       }
 }
 
 impl<T: sealed::DataLossProtect> Features<T> {
@@ -762,19 +744,15 @@ mod tests {
 
        #[test]
        fn sanity_test_unknown_bits() {
-               let mut features = ChannelFeatures::empty();
+               let features = ChannelFeatures::empty();
                assert!(!features.requires_unknown_bits());
                assert!(!features.supports_unknown_bits());
 
-               features.set_required_unknown_bits();
+               let features = ChannelFeatures::empty().set_unknown_feature_required();
                assert!(features.requires_unknown_bits());
                assert!(features.supports_unknown_bits());
 
-               features.clear_unknown_bits();
-               assert!(!features.requires_unknown_bits());
-               assert!(!features.supports_unknown_bits());
-
-               features.set_optional_unknown_bits();
+               let features = ChannelFeatures::empty().set_unknown_feature_optional();
                assert!(!features.requires_unknown_bits());
                assert!(features.supports_unknown_bits());
        }
@@ -810,6 +788,16 @@ mod tests {
                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!(InvoiceFeatures::known().byte_count() < NodeFeatures::known().byte_count());
+               let invoice_features = InvoiceFeatures::known().set_unknown_feature_optional();
+               assert!(invoice_features.supports_unknown_bits());
+               let node_features: NodeFeatures = invoice_features.to_context();
+               assert!(!node_features.supports_unknown_bits());
+       }
+
        #[test]
        fn set_feature_bits() {
                let features = InvoiceFeatures::empty()