//! [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};
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
)*
];
}
+
+ impl alloc::fmt::Display for Features<$context> {
+ fn fmt(&self, fmt: &mut alloc::fmt::Formatter) -> Result<(), alloc::fmt::Error> {
+ $(
+ $(
+ fmt.write_fmt(format_args!("{}: {}, ", stringify!($required_feature),
+ if <$context as $required_feature>::requires_feature(&self.flags) { "required" }
+ else if <$context as $required_feature>::supports_feature(&self.flags) { "supported" }
+ else { "not supported" }))?;
+ )*
+ $(
+ fmt.write_fmt(format_args!("{}: {}, ", stringify!($optional_feature),
+ if <$context as $optional_feature>::requires_feature(&self.flags) { "required" }
+ else if <$context as $optional_feature>::supports_feature(&self.flags) { "supported" }
+ else { "not supported" }))?;
+ )*
+ )*
+ fmt.write_fmt(format_args!("unknown flags: {}",
+ if self.requires_unknown_bits() { "required" }
+ else if self.supports_unknown_bits() { "supported" } else { "none" }))
+ }
+ }
};
}
// Byte 0
,
// Byte 1
- StaticRemoteKey,
+ VariableLengthOnion | StaticRemoteKey | PaymentSecret,
// Byte 2
,
// Byte 3
// Byte 0
DataLossProtect | InitialRoutingSync | UpfrontShutdownScript | GossipQueries,
// Byte 1
- VariableLengthOnion | PaymentSecret,
+ ,
// Byte 2
BasicMPP,
// Byte 3
// Byte 0
,
// Byte 1
- StaticRemoteKey,
+ VariableLengthOnion | StaticRemoteKey | PaymentSecret,
// Byte 2
,
// Byte 3
,
+ // Byte 4
+ ,
+ // Byte 5
+ ,
+ // Byte 6
+ ,
],
optional_features: [
// Byte 0
DataLossProtect | UpfrontShutdownScript | GossipQueries,
// Byte 1
- VariableLengthOnion | PaymentSecret,
+ ,
// Byte 2
BasicMPP,
// Byte 3
ShutdownAnySegwit,
+ // Byte 4
+ ,
+ // Byte 5
+ ,
+ // Byte 6
+ Keysend,
],
});
define_context!(ChannelContext {
optional_features: [],
});
define_context!(InvoiceContext {
- required_features: [,,,],
- optional_features: [
+ required_features: [
// Byte 0
,
// Byte 1
VariableLengthOnion | PaymentSecret,
// Byte 2
+ ,
+ ],
+ optional_features: [
+ // Byte 0
+ ,
+ // Byte 1
+ ,
+ // Byte 2
BasicMPP,
],
});
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);
}
pub(crate) fn to_context<C: sealed::Context>(&self) -> Features<C> {
self.to_context_internal()
}
+
+ /// Getting a route for a keysend payment to a private node requires providing the payee's
+ /// features (since they were not announced in a node announcement). However, keysend payments
+ /// don't have an invoice to pull the payee's features from, so this method is provided for use in
+ /// [`get_keysend_route`], thus omitting the need for payers to manually construct an
+ /// `InvoiceFeatures` for [`get_route`].
+ ///
+ /// [`get_keysend_route`]: crate::routing::router::get_keysend_route
+ /// [`get_route`]: crate::routing::router::get_route
+ pub(crate) fn for_keysend() -> InvoiceFeatures {
+ InvoiceFeatures::empty().set_variable_length_onion_optional()
+ }
}
impl ToBase32 for InvoiceFeatures {
/// 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, }
/// 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,
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> {
pub(crate) fn requires_data_loss_protect(&self) -> bool {
<T as sealed::DataLossProtect>::requires_feature(&self.flags)
}
+ #[cfg(test)]
pub(crate) fn supports_data_loss_protect(&self) -> bool {
<T as sealed::DataLossProtect>::supports_feature(&self.flags)
}
pub(crate) fn requires_payment_secret(&self) -> bool {
<T as sealed::PaymentSecret>::requires_feature(&self.flags)
}
- // Note that we never need to test this since what really matters is the invoice - iff the
- // invoice provides a payment_secret, we assume that we can use it (ie that the recipient
- // supports payment_secret).
- #[allow(dead_code)]
- pub(crate) fn supports_payment_secret(&self) -> bool {
+ /// Returns whether the `payment_secret` feature is supported.
+ pub fn supports_payment_secret(&self) -> bool {
<T as sealed::PaymentSecret>::supports_feature(&self.flags)
}
}
assert!(InitFeatures::known().supports_variable_length_onion());
assert!(NodeFeatures::known().supports_variable_length_onion());
- assert!(!InitFeatures::known().requires_variable_length_onion());
- assert!(!NodeFeatures::known().requires_variable_length_onion());
+ assert!(InvoiceFeatures::known().supports_variable_length_onion());
+ assert!(InitFeatures::known().requires_variable_length_onion());
+ assert!(NodeFeatures::known().requires_variable_length_onion());
+ assert!(InvoiceFeatures::known().requires_variable_length_onion());
assert!(InitFeatures::known().supports_static_remote_key());
assert!(NodeFeatures::known().supports_static_remote_key());
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!(InvoiceFeatures::known().supports_payment_secret());
+ assert!(InitFeatures::known().requires_payment_secret());
+ assert!(NodeFeatures::known().requires_payment_secret());
+ assert!(InvoiceFeatures::known().requires_payment_secret());
assert!(InitFeatures::known().supports_basic_mpp());
assert!(NodeFeatures::known().supports_basic_mpp());
+ assert!(InvoiceFeatures::known().supports_basic_mpp());
assert!(!InitFeatures::known().requires_basic_mpp());
assert!(!NodeFeatures::known().requires_basic_mpp());
+ assert!(!InvoiceFeatures::known().requires_basic_mpp());
assert!(InitFeatures::known().supports_shutdown_anysegwit());
assert!(NodeFeatures::known().supports_shutdown_anysegwit());
#[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());
}
{
// Check that the flags are as expected:
// - option_data_loss_protect
- // - var_onion_optin | static_remote_key (req) | payment_secret
+ // - var_onion_optin (req) | 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], 0b01010001);
assert_eq!(node_features.flags[2], 0b00000010);
assert_eq!(node_features.flags[3], 0b00001000);
}
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()
projects / rust-lightning / blobdiff