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