_ Git - rust-lightning/blob - lightning/src/ln/features.rs

   1 // This file is Copyright its original authors, visible in version control
   2 // history.
   3 //
   4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
   5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
   7 // You may not use this file except in accordance with one or both of these
   8 // licenses.
   9
  10 //! Feature flag definitions for the Lightning protocol according to [BOLT #9].
  11 //!
  12 //! Lightning nodes advertise a supported set of operation through feature flags. Features are
  13 //! applicable for a specific context as indicated in some [messages]. [`Features`] encapsulates
  14 //! behavior for specifying and checking feature flags for a particular context. Each feature is
  15 //! defined internally by a trait specifying the corresponding flags (i.e., even and odd bits). A
  16 //! [`Context`] is used to parameterize [`Features`] and defines which features it can support.
  17 //!
  18 //! Whether a feature is considered "known" or "unknown" is relative to the implementation, whereas
  19 //! the term "supports" is used in reference to a particular set of [`Features`]. That is, a node
  20 //! supports a feature if it advertises the feature (as either required or optional) to its peers.
  21 //! And the implementation can interpret a feature if the feature is known to it.
  22 //!
  23 //! [BOLT #9]: https://github.com/lightningnetwork/lightning-rfc/blob/master/09-features.md
  24 //! [messages]: ../msgs/index.html
  25 //! [`Features`]: struct.Features.html
  26 //! [`Context`]: sealed/trait.Context.html
  27
  28 use std::{cmp, fmt};
  29 use std::result::Result;
  30 use std::marker::PhantomData;
  31
  32 use ln::msgs::DecodeError;
  33 use util::ser::{Readable, Writeable, Writer};
  34
  35 mod sealed {
  36         /// The context in which [`Features`] are applicable. Defines which features are required and
  37         /// which are optional for the context.
  38         ///
  39         /// [`Features`]: ../struct.Features.html
  40         pub trait Context {
  41                 /// Features that are known to the implementation, where a required feature is indicated by
  42                 /// its even bit and an optional feature is indicated by its odd bit.
  43                 const KNOWN_FEATURE_FLAGS: &'static [u8];
  44
  45                 /// Bitmask for selecting features that are known to the implementation, regardless of
  46                 /// whether each feature is required or optional.
  47                 const KNOWN_FEATURE_MASK: &'static [u8];
  48         }
  49
  50         /// Defines a [`Context`] by stating which features it requires and which are optional. Features
  51         /// are specified as a comma-separated list of bytes where each byte is a pipe-delimited list of
  52         /// feature identifiers.
  53         ///
  54         /// [`Context`]: trait.Context.html
  55         macro_rules! define_context {
  56                 ($context: ident {
  57                         required_features: [$( $( $required_feature: ident )|*, )*],
  58                         optional_features: [$( $( $optional_feature: ident )|*, )*],
  59                 }) => {
  60                         pub struct $context {}
  61
  62                         impl Context for $context {
  63                                 const KNOWN_FEATURE_FLAGS: &'static [u8] = &[
  64                                         // For each byte, use bitwise-OR to compute the applicable flags for known
  65                                         // required features `r_i` and optional features `o_j` for all `i` and `j` such
  66                                         // that the following slice is formed:
  67                                         //
  68                                         // [
  69                                         //  `r_0` | `r_1` | ... | `o_0` | `o_1` | ...,
  70                                         //  ...,
  71                                         // ]
  72                                         $(
  73                                                 0b00_00_00_00 $(|
  74                                                         <Self as $required_feature>::REQUIRED_MASK)*
  75                                                 $(|
  76                                                         <Self as $optional_feature>::OPTIONAL_MASK)*,
  77                                         )*
  78                                 ];
  79
  80                                 const KNOWN_FEATURE_MASK: &'static [u8] = &[
  81                                         // Similar as above, but set both flags for each feature regardless of whether
  82                                         // the feature is required or optional.
  83                                         $(
  84                                                 0b00_00_00_00 $(|
  85                                                         <Self as $required_feature>::REQUIRED_MASK |
  86                                                         <Self as $required_feature>::OPTIONAL_MASK)*
  87                                                 $(|
  88                                                         <Self as $optional_feature>::REQUIRED_MASK |
  89                                                         <Self as $optional_feature>::OPTIONAL_MASK)*,
  90                                         )*
  91                                 ];
  92                         }
  93                 };
  94         }
  95
  96         define_context!(InitContext {
  97                 required_features: [
  98                         // Byte 0
  99                         ,
 100                         // Byte 1
 101                         StaticRemoteKey,
 102                         // Byte 2
 103                         ,
 104                 ],
 105                 optional_features: [
 106                         // Byte 0
 107                         DataLossProtect | InitialRoutingSync | UpfrontShutdownScript,
 108                         // Byte 1
 109                         VariableLengthOnion | PaymentSecret,
 110                         // Byte 2
 111                         BasicMPP,
 112                 ],
 113         });
 114         define_context!(NodeContext {
 115                 required_features: [
 116                         // Byte 0
 117                         ,
 118                         // Byte 1
 119                         StaticRemoteKey,
 120                         // Byte 2
 121                         ,
 122                 ],
 123                 optional_features: [
 124                         // Byte 0
 125                         DataLossProtect | UpfrontShutdownScript,
 126                         // Byte 1
 127                         VariableLengthOnion | PaymentSecret,
 128                         // Byte 2
 129                         BasicMPP,
 130                 ],
 131         });
 132         define_context!(ChannelContext {
 133                 required_features: [],
 134                 optional_features: [],
 135         });
 136
 137         /// Defines a feature with the given bits for the specified [`Context`]s. The generated trait is
 138         /// useful for manipulating feature flags.
 139         ///
 140         /// [`Context`]: trait.Context.html
 141         macro_rules! define_feature {
 142                 ($odd_bit: expr, $feature: ident, [$($context: ty),+], $doc: expr) => {
 143                         #[doc = $doc]
 144                         ///
 145                         /// See [BOLT #9] for details.
 146                         ///
 147                         /// [BOLT #9]: https://github.com/lightningnetwork/lightning-rfc/blob/master/09-features.md
 148                         pub trait $feature: Context {
 149                                 /// The bit used to signify that the feature is required.
 150                                 const EVEN_BIT: usize = $odd_bit - 1;
 151
 152                                 /// The bit used to signify that the feature is optional.
 153                                 const ODD_BIT: usize = $odd_bit;
 154
 155                                 /// Assertion that [`EVEN_BIT`] is actually even.
 156                                 ///
 157                                 /// [`EVEN_BIT`]: #associatedconstant.EVEN_BIT
 158                                 const ASSERT_EVEN_BIT_PARITY: usize;
 159
 160                                 /// Assertion that [`ODD_BIT`] is actually odd.
 161                                 ///
 162                                 /// [`ODD_BIT`]: #associatedconstant.ODD_BIT
 163                                 const ASSERT_ODD_BIT_PARITY: usize;
 164
 165                                 /// The byte where the feature is set.
 166                                 const BYTE_OFFSET: usize = Self::EVEN_BIT / 8;
 167
 168                                 /// The bitmask for the feature's required flag relative to the [`BYTE_OFFSET`].
 169                                 ///
 170                                 /// [`BYTE_OFFSET`]: #associatedconstant.BYTE_OFFSET
 171                                 const REQUIRED_MASK: u8 = 1 << (Self::EVEN_BIT - 8 * Self::BYTE_OFFSET);
 172
 173                                 /// The bitmask for the feature's optional flag relative to the [`BYTE_OFFSET`].
 174                                 ///
 175                                 /// [`BYTE_OFFSET`]: #associatedconstant.BYTE_OFFSET
 176                                 const OPTIONAL_MASK: u8 = 1 << (Self::ODD_BIT - 8 * Self::BYTE_OFFSET);
 177
 178                                 /// Returns whether the feature is required by the given flags.
 179                                 #[inline]
 180                                 fn requires_feature(flags: &Vec<u8>) -> bool {
 181                                         flags.len() > Self::BYTE_OFFSET &&
 182                                                 (flags[Self::BYTE_OFFSET] & Self::REQUIRED_MASK) != 0
 183                                 }
 184
 185                                 /// Returns whether the feature is supported by the given flags.
 186                                 #[inline]
 187                                 fn supports_feature(flags: &Vec<u8>) -> bool {
 188                                         flags.len() > Self::BYTE_OFFSET &&
 189                                                 (flags[Self::BYTE_OFFSET] & (Self::REQUIRED_MASK | Self::OPTIONAL_MASK)) != 0
 190                                 }
 191
 192                                 /// Sets the feature's required (even) bit in the given flags.
 193                                 #[inline]
 194                                 fn set_required_bit(flags: &mut Vec<u8>) {
 195                                         if flags.len() <= Self::BYTE_OFFSET {
 196                                                 flags.resize(Self::BYTE_OFFSET + 1, 0u8);
 197                                         }
 198
 199                                         flags[Self::BYTE_OFFSET] |= Self::REQUIRED_MASK;
 200                                 }
 201
 202                                 /// Sets the feature's optional (odd) bit in the given flags.
 203                                 #[inline]
 204                                 fn set_optional_bit(flags: &mut Vec<u8>) {
 205                                         if flags.len() <= Self::BYTE_OFFSET {
 206                                                 flags.resize(Self::BYTE_OFFSET + 1, 0u8);
 207                                         }
 208
 209                                         flags[Self::BYTE_OFFSET] |= Self::OPTIONAL_MASK;
 210                                 }
 211
 212                                 /// Clears the feature's required (even) and optional (odd) bits from the given
 213                                 /// flags.
 214                                 #[inline]
 215                                 fn clear_bits(flags: &mut Vec<u8>) {
 216                                         if flags.len() > Self::BYTE_OFFSET {
 217                                                 flags[Self::BYTE_OFFSET] &= !Self::REQUIRED_MASK;
 218                                                 flags[Self::BYTE_OFFSET] &= !Self::OPTIONAL_MASK;
 219                                         }
 220
 221                                         let last_non_zero_byte = flags.iter().rposition(|&byte| byte != 0);
 222                                         let size = if let Some(offset) = last_non_zero_byte { offset + 1 } else { 0 };
 223                                         flags.resize(size, 0u8);
 224                                 }
 225                         }
 226
 227                         $(
 228                                 impl $feature for $context {
 229                                         // EVEN_BIT % 2 == 0
 230                                         const ASSERT_EVEN_BIT_PARITY: usize = 0 - (<Self as $feature>::EVEN_BIT % 2);
 231
 232                                         // ODD_BIT % 2 == 1
 233                                         const ASSERT_ODD_BIT_PARITY: usize = (<Self as $feature>::ODD_BIT % 2) - 1;
 234                                 }
 235                         )*
 236                 }
 237         }
 238
 239         define_feature!(1, DataLossProtect, [InitContext, NodeContext],
 240                 "Feature flags for `option_data_loss_protect`.");
 241         // NOTE: Per Bolt #9, initial_routing_sync has no even bit.
 242         define_feature!(3, InitialRoutingSync, [InitContext],
 243                 "Feature flags for `initial_routing_sync`.");
 244         define_feature!(5, UpfrontShutdownScript, [InitContext, NodeContext],
 245                 "Feature flags for `option_upfront_shutdown_script`.");
 246         define_feature!(9, VariableLengthOnion, [InitContext, NodeContext],
 247                 "Feature flags for `var_onion_optin`.");
 248         define_feature!(13, StaticRemoteKey, [InitContext, NodeContext],
 249                 "Feature flags for `option_static_remotekey`.");
 250         define_feature!(15, PaymentSecret, [InitContext, NodeContext],
 251                 "Feature flags for `payment_secret`.");
 252         define_feature!(17, BasicMPP, [InitContext, NodeContext],
 253                 "Feature flags for `basic_mpp`.");
 254
 255         #[cfg(test)]
 256         define_context!(TestingContext {
 257                 required_features: [
 258                         // Byte 0
 259                         ,
 260                         // Byte 1
 261                         ,
 262                         // Byte 2
 263                         UnknownFeature,
 264                 ],
 265                 optional_features: [
 266                         // Byte 0
 267                         ,
 268                         // Byte 1
 269                         ,
 270                         // Byte 2
 271                         ,
 272                 ],
 273         });
 274
 275         #[cfg(test)]
 276         define_feature!(23, UnknownFeature, [TestingContext],
 277                 "Feature flags for an unknown feature used in testing.");
 278 }
 279
 280 /// Tracks the set of features which a node implements, templated by the context in which it
 281 /// appears.
 282 pub struct Features<T: sealed::Context> {
 283         /// Note that, for convenience, flags is LITTLE endian (despite being big-endian on the wire)
 284         flags: Vec<u8>,
 285         mark: PhantomData<T>,
 286 }
 287
 288 impl<T: sealed::Context> Clone for Features<T> {
 289         fn clone(&self) -> Self {
 290                 Self {
 291                         flags: self.flags.clone(),
 292                         mark: PhantomData,
 293                 }
 294         }
 295 }
 296 impl<T: sealed::Context> PartialEq for Features<T> {
 297         fn eq(&self, o: &Self) -> bool {
 298                 self.flags.eq(&o.flags)
 299         }
 300 }
 301 impl<T: sealed::Context> fmt::Debug for Features<T> {
 302         fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
 303                 self.flags.fmt(fmt)
 304         }
 305 }
 306
 307 /// Features used within an `init` message.
 308 pub type InitFeatures = Features<sealed::InitContext>;
 309 /// Features used within a `node_announcement` message.
 310 pub type NodeFeatures = Features<sealed::NodeContext>;
 311 /// Features used within a `channel_announcement` message.
 312 pub type ChannelFeatures = Features<sealed::ChannelContext>;
 313
 314 impl InitFeatures {
 315         /// Writes all features present up to, and including, 13.
 316         pub(crate) fn write_up_to_13<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 317                 let len = cmp::min(2, self.flags.len());
 318                 w.size_hint(len + 2);
 319                 (len as u16).write(w)?;
 320                 for i in (0..len).rev() {
 321                         if i == 0 {
 322                                 self.flags[i].write(w)?;
 323                         } else {
 324                                 // On byte 1, we want up-to-and-including-bit-13, 0-indexed, which is
 325                                 // up-to-and-including-bit-5, 0-indexed, on this byte:
 326                                 (self.flags[i] & 0b00_11_11_11).write(w)?;
 327                         }
 328                 }
 329                 Ok(())
 330         }
 331
 332         /// or's another InitFeatures into this one.
 333         pub(crate) fn or(mut self, o: InitFeatures) -> InitFeatures {
 334                 let total_feature_len = cmp::max(self.flags.len(), o.flags.len());
 335                 self.flags.resize(total_feature_len, 0u8);
 336                 for (byte, o_byte) in self.flags.iter_mut().zip(o.flags.iter()) {
 337                         *byte |= *o_byte;
 338                 }
 339                 self
 340         }
 341
 342         /// Converts `InitFeatures` to `Features<C>`. Only known `InitFeatures` relevant to context `C`
 343         /// are included in the result.
 344         pub(crate) fn to_context<C: sealed::Context>(&self) -> Features<C> {
 345                 self.to_context_internal()
 346         }
 347 }
 348
 349 impl<T: sealed::Context> Features<T> {
 350         /// Create a blank Features with no features set
 351         pub fn empty() -> Features<T> {
 352                 Features {
 353                         flags: Vec::new(),
 354                         mark: PhantomData,
 355                 }
 356         }
 357
 358         /// Creates features known by the implementation as defined by [`T::KNOWN_FEATURE_FLAGS`].
 359         ///
 360         /// [`T::KNOWN_FEATURE_FLAGS`]: sealed/trait.Context.html#associatedconstant.KNOWN_FEATURE_FLAGS
 361         pub fn known() -> Features<T> {
 362                 Self {
 363                         flags: T::KNOWN_FEATURE_FLAGS.to_vec(),
 364                         mark: PhantomData,
 365                 }
 366         }
 367
 368         /// Converts `Features<T>` to `Features<C>`. Only known `T` features relevant to context `C` are
 369         /// included in the result.
 370         fn to_context_internal<C: sealed::Context>(&self) -> Features<C> {
 371                 let byte_count = C::KNOWN_FEATURE_MASK.len();
 372                 let mut flags = Vec::new();
 373                 for (i, byte) in self.flags.iter().enumerate() {
 374                         if i < byte_count {
 375                                 let known_source_features = T::KNOWN_FEATURE_MASK[i];
 376                                 let known_target_features = C::KNOWN_FEATURE_MASK[i];
 377                                 flags.push(byte & known_source_features & known_target_features);
 378                         }
 379                 }
 380                 Features::<C> { flags, mark: PhantomData, }
 381         }
 382
 383         #[cfg(test)]
 384         /// Create a Features given a set of flags, in LE.
 385         pub fn from_le_bytes(flags: Vec<u8>) -> Features<T> {
 386                 Features {
 387                         flags,
 388                         mark: PhantomData,
 389                 }
 390         }
 391
 392         #[cfg(test)]
 393         /// Gets the underlying flags set, in LE.
 394         pub fn le_flags(&self) -> &Vec<u8> {
 395                 &self.flags
 396         }
 397
 398         pub(crate) fn requires_unknown_bits(&self) -> bool {
 399                 // Bitwise AND-ing with all even bits set except for known features will select required
 400                 // unknown features.
 401                 let byte_count = T::KNOWN_FEATURE_MASK.len();
 402                 self.flags.iter().enumerate().any(|(i, &byte)| {
 403                         let required_features = 0b01_01_01_01;
 404                         let unknown_features = if i < byte_count {
 405                                 !T::KNOWN_FEATURE_MASK[i]
 406                         } else {
 407                                 0b11_11_11_11
 408                         };
 409                         (byte & (required_features & unknown_features)) != 0
 410                 })
 411         }
 412
 413         pub(crate) fn supports_unknown_bits(&self) -> bool {
 414                 // Bitwise AND-ing with all even and odd bits set except for known features will select
 415                 // both required and optional unknown features.
 416                 let byte_count = T::KNOWN_FEATURE_MASK.len();
 417                 self.flags.iter().enumerate().any(|(i, &byte)| {
 418                         let unknown_features = if i < byte_count {
 419                                 !T::KNOWN_FEATURE_MASK[i]
 420                         } else {
 421                                 0b11_11_11_11
 422                         };
 423                         (byte & unknown_features) != 0
 424                 })
 425         }
 426
 427         /// The number of bytes required to represent the feature flags present. This does not include
 428         /// the length bytes which are included in the serialized form.
 429         pub(crate) fn byte_count(&self) -> usize {
 430                 self.flags.len()
 431         }
 432
 433         #[cfg(test)]
 434         pub(crate) fn set_required_unknown_bits(&mut self) {
 435                 <sealed::TestingContext as sealed::UnknownFeature>::set_required_bit(&mut self.flags);
 436         }
 437
 438         #[cfg(test)]
 439         pub(crate) fn set_optional_unknown_bits(&mut self) {
 440                 <sealed::TestingContext as sealed::UnknownFeature>::set_optional_bit(&mut self.flags);
 441         }
 442
 443         #[cfg(test)]
 444         pub(crate) fn clear_unknown_bits(&mut self) {
 445                 <sealed::TestingContext as sealed::UnknownFeature>::clear_bits(&mut self.flags);
 446         }
 447 }
 448
 449 impl<T: sealed::DataLossProtect> Features<T> {
 450         #[cfg(test)]
 451         pub(crate) fn requires_data_loss_protect(&self) -> bool {
 452                 <T as sealed::DataLossProtect>::requires_feature(&self.flags)
 453         }
 454         pub(crate) fn supports_data_loss_protect(&self) -> bool {
 455                 <T as sealed::DataLossProtect>::supports_feature(&self.flags)
 456         }
 457 }
 458
 459 impl<T: sealed::UpfrontShutdownScript> Features<T> {
 460         #[cfg(test)]
 461         pub(crate) fn requires_upfront_shutdown_script(&self) -> bool {
 462                 <T as sealed::UpfrontShutdownScript>::requires_feature(&self.flags)
 463         }
 464         pub(crate) fn supports_upfront_shutdown_script(&self) -> bool {
 465                 <T as sealed::UpfrontShutdownScript>::supports_feature(&self.flags)
 466         }
 467         #[cfg(test)]
 468         pub(crate) fn clear_upfront_shutdown_script(mut self) -> Self {
 469                 <T as sealed::UpfrontShutdownScript>::clear_bits(&mut self.flags);
 470                 self
 471         }
 472 }
 473
 474 impl<T: sealed::VariableLengthOnion> Features<T> {
 475         #[cfg(test)]
 476         pub(crate) fn requires_variable_length_onion(&self) -> bool {
 477                 <T as sealed::VariableLengthOnion>::requires_feature(&self.flags)
 478         }
 479         pub(crate) fn supports_variable_length_onion(&self) -> bool {
 480                 <T as sealed::VariableLengthOnion>::supports_feature(&self.flags)
 481         }
 482 }
 483
 484 impl<T: sealed::StaticRemoteKey> Features<T> {
 485         pub(crate) fn supports_static_remote_key(&self) -> bool {
 486                 <T as sealed::StaticRemoteKey>::supports_feature(&self.flags)
 487         }
 488         #[cfg(test)]
 489         pub(crate) fn requires_static_remote_key(&self) -> bool {
 490                 <T as sealed::StaticRemoteKey>::requires_feature(&self.flags)
 491         }
 492 }
 493
 494 impl<T: sealed::InitialRoutingSync> Features<T> {
 495         pub(crate) fn initial_routing_sync(&self) -> bool {
 496                 <T as sealed::InitialRoutingSync>::supports_feature(&self.flags)
 497         }
 498         pub(crate) fn clear_initial_routing_sync(&mut self) {
 499                 <T as sealed::InitialRoutingSync>::clear_bits(&mut self.flags)
 500         }
 501 }
 502
 503 impl<T: sealed::PaymentSecret> Features<T> {
 504         #[cfg(test)]
 505         pub(crate) fn requires_payment_secret(&self) -> bool {
 506                 <T as sealed::PaymentSecret>::requires_feature(&self.flags)
 507         }
 508         // Note that we never need to test this since what really matters is the invoice - iff the
 509         // invoice provides a payment_secret, we assume that we can use it (ie that the recipient
 510         // supports payment_secret).
 511         #[allow(dead_code)]
 512         pub(crate) fn supports_payment_secret(&self) -> bool {
 513                 <T as sealed::PaymentSecret>::supports_feature(&self.flags)
 514         }
 515 }
 516
 517 impl<T: sealed::BasicMPP> Features<T> {
 518         #[cfg(test)]
 519         pub(crate) fn requires_basic_mpp(&self) -> bool {
 520                 <T as sealed::BasicMPP>::requires_feature(&self.flags)
 521         }
 522         // We currently never test for this since we don't actually *generate* multipath routes.
 523         #[allow(dead_code)]
 524         pub(crate) fn supports_basic_mpp(&self) -> bool {
 525                 <T as sealed::BasicMPP>::supports_feature(&self.flags)
 526         }
 527 }
 528
 529 impl<T: sealed::Context> Writeable for Features<T> {
 530         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 531                 w.size_hint(self.flags.len() + 2);
 532                 (self.flags.len() as u16).write(w)?;
 533                 for f in self.flags.iter().rev() { // Swap back to big-endian
 534                         f.write(w)?;
 535                 }
 536                 Ok(())
 537         }
 538 }
 539
 540 impl<T: sealed::Context> Readable for Features<T> {
 541         fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
 542                 let mut flags: Vec<u8> = Readable::read(r)?;
 543                 flags.reverse(); // Swap to little-endian
 544                 Ok(Self {
 545                         flags,
 546                         mark: PhantomData,
 547                 })
 548         }
 549 }
 550
 551 #[cfg(test)]
 552 mod tests {
 553         use super::{ChannelFeatures, InitFeatures, NodeFeatures};
 554
 555         #[test]
 556         fn sanity_test_known_features() {
 557                 assert!(!ChannelFeatures::known().requires_unknown_bits());
 558                 assert!(!ChannelFeatures::known().supports_unknown_bits());
 559                 assert!(!InitFeatures::known().requires_unknown_bits());
 560                 assert!(!InitFeatures::known().supports_unknown_bits());
 561                 assert!(!NodeFeatures::known().requires_unknown_bits());
 562                 assert!(!NodeFeatures::known().supports_unknown_bits());
 563
 564                 assert!(InitFeatures::known().supports_upfront_shutdown_script());
 565                 assert!(NodeFeatures::known().supports_upfront_shutdown_script());
 566                 assert!(!InitFeatures::known().requires_upfront_shutdown_script());
 567                 assert!(!NodeFeatures::known().requires_upfront_shutdown_script());
 568
 569                 assert!(InitFeatures::known().supports_data_loss_protect());
 570                 assert!(NodeFeatures::known().supports_data_loss_protect());
 571                 assert!(!InitFeatures::known().requires_data_loss_protect());
 572                 assert!(!NodeFeatures::known().requires_data_loss_protect());
 573
 574                 assert!(InitFeatures::known().supports_variable_length_onion());
 575                 assert!(NodeFeatures::known().supports_variable_length_onion());
 576                 assert!(!InitFeatures::known().requires_variable_length_onion());
 577                 assert!(!NodeFeatures::known().requires_variable_length_onion());
 578
 579                 assert!(InitFeatures::known().supports_static_remote_key());
 580                 assert!(NodeFeatures::known().supports_static_remote_key());
 581                 assert!(InitFeatures::known().requires_static_remote_key());
 582                 assert!(NodeFeatures::known().requires_static_remote_key());
 583
 584                 assert!(InitFeatures::known().supports_payment_secret());
 585                 assert!(NodeFeatures::known().supports_payment_secret());
 586                 assert!(!InitFeatures::known().requires_payment_secret());
 587                 assert!(!NodeFeatures::known().requires_payment_secret());
 588
 589                 assert!(InitFeatures::known().supports_basic_mpp());
 590                 assert!(NodeFeatures::known().supports_basic_mpp());
 591                 assert!(!InitFeatures::known().requires_basic_mpp());
 592                 assert!(!NodeFeatures::known().requires_basic_mpp());
 593
 594                 let mut init_features = InitFeatures::known();
 595                 assert!(init_features.initial_routing_sync());
 596                 init_features.clear_initial_routing_sync();
 597                 assert!(!init_features.initial_routing_sync());
 598         }
 599
 600         #[test]
 601         fn sanity_test_unknown_bits() {
 602                 let mut features = ChannelFeatures::empty();
 603                 assert!(!features.requires_unknown_bits());
 604                 assert!(!features.supports_unknown_bits());
 605
 606                 features.set_required_unknown_bits();
 607                 assert!(features.requires_unknown_bits());
 608                 assert!(features.supports_unknown_bits());
 609
 610                 features.clear_unknown_bits();
 611                 assert!(!features.requires_unknown_bits());
 612                 assert!(!features.supports_unknown_bits());
 613
 614                 features.set_optional_unknown_bits();
 615                 assert!(!features.requires_unknown_bits());
 616                 assert!(features.supports_unknown_bits());
 617         }
 618
 619         #[test]
 620         fn convert_to_context_with_relevant_flags() {
 621                 let init_features = InitFeatures::known().clear_upfront_shutdown_script();
 622                 assert!(init_features.initial_routing_sync());
 623                 assert!(!init_features.supports_upfront_shutdown_script());
 624
 625                 let node_features: NodeFeatures = init_features.to_context();
 626                 {
 627                         // Check that the flags are as expected:
 628                         // - option_data_loss_protect
 629                         // - var_onion_optin | static_remote_key (req) | payment_secret
 630                         // - basic_mpp
 631                         assert_eq!(node_features.flags.len(), 3);
 632                         assert_eq!(node_features.flags[0], 0b00000010);
 633                         assert_eq!(node_features.flags[1], 0b10010010);
 634                         assert_eq!(node_features.flags[2], 0b00000010);
 635                 }
 636
 637                 // Check that cleared flags are kept blank when converting back:
 638                 // - initial_routing_sync was not applicable to NodeContext
 639                 // - upfront_shutdown_script was cleared before converting
 640                 let features: InitFeatures = node_features.to_context_internal();
 641                 assert!(!features.initial_routing_sync());
 642                 assert!(!features.supports_upfront_shutdown_script());
 643         }
 644 }