//! Lightning nodes advertise a supported set of operation through feature flags. Features are
//! applicable for a specific context as indicated in some [messages]. [`Features`] encapsulates
//! behavior for specifying and checking feature flags for a particular context. Each feature is
-//! defined internally by a trait specifying the corresponding flags (i.e., even and odd bits). A
-//! [`Context`] is used to parameterize [`Features`] and defines which features it can support.
+//! defined internally by a trait specifying the corresponding flags (i.e., even and odd bits).
//!
//! Whether a feature is considered "known" or "unknown" is relative to the implementation, whereas
//! the term "supports" is used in reference to a particular set of [`Features`]. That is, a node
//! And the implementation can interpret a feature if the feature is known to it.
//!
//! [BOLT #9]: https://github.com/lightningnetwork/lightning-rfc/blob/master/09-features.md
-//! [messages]: ../msgs/index.html
-//! [`Features`]: struct.Features.html
-//! [`Context`]: sealed/trait.Context.html
+//! [messages]: crate::ln::msgs
use std::{cmp, fmt};
use std::marker::PhantomData;
+use bitcoin::bech32;
+use bitcoin::bech32::{Base32Len, FromBase32, ToBase32, u5, WriteBase32};
use ln::msgs::DecodeError;
use util::ser::{Readable, Writeable, Writer};
mod sealed {
+ use ln::features::Features;
+
/// The context in which [`Features`] are applicable. Defines which features are required and
/// which are optional for the context.
- ///
- /// [`Features`]: ../struct.Features.html
pub trait Context {
/// Features that are known to the implementation, where a required feature is indicated by
/// its even bit and an optional feature is indicated by its odd bit.
/// Defines a [`Context`] by stating which features it requires and which are optional. Features
/// are specified as a comma-separated list of bytes where each byte is a pipe-delimited list of
/// feature identifiers.
- ///
- /// [`Context`]: trait.Context.html
macro_rules! define_context {
($context: ident {
required_features: [$( $( $required_feature: ident )|*, )*],
optional_features: [$( $( $optional_feature: ident )|*, )*],
}) => {
+ #[derive(Eq, PartialEq)]
pub struct $context {}
impl Context for $context {
// Byte 0
,
// Byte 1
- StaticRemoteKey,
+ StaticRemoteKey | PaymentSecret,
// Byte 2
,
// Byte 3
// Byte 0
DataLossProtect | InitialRoutingSync | UpfrontShutdownScript | GossipQueries,
// Byte 1
- VariableLengthOnion | PaymentSecret,
+ VariableLengthOnion,
// Byte 2
BasicMPP,
// Byte 3
// Byte 0
,
// Byte 1
- StaticRemoteKey,
+ StaticRemoteKey | PaymentSecret,
// Byte 2
,
// Byte 3
// Byte 0
DataLossProtect | UpfrontShutdownScript | GossipQueries,
// Byte 1
- VariableLengthOnion | PaymentSecret,
+ VariableLengthOnion,
// Byte 2
BasicMPP,
// Byte 3
optional_features: [],
});
define_context!(InvoiceContext {
- required_features: [,,,],
+ required_features: [
+ // Byte 0
+ ,
+ // Byte 1
+ PaymentSecret,
+ // Byte 2
+ ,
+ ],
optional_features: [
// Byte 0
,
// Byte 1
- VariableLengthOnion | PaymentSecret,
+ VariableLengthOnion,
// Byte 2
BasicMPP,
],
/// Defines a feature with the given bits for the specified [`Context`]s. The generated trait is
/// useful for manipulating feature flags.
- ///
- /// [`Context`]: trait.Context.html
macro_rules! define_feature {
- ($odd_bit: expr, $feature: ident, [$($context: ty),+], $doc: expr) => {
+ ($odd_bit: expr, $feature: ident, [$($context: ty),+], $doc: expr, $optional_setter: ident,
+ $required_setter: ident) => {
#[doc = $doc]
///
/// See [BOLT #9] for details.
}
}
+ impl <T: $feature> Features<T> {
+ /// Set this feature as optional.
+ pub fn $optional_setter(mut self) -> Self {
+ <T as $feature>::set_optional_bit(&mut self.flags);
+ self
+ }
+
+ /// Set this feature as required.
+ pub fn $required_setter(mut self) -> Self {
+ <T as $feature>::set_required_bit(&mut self.flags);
+ self
+ }
+ }
+
$(
impl $feature for $context {
// EVEN_BIT % 2 == 0
const ASSERT_ODD_BIT_PARITY: usize = (<Self as $feature>::ODD_BIT % 2) - 1;
}
)*
+
}
}
define_feature!(1, DataLossProtect, [InitContext, NodeContext],
- "Feature flags for `option_data_loss_protect`.");
+ "Feature flags for `option_data_loss_protect`.", set_data_loss_protect_optional,
+ set_data_loss_protect_required);
// NOTE: Per Bolt #9, initial_routing_sync has no even bit.
- define_feature!(3, InitialRoutingSync, [InitContext],
- "Feature flags for `initial_routing_sync`.");
+ define_feature!(3, InitialRoutingSync, [InitContext], "Feature flags for `initial_routing_sync`.",
+ set_initial_routing_sync_optional, set_initial_routing_sync_required);
define_feature!(5, UpfrontShutdownScript, [InitContext, NodeContext],
- "Feature flags for `option_upfront_shutdown_script`.");
+ "Feature flags for `option_upfront_shutdown_script`.", set_upfront_shutdown_script_optional,
+ set_upfront_shutdown_script_required);
define_feature!(7, GossipQueries, [InitContext, NodeContext],
- "Feature flags for `gossip_queries`.");
+ "Feature flags for `gossip_queries`.", set_gossip_queries_optional, set_gossip_queries_required);
define_feature!(9, VariableLengthOnion, [InitContext, NodeContext, InvoiceContext],
- "Feature flags for `var_onion_optin`.");
+ "Feature flags for `var_onion_optin`.", set_variable_length_onion_optional,
+ set_variable_length_onion_required);
define_feature!(13, StaticRemoteKey, [InitContext, NodeContext],
- "Feature flags for `option_static_remotekey`.");
+ "Feature flags for `option_static_remotekey`.", set_static_remote_key_optional,
+ set_static_remote_key_required);
define_feature!(15, PaymentSecret, [InitContext, NodeContext, InvoiceContext],
- "Feature flags for `payment_secret`.");
+ "Feature flags for `payment_secret`.", set_payment_secret_optional, set_payment_secret_required);
define_feature!(17, BasicMPP, [InitContext, NodeContext, InvoiceContext],
- "Feature flags for `basic_mpp`.");
+ "Feature flags for `basic_mpp`.", set_basic_mpp_optional, set_basic_mpp_required);
define_feature!(27, ShutdownAnySegwit, [InitContext, NodeContext],
- "Feature flags for `opt_shutdown_anysegwit`.");
+ "Feature flags for `opt_shutdown_anysegwit`.", set_shutdown_any_segwit_optional,
+ set_shutdown_any_segwit_required);
#[cfg(test)]
define_context!(TestingContext {
#[cfg(test)]
define_feature!(23, UnknownFeature, [TestingContext],
- "Feature flags for an unknown feature used in testing.");
+ "Feature flags for an unknown feature used in testing.", set_unknown_feature_optional,
+ set_unknown_feature_required);
}
/// Tracks the set of features which a node implements, templated by the context in which it
/// appears.
///
/// (C-not exported) as we map the concrete feature types below directly instead
+#[derive(Eq)]
pub struct Features<T: sealed::Context> {
/// Note that, for convenience, flags is LITTLE endian (despite being big-endian on the wire)
flags: Vec<u8>,
}
}
+impl ToBase32 for InvoiceFeatures {
+ fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
+ // Explanation for the "4": the normal way to round up when dividing is to add the divisor
+ // minus one before dividing
+ let length_u5s = (self.flags.len() * 8 + 4) / 5 as usize;
+ let mut res_u5s: Vec<u5> = vec![u5::try_from_u8(0).unwrap(); length_u5s];
+ for (byte_idx, byte) in self.flags.iter().enumerate() {
+ let bit_pos_from_left_0_indexed = byte_idx * 8;
+ let new_u5_idx = length_u5s - (bit_pos_from_left_0_indexed / 5) as usize - 1;
+ let new_bit_pos = bit_pos_from_left_0_indexed % 5;
+ let shifted_chunk_u16 = (*byte as u16) << new_bit_pos;
+ let curr_u5_as_u8 = res_u5s[new_u5_idx].to_u8();
+ res_u5s[new_u5_idx] = u5::try_from_u8(curr_u5_as_u8 | ((shifted_chunk_u16 & 0x001f) as u8)).unwrap();
+ if new_u5_idx > 0 {
+ let curr_u5_as_u8 = res_u5s[new_u5_idx - 1].to_u8();
+ res_u5s[new_u5_idx - 1] = u5::try_from_u8(curr_u5_as_u8 | (((shifted_chunk_u16 >> 5) & 0x001f) as u8)).unwrap();
+ }
+ if new_u5_idx > 1 {
+ let curr_u5_as_u8 = res_u5s[new_u5_idx - 2].to_u8();
+ res_u5s[new_u5_idx - 2] = u5::try_from_u8(curr_u5_as_u8 | (((shifted_chunk_u16 >> 10) & 0x001f) as u8)).unwrap();
+ }
+ }
+ // Trim the highest feature bits.
+ while !res_u5s.is_empty() && res_u5s[0] == u5::try_from_u8(0).unwrap() {
+ res_u5s.remove(0);
+ }
+ writer.write(&res_u5s)
+ }
+}
+
+impl Base32Len for InvoiceFeatures {
+ fn base32_len(&self) -> usize {
+ self.to_base32().len()
+ }
+}
+
+impl FromBase32 for InvoiceFeatures {
+ type Err = bech32::Error;
+
+ fn from_base32(field_data: &[u5]) -> Result<InvoiceFeatures, bech32::Error> {
+ // Explanation for the "7": the normal way to round up when dividing is to add the divisor
+ // minus one before dividing
+ let length_bytes = (field_data.len() * 5 + 7) / 8 as usize;
+ let mut res_bytes: Vec<u8> = vec![0; length_bytes];
+ for (u5_idx, chunk) in field_data.iter().enumerate() {
+ let bit_pos_from_right_0_indexed = (field_data.len() - u5_idx - 1) * 5;
+ let new_byte_idx = (bit_pos_from_right_0_indexed / 8) as usize;
+ let new_bit_pos = bit_pos_from_right_0_indexed % 8;
+ let chunk_u16 = chunk.to_u8() as u16;
+ res_bytes[new_byte_idx] |= ((chunk_u16 << new_bit_pos) & 0xff) as u8;
+ if new_byte_idx != length_bytes - 1 {
+ res_bytes[new_byte_idx + 1] |= ((chunk_u16 >> (8-new_bit_pos)) & 0xff) as u8;
+ }
+ }
+ // Trim the highest feature bits.
+ while !res_bytes.is_empty() && res_bytes[res_bytes.len() - 1] == 0 {
+ res_bytes.pop();
+ }
+ Ok(InvoiceFeatures::from_le_bytes(res_bytes))
+ }
+}
+
impl<T: sealed::Context> Features<T> {
/// Create a blank Features with no features set
pub fn empty() -> Self {
}
}
- /// Creates features known by the implementation as defined by [`T::KNOWN_FEATURE_FLAGS`].
- ///
- /// [`T::KNOWN_FEATURE_FLAGS`]: sealed/trait.Context.html#associatedconstant.KNOWN_FEATURE_FLAGS
+ /// Creates a Features with the bits set which are known by the implementation
pub fn known() -> Self {
Self {
flags: T::KNOWN_FEATURE_FLAGS.to_vec(),
Features::<C> { flags, mark: PhantomData, }
}
- #[cfg(test)]
- /// Create a Features given a set of flags, in LE.
+ /// Create a Features given a set of flags, in little-endian. This is in reverse byte order from
+ /// most on-the-wire encodings.
+ /// (C-not exported) as we don't support export across multiple T
pub fn from_le_bytes(flags: Vec<u8>) -> Features<T> {
Features {
flags,
#[cfg(test)]
mod tests {
- use super::{ChannelFeatures, InitFeatures, NodeFeatures};
+ use super::{ChannelFeatures, InitFeatures, InvoiceFeatures, NodeFeatures};
+ use bitcoin::bech32::{Base32Len, FromBase32, ToBase32, u5};
#[test]
fn sanity_test_known_features() {
assert!(InitFeatures::known().supports_payment_secret());
assert!(NodeFeatures::known().supports_payment_secret());
- assert!(!InitFeatures::known().requires_payment_secret());
- assert!(!NodeFeatures::known().requires_payment_secret());
+ assert!(InitFeatures::known().requires_payment_secret());
+ assert!(NodeFeatures::known().requires_payment_secret());
assert!(InitFeatures::known().supports_basic_mpp());
assert!(NodeFeatures::known().supports_basic_mpp());
{
// Check that the flags are as expected:
// - option_data_loss_protect
- // - var_onion_optin | static_remote_key (req) | payment_secret
+ // - var_onion_optin | static_remote_key (req) | payment_secret(req)
// - basic_mpp
// - opt_shutdown_anysegwit
assert_eq!(node_features.flags.len(), 4);
assert_eq!(node_features.flags[0], 0b00000010);
- assert_eq!(node_features.flags[1], 0b10010010);
+ assert_eq!(node_features.flags[1], 0b01010010);
assert_eq!(node_features.flags[2], 0b00000010);
assert_eq!(node_features.flags[3], 0b00001000);
}
assert!(!features.supports_upfront_shutdown_script());
assert!(!init_features.supports_gossip_queries());
}
+
+ #[test]
+ fn set_feature_bits() {
+ let features = InvoiceFeatures::empty()
+ .set_basic_mpp_optional()
+ .set_payment_secret_required();
+ assert!(features.supports_basic_mpp());
+ assert!(!features.requires_basic_mpp());
+ assert!(features.requires_payment_secret());
+ assert!(features.supports_payment_secret());
+ }
+
+ #[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 = InvoiceFeatures::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 = InvoiceFeatures::from_base32(&features_as_u5s).unwrap();
+ assert_eq!(features, features_deserialized);
+ }
}