Move features into a separate module out of msgs.

diff --git a/fuzz/src/chanmon_consistency.rs b/fuzz/src/chanmon_consistency.rs
index f86ee56fab8288c5671c192b766b27eeafe511e8..9e2dbf3596fb68a21a953a4405ae93d07e3ae1e2 100644 (file)
--- a/fuzz/src/chanmon_consistency.rs
+++ b/fuzz/src/chanmon_consistency.rs
@@ -29,7 +29,8 @@ use lightning::ln::channelmonitor;
 use lightning::ln::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateErr, HTLCUpdate};
 use lightning::ln::channelmanager::{ChannelManager, PaymentHash, PaymentPreimage, ChannelManagerReadArgs};
 use lightning::ln::router::{Route, RouteHop};
-use lightning::ln::msgs::{CommitmentUpdate, ChannelMessageHandler, ErrorAction, UpdateAddHTLC, Features, FeatureContextInit};
+use lightning::ln::features::InitFeatures;
+use lightning::ln::msgs::{CommitmentUpdate, ChannelMessageHandler, ErrorAction, UpdateAddHTLC};
 use lightning::util::enforcing_trait_impls::EnforcingChannelKeys;
 use lightning::util::events;
 use lightning::util::logger::Logger;
@@ -252,7 +253,7 @@ pub fn do_test(data: &[u8]) {
                                } else { panic!("Wrong event type"); }
                        };
 
-                       $dest.handle_open_channel(&$source.get_our_node_id(), Features::<FeatureContextInit>::supported(), &open_channel);
+                       $dest.handle_open_channel(&$source.get_our_node_id(), InitFeatures::supported(), &open_channel);
                        let accept_channel = {
                                let events = $dest.get_and_clear_pending_msg_events();
                                assert_eq!(events.len(), 1);
@@ -261,7 +262,7 @@ pub fn do_test(data: &[u8]) {
                                } else { panic!("Wrong event type"); }
                        };
 
-                       $source.handle_accept_channel(&$dest.get_our_node_id(), Features::<FeatureContextInit>::supported(), &accept_channel);
+                       $source.handle_accept_channel(&$dest.get_our_node_id(), InitFeatures::supported(), &accept_channel);
                        {
                                let events = $source.get_and_clear_pending_events();
                                assert_eq!(events.len(), 1);

diff --git a/lightning/src/ln/chanmon_update_fail_tests.rs b/lightning/src/ln/chanmon_update_fail_tests.rs
index 7991e13065a49601e831d513e776052a03852fcf..fe63e46f35761f9d735dc8b34722b5b73a2b32ad 100644 (file)
--- a/lightning/src/ln/chanmon_update_fail_tests.rs
+++ b/lightning/src/ln/chanmon_update_fail_tests.rs
@@ -5,8 +5,9 @@
 
 use ln::channelmanager::{RAACommitmentOrder, PaymentPreimage, PaymentHash};
 use ln::channelmonitor::ChannelMonitorUpdateErr;
+use ln::features::InitFeatures;
 use ln::msgs;
-use ln::msgs::{ChannelMessageHandler, ErrorAction, Features, FeatureContextInit, RoutingMessageHandler};
+use ln::msgs::{ChannelMessageHandler, ErrorAction, RoutingMessageHandler};
 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
 use util::errors::APIError;
 
@@ -19,7 +20,7 @@ use ln::functional_test_utils::*;
 fn test_simple_monitor_permanent_update_fail() {
        // Test that we handle a simple permanent monitor update failure
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
        let (_, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
@@ -49,7 +50,7 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
        // Test that we can recover from a simple temporary monitor update failure optionally with
        // a disconnect in between
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
        let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
@@ -148,7 +149,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
        //   through, swapping message ordering based on disconnect_count & 8 and optionally
        //   disconnect/reconnecting based on disconnect_count.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
@@ -474,7 +475,7 @@ fn test_monitor_temporary_update_fail_c() {
 fn test_monitor_update_fail_cs() {
        // Tests handling of a monitor update failure when processing an incoming commitment_signed
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
        let (payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
@@ -553,7 +554,7 @@ fn test_monitor_update_fail_no_rebroadcast() {
        // test_restore_channel_monitor() is required. Backported from
        // chanmon_fail_consistency fuzz tests.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
        let (payment_preimage_1, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
@@ -595,7 +596,7 @@ fn test_monitor_update_raa_while_paused() {
        // Tests handling of an RAA while monitor updating has already been marked failed.
        // Backported from chanmon_fail_consistency fuzz tests as this used to be broken.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        send_payment(&nodes[0], &[&nodes[1]], 5000000, 5_000_000);
 
@@ -662,8 +663,8 @@ fn test_monitor_update_raa_while_paused() {
 fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
        // Tests handling of a monitor update failure when processing an incoming RAA
        let mut nodes = create_network(3, &[None, None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance a bit so that we can send backwards from 2 to 1.
        send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
@@ -915,8 +916,8 @@ fn test_monitor_update_fail_reestablish() {
        // channel_reestablish generating a monitor update (which comes from freeing holding cell
        // HTLCs).
        let mut nodes = create_network(3, &[None, None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
 
@@ -993,7 +994,7 @@ fn raa_no_response_awaiting_raa_state() {
        // in question (assuming it intends to respond with a CS after monitor updating is restored).
        // Backported from chanmon_fail_consistency fuzz tests as this used to be broken.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
        let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
@@ -1106,7 +1107,7 @@ fn claim_while_disconnected_monitor_update_fail() {
        // code introduced a regression in this test (specifically, this caught a removal of the
        // channel_reestablish handling ensuring the order was sensical given the messages used).
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // Forward a payment for B to claim
        let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
@@ -1221,7 +1222,7 @@ fn monitor_failed_no_reestablish_response() {
        // Backported from chanmon_fail_consistency fuzz tests as it caught a long-standing
        // debug_assert!() failure in channel_reestablish handling.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // Route the payment and deliver the initial commitment_signed (with a monitor update failure
        // on receipt).
@@ -1287,7 +1288,7 @@ fn first_message_on_recv_ordering() {
        // payment applied).
        // Backported from chanmon_fail_consistency fuzz tests as it caught a bug here.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // Route the first payment outbound, holding the last RAA for B until we are set up so that we
        // can deliver it and fail the monitor update.
@@ -1372,8 +1373,8 @@ fn test_monitor_update_fail_claim() {
        // payment from B to A fail due to the paused channel. Finally, we restore the channel monitor
        // updating and claim the payment on B.
        let mut nodes = create_network(3, &[None, None, None]);
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance a bit so that we can send backwards from 3 to 2.
        send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
@@ -1445,8 +1446,8 @@ fn test_monitor_update_on_pending_forwards() {
        // The payment from A to C will be failed by C and pending a back-fail to A, while the payment
        // from C to A will be pending a forward to A.
        let mut nodes = create_network(3, &[None, None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance a bit so that we can send backwards from 3 to 1.
        send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
@@ -1510,7 +1511,7 @@ fn monitor_update_claim_fail_no_response() {
        // Backported from chanmon_fail_consistency fuzz tests as an unmerged version of the handling
        // code was broken.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // Forward a payment for B to claim
        let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
@@ -1571,8 +1572,8 @@ fn do_during_funding_monitor_fail(fail_on_generate: bool, restore_between_fails:
        let mut nodes = create_network(2, &[None, None]);
 
        nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 43).unwrap();
-       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), Features::<FeatureContextInit>::supported(), &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()));
-       nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), Features::<FeatureContextInit>::supported(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()));
+       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::supported(), &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()));
+       nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::supported(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()));
 
        let (temporary_channel_id, funding_tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 43);
 

diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index 09b5a2040bfa49fff9b44bac885e4d4b1a904a5b..6f509f214837cdb84e6a64b4a08897695c34592e 100644 (file)
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -15,8 +15,9 @@ use secp256k1::key::{PublicKey,SecretKey};
 use secp256k1::{Secp256k1,Signature};
 use secp256k1;
 
+use ln::features::{ChannelFeatures, InitFeatures};
 use ln::msgs;
-use ln::msgs::{DecodeError, OptionalField, ChannelFeatures, InitFeatures, DataLossProtect};
+use ln::msgs::{DecodeError, OptionalField, DataLossProtect};
 use ln::channelmonitor::ChannelMonitor;
 use ln::channelmanager::{PendingHTLCStatus, HTLCSource, HTLCFailReason, HTLCFailureMsg, PendingForwardHTLCInfo, RAACommitmentOrder, PaymentPreimage, PaymentHash, BREAKDOWN_TIMEOUT, MAX_LOCAL_BREAKDOWN_TIMEOUT};
 use ln::chan_utils::{LocalCommitmentTransaction,TxCreationKeys,HTLCOutputInCommitment,HTLC_SUCCESS_TX_WEIGHT,HTLC_TIMEOUT_TX_WEIGHT};

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 632800b2cd8db29217c3aa5eb98ed8ce66e3f429..698d463e5f6dea2f0158f4030d1908132dcad9b5 100644 (file)
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -30,8 +30,8 @@ use chain::transaction::OutPoint;
 use ln::channel::{Channel, ChannelError};
 use ln::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateErr, ManyChannelMonitor, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ANTI_REORG_DELAY};
 use ln::router::Route;
+use ln::features::InitFeatures;
 use ln::msgs;
-use ln::msgs::InitFeatures;
 use ln::onion_utils;
 use ln::msgs::{ChannelMessageHandler, DecodeError, LightningError};
 use chain::keysinterface::{ChannelKeys, KeysInterface};

diff --git a/lightning/src/ln/features.rs b/lightning/src/ln/features.rs
new file mode 100644 (file)
index 0000000..ac9af14
--- /dev/null
+++ b/lightning/src/ln/features.rs
@@ -0,0 +1,261 @@
+//! Lightning exposes sets of supported operations through "feature flags". This module includes
+//! types to store those feature flags and query for specific flags.
+
+use std::{cmp, fmt};
+use std::result::Result;
+use std::marker::PhantomData;
+
+use ln::msgs::DecodeError;
+use util::ser::{Readable, Writeable, Writer};
+
+/// The context in which a Feature object appears determines which bits of features the node
+/// supports will be set. We use this when creating our own Feature objects to select which bits to
+/// set and when passing around Feature objects to ensure the bits we're checking for are
+/// available.
+///
+/// This Context represents when the Feature appears in the init message, sent between peers and not
+/// rumored around the P2P network.
+pub struct FeatureContextInit {}
+/// The context in which a Feature object appears determines which bits of features the node
+/// supports will be set. We use this when creating our own Feature objects to select which bits to
+/// set and when passing around Feature objects to ensure the bits we're checking for are
+/// available.
+///
+/// This Context represents when the Feature appears in the node_announcement message, as it is
+/// rumored around the P2P network.
+pub struct FeatureContextNode {}
+/// The context in which a Feature object appears determines which bits of features the node
+/// supports will be set. We use this when creating our own Feature objects to select which bits to
+/// set and when passing around Feature objects to ensure the bits we're checking for are
+/// available.
+///
+/// This Context represents when the Feature appears in the ChannelAnnouncement message, as it is
+/// rumored around the P2P network.
+pub struct FeatureContextChannel {}
+/// The context in which a Feature object appears determines which bits of features the node
+/// supports will be set. We use this when creating our own Feature objects to select which bits to
+/// set and when passing around Feature objects to ensure the bits we're checking for are
+/// available.
+///
+/// This Context represents when the Feature appears in an invoice, used to determine the different
+/// options available for routing a payment.
+///
+/// Note that this is currently unused as invoices come to us via a different crate and are not
+/// native to rust-lightning directly.
+pub struct FeatureContextInvoice {}
+
+/// An internal trait capturing the various future context types
+pub trait FeatureContext {}
+impl FeatureContext for FeatureContextInit {}
+impl FeatureContext for FeatureContextNode {}
+impl FeatureContext for FeatureContextChannel {}
+impl FeatureContext for FeatureContextInvoice {}
+
+/// An internal trait capturing FeatureContextInit and FeatureContextNode
+pub trait FeatureContextInitNode : FeatureContext {}
+impl FeatureContextInitNode for FeatureContextInit {}
+impl FeatureContextInitNode for FeatureContextNode {}
+
+/// Tracks the set of features which a node implements, templated by the context in which it
+/// appears.
+pub struct Features<T: FeatureContext> {
+       /// Note that, for convinience, flags is LITTLE endian (despite being big-endian on the wire)
+       flags: Vec<u8>,
+       mark: PhantomData<T>,
+}
+
+impl<T: FeatureContext> Clone for Features<T> {
+       fn clone(&self) -> Self {
+               Self {
+                       flags: self.flags.clone(),
+                       mark: PhantomData,
+               }
+       }
+}
+impl<T: FeatureContext> PartialEq for Features<T> {
+       fn eq(&self, o: &Self) -> bool {
+               self.flags.eq(&o.flags)
+       }
+}
+impl<T: FeatureContext> fmt::Debug for Features<T> {
+       fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+               self.flags.fmt(fmt)
+       }
+}
+
+/// A feature message as it appears in an init message
+pub type InitFeatures = Features<FeatureContextInit>;
+/// A feature message as it appears in a node_announcement message
+pub type NodeFeatures = Features<FeatureContextNode>;
+/// A feature message as it appears in a channel_announcement message
+pub type ChannelFeatures = Features<FeatureContextChannel>;
+
+impl<T: FeatureContextInitNode> Features<T> {
+       /// Create a Features with the features we support
+       #[cfg(not(feature = "fuzztarget"))]
+       pub(crate) fn supported() -> Features<T> {
+               Features {
+                       flags: vec![2 | 1 << 5],
+                       mark: PhantomData,
+               }
+       }
+       #[cfg(feature = "fuzztarget")]
+       pub fn supported() -> Features<T> {
+               Features {
+                       flags: vec![2 | 1 << 5],
+                       mark: PhantomData,
+               }
+       }
+}
+
+impl Features<FeatureContextChannel> {
+       /// Create a Features with the features we support
+       #[cfg(not(feature = "fuzztarget"))]
+       pub(crate) fn supported() -> Features<FeatureContextChannel> {
+               Features {
+                       flags: Vec::new(),
+                       mark: PhantomData,
+               }
+       }
+       #[cfg(feature = "fuzztarget")]
+       pub fn supported() -> Features<FeatureContextChannel> {
+               Features {
+                       flags: Vec::new(),
+                       mark: PhantomData,
+               }
+       }
+}
+
+impl<T: FeatureContext> Features<T> {
+       /// Create a blank Features with no features set
+       pub fn empty() -> Features<T> {
+               Features {
+                       flags: Vec::new(),
+                       mark: PhantomData,
+               }
+       }
+
+       #[cfg(test)]
+       /// Create a Features given a set of flags, in LE.
+       pub fn from_le_bytes(flags: Vec<u8>) -> Features<T> {
+               Features {
+                       flags,
+                       mark: PhantomData,
+               }
+       }
+
+       #[cfg(test)]
+       /// Gets the underlying flags set, in LE.
+       pub fn le_flags(&self) -> &Vec<u8> {
+               &self.flags
+       }
+
+       pub(crate) fn requires_unknown_bits(&self) -> bool {
+               self.flags.iter().enumerate().any(|(idx, &byte)| {
+                       ( idx != 0 && (byte & 0x55) != 0 ) || ( idx == 0 && (byte & 0x14) != 0 )
+               })
+       }
+
+       pub(crate) fn supports_unknown_bits(&self) -> bool {
+               self.flags.iter().enumerate().any(|(idx, &byte)| {
+                       ( idx != 0 && byte != 0 ) || ( idx == 0 && (byte & 0xc4) != 0 )
+               })
+       }
+
+       /// The number of bytes required to represent the feature flags present. This does not include
+       /// the length bytes which are included in the serialized form.
+       pub(crate) fn byte_count(&self) -> usize {
+               self.flags.len()
+       }
+
+       #[cfg(test)]
+       pub(crate) fn set_require_unknown_bits(&mut self) {
+               let newlen = cmp::max(2, self.flags.len());
+               self.flags.resize(newlen, 0u8);
+               self.flags[1] |= 0x40;
+       }
+
+       #[cfg(test)]
+       pub(crate) fn clear_require_unknown_bits(&mut self) {
+               let newlen = cmp::max(2, self.flags.len());
+               self.flags.resize(newlen, 0u8);
+               self.flags[1] &= !0x40;
+               if self.flags.len() == 2 && self.flags[1] == 0 {
+                       self.flags.resize(1, 0u8);
+               }
+       }
+}
+
+impl<T: FeatureContextInitNode> Features<T> {
+       pub(crate) fn supports_data_loss_protect(&self) -> bool {
+               self.flags.len() > 0 && (self.flags[0] & 3) != 0
+       }
+
+       pub(crate) fn supports_upfront_shutdown_script(&self) -> bool {
+               self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0
+       }
+       #[cfg(test)]
+       pub(crate) fn unset_upfront_shutdown_script(&mut self) {
+               self.flags[0] ^= 1 << 5;
+       }
+}
+
+impl Features<FeatureContextInit> {
+       pub(crate) fn initial_routing_sync(&self) -> bool {
+               self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0
+       }
+       pub(crate) fn set_initial_routing_sync(&mut self) {
+               if self.flags.len() == 0 {
+                       self.flags.resize(1, 1 << 3);
+               } else {
+                       self.flags[0] |= 1 << 3;
+               }
+       }
+
+       /// Writes all features present up to, and including, 13.
+       pub(crate) fn write_up_to_13<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+               let len = cmp::min(2, self.flags.len());
+               w.size_hint(len + 2);
+               (len as u16).write(w)?;
+               for i in (0..len).rev() {
+                       if i == 0 {
+                               self.flags[i].write(w)?;
+                       } else {
+                               (self.flags[i] & ((1 << (14 - 8)) - 1)).write(w)?;
+                       }
+               }
+               Ok(())
+       }
+
+       /// or's another InitFeatures into this one.
+       pub(crate) fn or(mut self, o: InitFeatures) -> InitFeatures {
+               let total_feature_len = cmp::max(self.flags.len(), o.flags.len());
+               self.flags.resize(total_feature_len, 0u8);
+               for (feature, o_feature) in self.flags.iter_mut().zip(o.flags.iter()) {
+                       *feature |= *o_feature;
+               }
+               self
+       }
+}
+
+impl<T: FeatureContext> Writeable for Features<T> {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+               w.size_hint(self.flags.len() + 2);
+               (self.flags.len() as u16).write(w)?;
+               for f in self.flags.iter().rev() { // Swap back to big-endian
+                       f.write(w)?;
+               }
+               Ok(())
+       }
+}
+
+impl<R: ::std::io::Read, T: FeatureContext> Readable<R> for Features<T> {
+       fn read(r: &mut R) -> Result<Self, DecodeError> {
+               let mut flags: Vec<u8> = Readable::read(r)?;
+               flags.reverse(); // Swap to little-endian
+               Ok(Self {
+                       flags,
+                       mark: PhantomData,
+               })
+       }
+}

diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index 05e63a52761f00b378468a5c5ead8d5e0c3ae07c..3936460f37eae318463543da2d45c566409bb2f1 100644 (file)
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -6,8 +6,9 @@ use chain::transaction::OutPoint;
 use chain::keysinterface::KeysInterface;
 use ln::channelmanager::{ChannelManager,RAACommitmentOrder, PaymentPreimage, PaymentHash};
 use ln::router::{Route, Router};
+use ln::features::InitFeatures;
 use ln::msgs;
-use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler, Features, FeatureContextInit};
+use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
 use util::enforcing_trait_impls::EnforcingChannelKeys;
 use util::test_utils;
 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
@@ -79,11 +80,11 @@ impl Drop for Node {
        }
 }
 
-pub fn create_chan_between_nodes(node_a: &Node, node_b: &Node, a_flags: Features<FeatureContextInit>, b_flags: Features<FeatureContextInit>) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
+pub fn create_chan_between_nodes(node_a: &Node, node_b: &Node, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
        create_chan_between_nodes_with_value(node_a, node_b, 100000, 10001, a_flags, b_flags)
 }
 
-pub fn create_chan_between_nodes_with_value(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64, a_flags: Features<FeatureContextInit>, b_flags: Features<FeatureContextInit>) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
+pub fn create_chan_between_nodes_with_value(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
        let (funding_locked, channel_id, tx) = create_chan_between_nodes_with_value_a(node_a, node_b, channel_value, push_msat, a_flags, b_flags);
        let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(node_a, node_b, &funding_locked);
        (announcement, as_update, bs_update, channel_id, tx)
@@ -178,7 +179,7 @@ pub fn create_funding_transaction(node: &Node, expected_chan_value: u64, expecte
        }
 }
 
-pub fn create_chan_between_nodes_with_value_init(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64, a_flags: Features<FeatureContextInit>, b_flags: Features<FeatureContextInit>) -> Transaction {
+pub fn create_chan_between_nodes_with_value_init(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> Transaction {
        node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42).unwrap();
        node_b.node.handle_open_channel(&node_a.node.get_our_node_id(), a_flags, &get_event_msg!(node_a, MessageSendEvent::SendOpenChannel, node_b.node.get_our_node_id()));
        node_a.node.handle_accept_channel(&node_b.node.get_our_node_id(), b_flags, &get_event_msg!(node_b, MessageSendEvent::SendAcceptChannel, node_a.node.get_our_node_id()));
@@ -253,7 +254,7 @@ pub fn create_chan_between_nodes_with_value_confirm(node_a: &Node, node_b: &Node
        create_chan_between_nodes_with_value_confirm_second(node_b, node_a)
 }
 
-pub fn create_chan_between_nodes_with_value_a(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64, a_flags: Features<FeatureContextInit>, b_flags: Features<FeatureContextInit>) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32], Transaction) {
+pub fn create_chan_between_nodes_with_value_a(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32], Transaction) {
        let tx = create_chan_between_nodes_with_value_init(node_a, node_b, channel_value, push_msat, a_flags, b_flags);
        let (msgs, chan_id) = create_chan_between_nodes_with_value_confirm(node_a, node_b, &tx);
        (msgs, chan_id, tx)
@@ -291,11 +292,11 @@ pub fn create_chan_between_nodes_with_value_b(node_a: &Node, node_b: &Node, as_f
        ((*announcement).clone(), (*as_update).clone(), (*bs_update).clone())
 }
 
-pub fn create_announced_chan_between_nodes(nodes: &Vec<Node>, a: usize, b: usize, a_flags: Features<FeatureContextInit>, b_flags: Features<FeatureContextInit>) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
+pub fn create_announced_chan_between_nodes(nodes: &Vec<Node>, a: usize, b: usize, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
        create_announced_chan_between_nodes_with_value(nodes, a, b, 100000, 10001, a_flags, b_flags)
 }
 
-pub fn create_announced_chan_between_nodes_with_value(nodes: &Vec<Node>, a: usize, b: usize, channel_value: u64, push_msat: u64, a_flags: Features<FeatureContextInit>, b_flags: Features<FeatureContextInit>) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
+pub fn create_announced_chan_between_nodes_with_value(nodes: &Vec<Node>, a: usize, b: usize, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
        let chan_announcement = create_chan_between_nodes_with_value(&nodes[a], &nodes[b], channel_value, push_msat, a_flags, b_flags);
        for node in nodes {
                assert!(node.router.handle_channel_announcement(&chan_announcement.0).unwrap());

diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs
index 0ca492596d08a0af2af2f98b1a4c357ee97492da..9f077c0579a676e486f4e360c797ce826c1ba41b 100644 (file)
--- a/lightning/src/ln/functional_tests.rs
+++ b/lightning/src/ln/functional_tests.rs
@@ -11,8 +11,9 @@ use ln::channelmonitor::{ChannelMonitor, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD
 use ln::channel::{ACCEPTED_HTLC_SCRIPT_WEIGHT, OFFERED_HTLC_SCRIPT_WEIGHT, Channel, ChannelError};
 use ln::onion_utils;
 use ln::router::{Route, RouteHop};
+use ln::features::{ChannelFeatures, InitFeatures};
 use ln::msgs;
-use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler,HTLCFailChannelUpdate, Features, FeatureContextChannel, FeatureContextInit, ErrorAction};
+use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler,HTLCFailChannelUpdate, ErrorAction};
 use util::enforcing_trait_impls::EnforcingChannelKeys;
 use util::test_utils;
 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
@@ -69,7 +70,7 @@ fn test_insane_channel_opens() {
        // Test helper that asserts we get the correct error string given a mutator
        // that supposedly makes the channel open message insane
        let insane_open_helper = |expected_error_str: &str, message_mutator: fn(msgs::OpenChannel) -> msgs::OpenChannel| {
-               nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), Features::<FeatureContextInit>::supported(), &message_mutator(open_channel_message.clone()));
+               nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::supported(), &message_mutator(open_channel_message.clone()));
                let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
                assert_eq!(msg_events.len(), 1);
                if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
@@ -108,7 +109,7 @@ fn test_insane_channel_opens() {
 #[test]
 fn test_async_inbound_update_fee() {
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        let channel_id = chan.2;
 
        // balancing
@@ -218,7 +219,7 @@ fn test_update_fee_unordered_raa() {
        // Just the intro to the previous test followed by an out-of-order RAA (which caused a
        // crash in an earlier version of the update_fee patch)
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        let channel_id = chan.2;
 
        // balancing
@@ -268,7 +269,7 @@ fn test_update_fee_unordered_raa() {
 #[test]
 fn test_multi_flight_update_fee() {
        let nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        let channel_id = chan.2;
 
        // A                                        B
@@ -372,7 +373,7 @@ fn test_multi_flight_update_fee() {
 #[test]
 fn test_update_fee_vanilla() {
        let nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        let channel_id = chan.2;
 
        let feerate = get_feerate!(nodes[0], channel_id);
@@ -411,7 +412,7 @@ fn test_update_fee_vanilla() {
 fn test_update_fee_that_funder_cannot_afford() {
        let nodes = create_network(2, &[None, None]);
        let channel_value = 1888;
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 700000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 700000, InitFeatures::supported(), InitFeatures::supported());
        let channel_id = chan.2;
 
        let feerate = 260;
@@ -459,7 +460,7 @@ fn test_update_fee_that_funder_cannot_afford() {
 #[test]
 fn test_update_fee_with_fundee_update_add_htlc() {
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        let channel_id = chan.2;
 
        // balancing
@@ -553,7 +554,7 @@ fn test_update_fee_with_fundee_update_add_htlc() {
 #[test]
 fn test_update_fee() {
        let nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        let channel_id = chan.2;
 
        // A                                        B
@@ -654,7 +655,7 @@ fn test_update_fee() {
 fn pre_funding_lock_shutdown_test() {
        // Test sending a shutdown prior to funding_locked after funding generation
        let nodes = create_network(2, &[None, None]);
-       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0, InitFeatures::supported(), InitFeatures::supported());
        let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
        nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![tx.clone()]}, 1);
        nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![tx.clone()]}, 1);
@@ -680,8 +681,8 @@ fn pre_funding_lock_shutdown_test() {
 fn updates_shutdown_wait() {
        // Test sending a shutdown with outstanding updates pending
        let mut nodes = create_network(3, &[None, None, None]);
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
        let route_1 = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
        let route_2 = nodes[1].router.get_route(&nodes[0].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
 
@@ -752,8 +753,8 @@ fn updates_shutdown_wait() {
 fn htlc_fail_async_shutdown() {
        // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order
        let mut nodes = create_network(3, &[None, None, None]);
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
@@ -833,8 +834,8 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) {
        // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of
        // messages delivered prior to disconnect
        let nodes = create_network(3, &[None, None, None]);
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
 
@@ -994,9 +995,9 @@ fn fake_network_test() {
        let nodes = create_network(4, &[None, None, None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
+       let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance the network a bit by relaying one payment through all the channels...
        send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
@@ -1014,7 +1015,7 @@ fn fake_network_test() {
        fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], payment_hash_1);
 
        // Add a new channel that skips 3
-       let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::supported(), InitFeatures::supported());
 
        send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000, 1_000_000);
        send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000, 1_000_000);
@@ -1076,7 +1077,7 @@ fn fake_network_test() {
        claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1, 1_000_000);
 
        // Add a duplicate new channel from 2 to 4
-       let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::supported(), InitFeatures::supported());
 
        // Send some payments across both channels
        let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
@@ -1109,8 +1110,8 @@ fn holding_cell_htlc_counting() {
        // to ensure we don't end up with HTLCs sitting around in our holding cell for several
        // commitment dance rounds.
        let mut nodes = create_network(3, &[None, None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        let mut payments = Vec::new();
        for _ in 0..::ln::channel::OUR_MAX_HTLCS {
@@ -1238,11 +1239,11 @@ fn duplicate_htlc_test() {
        let mut nodes = create_network(6, &[None, None, None, None, None, None]);
 
        // Create some initial channels to route via 3 to 4/5 from 0/1/2
-       create_announced_chan_between_nodes(&nodes, 0, 3, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 3, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 2, 3, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 3, 4, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 3, 5, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::supported(), InitFeatures::supported());
 
        let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], 1000000);
 
@@ -1264,7 +1265,7 @@ fn test_duplicate_htlc_different_direction_onchain() {
        // in opposite directions.
        let nodes = create_network(2, &[None, None]);
 
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // balancing
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
@@ -1330,8 +1331,8 @@ fn test_duplicate_htlc_different_direction_onchain() {
 fn do_channel_reserve_test(test_recv: bool) {
 
        let mut nodes = create_network(3, &[None, None, None]);
-       let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1900, 1001, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1900, 1001, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1900, 1001, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1900, 1001, InitFeatures::supported(), InitFeatures::supported());
 
        let mut stat01 = get_channel_value_stat!(nodes[0], chan_1.2);
        let mut stat11 = get_channel_value_stat!(nodes[1], chan_1.2);
@@ -1614,7 +1615,7 @@ fn channel_reserve_in_flight_removes() {
        //  * Now B happily sends another HTLC, potentially violating its reserve value from A's point
        //    of view (if A counts the AwaitingRemovedRemoteRevoke HTLC).
        let mut nodes = create_network(2, &[None, None]);
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let b_chan_values = get_channel_value_stat!(nodes[1], chan_1.2);
        // Route the first two HTLCs.
@@ -1743,10 +1744,10 @@ fn channel_monitor_network_test() {
        let nodes = create_network(5, &[None, None, None, None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
+       let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::supported(), InitFeatures::supported());
+       let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance the network a bit by relaying one payment through all the channels...
        send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
@@ -1890,7 +1891,7 @@ fn test_justice_tx() {
        let cfgs = [Some(alice_config), Some(bob_config)];
        let nodes = create_network(2, &cfgs);
        // Create some new channels:
-       let chan_5 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_5 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // A pending HTLC which will be revoked:
        let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
@@ -1934,7 +1935,7 @@ fn test_justice_tx() {
 
        // We test justice_tx build by A on B's revoked HTLC-Success tx
        // Create some new channels:
-       let chan_6 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_6 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        {
                let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
                node_txn.clear();
@@ -1980,7 +1981,7 @@ fn revoked_output_claim() {
        // Simple test to ensure a node will claim a revoked output when a stale remote commitment
        // transaction is broadcast by its counterparty
        let nodes = create_network(2, &[None, None]);
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        // node[0] is gonna to revoke an old state thus node[1] should be able to claim the revoked output
        let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2).unwrap().channel_monitor().get_latest_local_commitment_txn();
        assert_eq!(revoked_local_txn.len(), 1);
@@ -2011,7 +2012,7 @@ fn claim_htlc_outputs_shared_tx() {
        let nodes = create_network(2, &[None, None]);
 
        // Create some new channel:
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance the network to generate htlc in the two directions
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
@@ -2085,7 +2086,7 @@ fn claim_htlc_outputs_single_tx() {
        // Node revoked old state, htlcs have timed out, claim each of them in separated justice tx
        let nodes = create_network(2, &[None, None]);
 
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance the network to generate htlc in the two directions
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
@@ -2184,8 +2185,8 @@ fn test_htlc_on_chain_success() {
        let nodes = create_network(3, &[None, None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance the network a bit by relaying one payment through all the channels...
        send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
@@ -2349,8 +2350,8 @@ fn test_htlc_on_chain_timeout() {
        let nodes = create_network(3, &[None, None, None]);
 
        // Create some intial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance the network a bit by relaying one payment thorugh all the channels...
        send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
@@ -2457,8 +2458,8 @@ fn test_simple_commitment_revoked_fail_backward() {
        let nodes = create_network(3, &[None, None, None]);
 
        // Create some initial channels
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
        // Get the will-be-revoked local txn from nodes[2]
@@ -2525,8 +2526,8 @@ fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use
        let mut nodes = create_network(3, &[None, None, None]);
 
        // Create some initial channels
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], if no_to_remote { 10_000 } else { 3_000_000 });
        // Get the will-be-revoked local txn from nodes[2]
@@ -2734,7 +2735,7 @@ fn test_htlc_ignore_latest_remote_commitment() {
        // Test that HTLC transactions spending the latest remote commitment transaction are simply
        // ignored if we cannot claim them. This originally tickled an invalid unwrap().
        let nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        route_payment(&nodes[0], &[&nodes[1]], 10000000);
        nodes[0].node.force_close_channel(&nodes[0].node.list_channels()[0].channel_id);
@@ -2756,8 +2757,8 @@ fn test_htlc_ignore_latest_remote_commitment() {
 fn test_force_close_fail_back() {
        // Check which HTLCs are failed-backwards on channel force-closure
        let mut nodes = create_network(3, &[None, None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, 42).unwrap();
 
@@ -2830,7 +2831,7 @@ fn test_force_close_fail_back() {
 fn test_unconf_chan() {
        // After creating a chan between nodes, we disconnect all blocks previously seen to force a channel close on nodes[0] side
        let nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let channel_state = nodes[0].node.channel_state.lock().unwrap();
        assert_eq!(channel_state.by_id.len(), 1);
@@ -2859,8 +2860,8 @@ fn test_unconf_chan() {
 fn test_simple_peer_disconnect() {
        // Test that we can reconnect when there are no lost messages
        let nodes = create_network(3, &[None, None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
@@ -2913,10 +2914,10 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
        // Test that we can reconnect when in-flight HTLC updates get dropped
        let mut nodes = create_network(2, &[None, None]);
        if messages_delivered == 0 {
-               create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+               create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::supported(), InitFeatures::supported());
                // nodes[1] doesn't receive the funding_locked message (it'll be re-sent on reconnect)
        } else {
-               create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+               create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        }
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
@@ -3118,7 +3119,7 @@ fn test_drop_messages_peer_disconnect_b() {
 fn test_funding_peer_disconnect() {
        // Test that we can lock in our funding tx while disconnected
        let nodes = create_network(2, &[None, None]);
-       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::supported(), InitFeatures::supported());
 
        nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
@@ -3200,7 +3201,7 @@ fn test_drop_messages_peer_disconnect_dual_htlc() {
        // Test that we can handle reconnecting when both sides of a channel have pending
        // commitment_updates when we disconnect.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
@@ -3340,7 +3341,7 @@ fn test_invalid_channel_announcement() {
        let secp_ctx = Secp256k1::new();
        let nodes = create_network(2, &[None, None]);
 
-       let chan_announcement = create_chan_between_nodes(&nodes[0], &nodes[1], Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_announcement = create_chan_between_nodes(&nodes[0], &nodes[1], InitFeatures::supported(), InitFeatures::supported());
 
        let a_channel_lock = nodes[0].node.channel_state.lock().unwrap();
        let b_channel_lock = nodes[1].node.channel_state.lock().unwrap();
@@ -3362,7 +3363,7 @@ fn test_invalid_channel_announcement() {
        macro_rules! dummy_unsigned_msg {
                () => {
                        msgs::UnsignedChannelAnnouncement {
-                               features: msgs::Features::<FeatureContextChannel>::supported(),
+                               features: ChannelFeatures::supported(),
                                chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
                                short_channel_id: as_chan.get_short_channel_id().unwrap(),
                                node_id_1: if were_node_one { as_network_key } else { bs_network_key },
@@ -3412,7 +3413,7 @@ fn test_invalid_channel_announcement() {
 fn test_no_txn_manager_serialize_deserialize() {
        let mut nodes = create_network(2, &[None, None]);
 
-       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::supported(), InitFeatures::supported());
 
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
 
@@ -3474,7 +3475,7 @@ fn test_no_txn_manager_serialize_deserialize() {
 #[test]
 fn test_simple_manager_serialize_deserialize() {
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
        let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
@@ -3521,9 +3522,9 @@ fn test_simple_manager_serialize_deserialize() {
 fn test_manager_serialize_deserialize_inconsistent_monitor() {
        // Test deserializing a ChannelManager with an out-of-date ChannelMonitor
        let mut nodes = create_network(4, &[None, None, None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 2, 0, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 3, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 2, 0, InitFeatures::supported(), InitFeatures::supported());
+       let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::supported(), InitFeatures::supported());
 
        let (our_payment_preimage, _) = route_payment(&nodes[2], &[&nodes[0], &nodes[1]], 1000000);
 
@@ -3718,7 +3719,7 @@ fn test_claim_sizeable_push_msat() {
        // Incidentally test SpendableOutput event generation due to detection of to_local output on commitment tx
        let nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::supported(), InitFeatures::supported());
        nodes[1].node.force_close_channel(&chan.2);
        check_closed_broadcast!(nodes[1], false);
        let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
@@ -3739,7 +3740,7 @@ fn test_claim_on_remote_sizeable_push_msat() {
        // to_remote output is encumbered by a P2WPKH
        let nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::supported(), InitFeatures::supported());
        nodes[0].node.force_close_channel(&chan.2);
        check_closed_broadcast!(nodes[0], false);
 
@@ -3764,7 +3765,7 @@ fn test_claim_on_remote_revoked_sizeable_push_msat() {
 
        let nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 59000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 59000000, InitFeatures::supported(), InitFeatures::supported());
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&chan.2).unwrap().channel_monitor().get_latest_local_commitment_txn();
        assert_eq!(revoked_local_txn[0].input.len(), 1);
@@ -3789,7 +3790,7 @@ fn test_static_spendable_outputs_preimage_tx() {
        let nodes = create_network(2, &[None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
 
@@ -3833,7 +3834,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() {
        let nodes = create_network(2, &[None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.iter_mut().next().unwrap().1.channel_monitor().get_latest_local_commitment_txn();
@@ -3863,7 +3864,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
        let nodes = create_network(2, &[None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2).unwrap().channel_monitor().get_latest_local_commitment_txn();
@@ -3907,7 +3908,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
        let nodes = create_network(2, &[None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let revoked_local_txn = nodes[1].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2).unwrap().channel_monitor().get_latest_local_commitment_txn();
@@ -3960,8 +3961,8 @@ fn test_onchain_to_onchain_claim() {
        let nodes = create_network(3, &[None, None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance the network a bit by relaying one payment through all the channels ...
        send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
@@ -4049,8 +4050,8 @@ fn test_duplicate_payment_hash_one_failure_one_success() {
        // We route 2 payments with same hash between B and C, one will be timeout, the other successfully claim
        let mut nodes = create_network(3, &[None, None, None]);
 
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
 
        let (our_payment_preimage, duplicate_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000);
        *nodes[0].network_payment_count.borrow_mut() -= 1;
@@ -4166,7 +4167,7 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
        let nodes = create_network(2, &[None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000).0;
        let local_txn = nodes[1].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2).unwrap().channel_monitor().get_latest_local_commitment_txn();
@@ -4214,11 +4215,11 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno
        // And test where C fails back to A/B when D announces its latest commitment transaction
        let nodes = create_network(6, &[None, None, None, None, None, None]);
 
-       create_announced_chan_between_nodes(&nodes, 0, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       let chan = create_announced_chan_between_nodes(&nodes, 2, 3, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 3, 4, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes(&nodes, 3, 5, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance and check output sanity...
        send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000, 500_000);
@@ -4454,7 +4455,7 @@ fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() {
        let nodes = create_network(2, &[None, None]);
 
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000).0;
        let local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2).unwrap().channel_monitor().get_latest_local_commitment_txn();
@@ -4488,7 +4489,7 @@ fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() {
 fn test_static_output_closing_tx() {
        let nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
        let closing_tx = close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true).2;
@@ -4507,7 +4508,7 @@ fn test_static_output_closing_tx() {
 
 fn do_htlc_claim_local_commitment_only(use_dust: bool) {
        let nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], if use_dust { 50000 } else { 3000000 });
 
@@ -4544,7 +4545,7 @@ fn do_htlc_claim_local_commitment_only(use_dust: bool) {
 
 fn do_htlc_claim_current_remote_commitment_only(use_dust: bool) {
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), if use_dust { 50000 } else { 3000000 }, TEST_FINAL_CLTV).unwrap();
        let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
@@ -4569,7 +4570,7 @@ fn do_htlc_claim_current_remote_commitment_only(use_dust: bool) {
 
 fn do_htlc_claim_previous_remote_commitment_only(use_dust: bool, check_revoke_no_close: bool) {
        let nodes = create_network(3, &[None, None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // Fail the payment, but don't deliver A's final RAA, resulting in the HTLC only being present
        // in B's previous (unrevoked) commitment transaction, but none of A's commitment transactions.
@@ -4855,7 +4856,7 @@ fn test_onion_failure() {
        for node in nodes.iter() {
                *node.keys_manager.override_session_priv.lock().unwrap() = Some(SecretKey::from_slice(&[3; 32]).unwrap());
        }
-       let channels = [create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported()), create_announced_chan_between_nodes(&nodes, 1, 2, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported())];
+       let channels = [create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()), create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported())];
        let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
        let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV).unwrap();
        // positve case
@@ -5076,7 +5077,7 @@ fn bolt2_open_channel_sending_node_checks_part1() { //This test needs to be on i
        let push_msat=10001;
        nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42).unwrap();
        let node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
-       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), Features::<FeatureContextInit>::supported(), &node0_to_1_send_open_channel);
+       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::supported(), &node0_to_1_send_open_channel);
 
        //Create a second channel with a channel_id collision
        assert!(nodes[0].node.create_channel(nodes[0].node.get_our_node_id(), channel_value_satoshis, push_msat, 42).is_err());
@@ -5133,7 +5134,7 @@ fn test_update_add_htlc_bolt2_sender_value_below_minimum_msat() {
        //BOLT2 Requirement: MUST offer amount_msat greater than 0.
        //BOLT2 Requirement: MUST NOT offer amount_msat below the receiving node's htlc_minimum_msat (same validation check catches both of these)
        let mut nodes = create_network(2, &[None, None]);
-       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
        let mut route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 
@@ -5155,7 +5156,7 @@ fn test_update_add_htlc_bolt2_sender_cltv_expiry_too_high() {
        //BOLT 2 Requirement: MUST set cltv_expiry less than 500000000.
        //It is enforced when constructing a route.
        let mut nodes = create_network(2, &[None, None]);
-       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 0, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 0, InitFeatures::supported(), InitFeatures::supported());
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 100000000, 500000001).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 
@@ -5174,7 +5175,7 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_num_and_htlc_id_increment()
        //BOLT 2 Requirement: for the first HTLC it offers MUST set id to 0.
        //BOLT 2 Requirement: MUST increase the value of id by 1 for each successive offer.
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 0, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 0, InitFeatures::supported(), InitFeatures::supported());
        let max_accepted_htlcs = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().their_max_accepted_htlcs as u64;
 
        for i in 0..max_accepted_htlcs {
@@ -5218,7 +5219,7 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
        //BOLT 2 Requirement: if the sum of total offered HTLCs would exceed the remote's max_htlc_value_in_flight_msat: MUST NOT add an HTLC.
        let mut nodes = create_network(2, &[None, None]);
        let channel_value = 100000;
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, InitFeatures::supported(), InitFeatures::supported());
        let max_in_flight = get_channel_value_stat!(nodes[0], chan.2).their_max_htlc_value_in_flight_msat;
 
        send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight, max_in_flight);
@@ -5243,7 +5244,7 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
 fn test_update_add_htlc_bolt2_receiver_check_amount_received_more_than_min() {
        //BOLT2 Requirement: receiving an amount_msat equal to 0, OR less than its own htlc_minimum_msat -> SHOULD fail the channel.
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
        let htlc_minimum_msat: u64;
        {
                let chan_lock = nodes[0].node.channel_state.lock().unwrap();
@@ -5266,7 +5267,7 @@ fn test_update_add_htlc_bolt2_receiver_check_amount_received_more_than_min() {
 fn test_update_add_htlc_bolt2_receiver_sender_can_afford_amount_sent() {
        //BOLT2 Requirement: receiving an amount_msat that the sending node cannot afford at the current feerate_per_kw (while maintaining its channel reserve): SHOULD fail the channel
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
 
        let their_channel_reserve = get_channel_value_stat!(nodes[0], chan.2).channel_reserve_msat;
 
@@ -5289,7 +5290,7 @@ fn test_update_add_htlc_bolt2_receiver_check_max_htlc_limit() {
        //BOLT 2 Requirement: if a sending node adds more than its max_accepted_htlcs HTLCs to its local commitment transaction: SHOULD fail the channel
        //BOLT 2 Requirement: MUST allow multiple HTLCs with the same payment_hash.
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 3999999, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 
@@ -5330,7 +5331,7 @@ fn test_update_add_htlc_bolt2_receiver_check_max_htlc_limit() {
 fn test_update_add_htlc_bolt2_receiver_check_max_in_flight_msat() {
        //OR adds more than its max_htlc_value_in_flight_msat worth of offered HTLCs to its local commitment transaction: SHOULD fail the channel
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::supported(), InitFeatures::supported());
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
        nodes[0].node.send_payment(route, our_payment_hash).unwrap();
@@ -5348,7 +5349,7 @@ fn test_update_add_htlc_bolt2_receiver_check_max_in_flight_msat() {
 fn test_update_add_htlc_bolt2_receiver_check_cltv_expiry() {
        //BOLT2 Requirement: if sending node sets cltv_expiry to greater or equal to 500000000: SHOULD fail the channel.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 3999999, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
        nodes[0].node.send_payment(route, our_payment_hash).unwrap();
@@ -5368,7 +5369,7 @@ fn test_update_add_htlc_bolt2_receiver_check_repeated_id_ignore() {
        // We test this by first testing that that repeated HTLCs pass commitment signature checks
        // after disconnect and that non-sequential htlc_ids result in a channel failure.
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
        nodes[0].node.send_payment(route, our_payment_hash).unwrap();
@@ -5409,7 +5410,7 @@ fn test_update_fulfill_htlc_bolt2_update_fulfill_htlc_before_commitment() {
        //BOLT 2 Requirement: until the corresponding HTLC is irrevocably committed in both sides' commitment transactions:     MUST NOT send an update_fulfill_htlc, update_fail_htlc, or update_fail_malformed_htlc.
 
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV).unwrap();
        let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
@@ -5436,7 +5437,7 @@ fn test_update_fulfill_htlc_bolt2_update_fail_htlc_before_commitment() {
        //BOLT 2 Requirement: until the corresponding HTLC is irrevocably committed in both sides' commitment transactions:     MUST NOT send an update_fulfill_htlc, update_fail_htlc, or update_fail_malformed_htlc.
 
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
@@ -5463,7 +5464,7 @@ fn test_update_fulfill_htlc_bolt2_update_fail_malformed_htlc_before_commitment()
        //BOLT 2 Requirement: until the corresponding HTLC is irrevocably committed in both sides' commitment transactions:     MUST NOT send an update_fulfill_htlc, update_fail_htlc, or update_fail_malformed_htlc.
 
        let mut nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
@@ -5491,7 +5492,7 @@ fn test_update_fulfill_htlc_bolt2_incorrect_htlc_id() {
        //BOLT 2 Requirement: A receiving node: if the id does not correspond to an HTLC in its current commitment transaction MUST fail the channel.
 
        let nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
 
@@ -5528,7 +5529,7 @@ fn test_update_fulfill_htlc_bolt2_wrong_preimage() {
        //BOLT 2 Requirement: A receiving node: if the payment_preimage value in update_fulfill_htlc doesn't SHA256 hash to the corresponding HTLC payment_hash MUST fail the channel.
 
        let nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
 
@@ -5566,7 +5567,7 @@ fn test_update_fulfill_htlc_bolt2_missing_badonion_bit_for_malformed_htlc_messag
        //BOLT 2 Requirement: A receiving node: if the BADONION bit in failure_code is not set for update_fail_malformed_htlc MUST fail the channel.
 
        let mut nodes = create_network(2, &[None, None]);
-       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::supported(), InitFeatures::supported());
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
        nodes[0].node.send_payment(route, our_payment_hash).unwrap();
@@ -5608,8 +5609,8 @@ fn test_update_fulfill_htlc_bolt2_after_malformed_htlc_message_must_forward_upda
        //    * MUST return an error in the update_fail_htlc sent to the link which originally sent the HTLC, using the failure_code given and setting the data to sha256_of_onion.
 
        let mut nodes = create_network(3, &[None, None, None]);
-       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
-       create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1000000, 1000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1000000, 1000000, InitFeatures::supported(), InitFeatures::supported());
 
        let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
@@ -5683,7 +5684,7 @@ fn do_test_failure_delay_dust_htlc_local_commitment(announce_latest: bool) {
        // HTLC could have been removed from lastest local commitment tx but still valid until we get remote RAA
 
        let nodes = create_network(2, &[None, None]);
-       let chan =create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan =create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
 
@@ -5773,7 +5774,7 @@ fn test_no_failure_dust_htlc_local_commitment() {
        // prone to error, we test here that a dummy transaction don't fail them.
 
        let nodes = create_network(2, &[None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        // Rebalance a bit
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
@@ -5827,7 +5828,7 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
        // Broadcast of HTLC-timeout tx on local commitment tx, trigger failure-update of non-dust HTLCs
 
        let nodes = create_network(3, &[None, None, None]);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
 
@@ -5960,7 +5961,7 @@ fn test_upfront_shutdown_script() {
        let nodes = create_network(3, &cfgs);
 
        // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign
-       let flags = Features::<FeatureContextInit>::supported();
+       let flags = InitFeatures::supported();
        let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000, flags.clone(), flags.clone());
        nodes[0].node.close_channel(&OutPoint::new(chan.3.txid(), 0).to_channel_id()).unwrap();
        let mut node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
@@ -5996,7 +5997,7 @@ fn test_upfront_shutdown_script() {
        }
 
        // We test that if case of peer non-signaling we don't enforce committed script at channel opening
-       let mut flags_no = Features::<FeatureContextInit>::supported();
+       let mut flags_no = InitFeatures::supported();
        flags_no.unset_upfront_shutdown_script();
        let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, flags_no, flags.clone());
        nodes[0].node.close_channel(&OutPoint::new(chan.3.txid(), 0).to_channel_id()).unwrap();
@@ -6067,7 +6068,7 @@ fn test_user_configurable_csv_delay() {
        nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42).unwrap();
        let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
        open_channel.to_self_delay = 200;
-       if let Err(error) = Channel::new_from_req(&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), Features::<FeatureContextInit>::supported(), &open_channel, 0, Arc::new(test_utils::TestLogger::new()), &low_our_to_self_config) {
+       if let Err(error) = Channel::new_from_req(&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), InitFeatures::supported(), &open_channel, 0, Arc::new(test_utils::TestLogger::new()), &low_our_to_self_config) {
                match error {
                        ChannelError::Close(err) => { assert_eq!(err, "Configured with an unreasonable our_to_self_delay putting user funds at risks"); },
                        _ => panic!("Unexpected event"),
@@ -6076,10 +6077,10 @@ fn test_user_configurable_csv_delay() {
 
        // We test msg.to_self_delay <= config.their_to_self_delay is enforced in Chanel::accept_channel()
        nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1000000, 1000000, 42).unwrap();
-       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), Features::<FeatureContextInit>::supported(), &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()));
+       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::supported(), &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()));
        let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
        accept_channel.to_self_delay = 200;
-       nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), Features::<FeatureContextInit>::supported(), &accept_channel);
+       nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::supported(), &accept_channel);
        if let MessageSendEvent::HandleError { ref action, .. } = nodes[0].node.get_and_clear_pending_msg_events()[0] {
                match action {
                        &ErrorAction::SendErrorMessage { ref msg } => {
@@ -6093,7 +6094,7 @@ fn test_user_configurable_csv_delay() {
        nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42).unwrap();
        let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
        open_channel.to_self_delay = 200;
-       if let Err(error) = Channel::new_from_req(&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), Features::<FeatureContextInit>::supported(), &open_channel, 0, Arc::new(test_utils::TestLogger::new()), &high_their_to_self_config) {
+       if let Err(error) = Channel::new_from_req(&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), InitFeatures::supported(), &open_channel, 0, Arc::new(test_utils::TestLogger::new()), &high_their_to_self_config) {
                match error {
                        ChannelError::Close(err) => { assert_eq!(err, "They wanted our payments to be delayed by a needlessly long period"); },
                        _ => panic!("Unexpected event"),
@@ -6109,7 +6110,7 @@ fn test_data_loss_protect() {
        // * we are able to claim our own outputs thanks to remote my_current_per_commitment_point
        let mut nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::supported(), InitFeatures::supported());
 
        // Cache node A state before any channel update
        let previous_node_state = nodes[0].node.encode();
@@ -6226,7 +6227,7 @@ fn test_check_htlc_underpaying() {
        let nodes = create_network(2, &[None, None, None]);
 
        // Create some initial channels
-       create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
 
        let (payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], 10_000);
 
@@ -6271,9 +6272,9 @@ fn test_announce_disable_channels() {
 
        let nodes = create_network(2, &[None, None]);
 
-       let short_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported()).0.contents.short_channel_id;
-       let short_id_2 = create_announced_chan_between_nodes(&nodes, 1, 0, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported()).0.contents.short_channel_id;
-       let short_id_3 = create_announced_chan_between_nodes(&nodes, 0, 1, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported()).0.contents.short_channel_id;
+       let short_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
+       let short_id_2 = create_announced_chan_between_nodes(&nodes, 1, 0, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
+       let short_id_3 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
 
        // Disconnect peers
        nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
@@ -6330,7 +6331,7 @@ fn test_bump_penalty_txn_on_revoked_commitment() {
 
        let nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let route = nodes[1].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 3000000, 30).unwrap();
        send_along_route(&nodes[1], route, &vec!(&nodes[0])[..], 3000000);
@@ -6430,7 +6431,7 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
 
        let nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
        // Lock HTLC in both directions
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3_000_000).0;
        route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
@@ -6574,7 +6575,7 @@ fn test_bump_penalty_txn_on_remote_commitment() {
 
        let nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000).0;
 
@@ -6681,7 +6682,7 @@ fn test_set_outpoints_partial_claiming() {
        // - disconnect tx, see no tx anymore
        let nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
        let payment_preimage_1 = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
        let payment_preimage_2 = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
 
@@ -6773,7 +6774,7 @@ fn test_bump_txn_sanitize_tracking_maps() {
 
        let nodes = create_network(2, &[None, None]);
 
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, Features::<FeatureContextInit>::supported(), Features::<FeatureContextInit>::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
        // Lock HTLC in both directions
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
        route_payment(&nodes[1], &vec!(&nodes[0])[..], 9_000_000).0;

diff --git a/lightning/src/ln/mod.rs b/lightning/src/ln/mod.rs
index 2b20e9908c7337c4455d750605450ed6d71fe0fd..369d2789302d2624f2a4f3bd84a6684a1705050a 100644 (file)
--- a/lightning/src/ln/mod.rs
+++ b/lightning/src/ln/mod.rs
@@ -21,6 +21,11 @@ pub mod peer_channel_encryptor;
 #[cfg(not(feature = "fuzztarget"))]
 pub(crate) mod peer_channel_encryptor;
 
+#[cfg(feature = "fuzztarget")]
+pub mod features;
+#[cfg(not(feature = "fuzztarget"))]
+pub(crate) mod features;
+
 mod channel;
 mod onion_utils;
 

diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs
index f051b555a9aaf1a279f5b56f1137159daf886cd8..70bf19f41e0b337dda57b9ca94c02b3b2f8005b8 100644 (file)
--- a/lightning/src/ln/msgs.rs
+++ b/lightning/src/ln/msgs.rs
@@ -21,11 +21,12 @@ use secp256k1;
 use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 use bitcoin::blockdata::script::Script;
 
+use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
+
 use std::error::Error;
 use std::{cmp, fmt};
 use std::io::Read;
 use std::result::Result;
-use std::marker::PhantomData;
 
 use util::events;
 use util::ser::{Readable, Writeable, Writer};
@@ -53,246 +54,6 @@ pub enum DecodeError {
        Io(::std::io::Error),
 }
 
-/// The context in which a Feature object appears determines which bits of features the node
-/// supports will be set. We use this when creating our own Feature objects to select which bits to
-/// set and when passing around Feature objects to ensure the bits we're checking for are
-/// available.
-///
-/// This Context represents when the Feature appears in the init message, sent between peers and not
-/// rumored around the P2P network.
-pub struct FeatureContextInit {}
-/// The context in which a Feature object appears determines which bits of features the node
-/// supports will be set. We use this when creating our own Feature objects to select which bits to
-/// set and when passing around Feature objects to ensure the bits we're checking for are
-/// available.
-///
-/// This Context represents when the Feature appears in the node_announcement message, as it is
-/// rumored around the P2P network.
-pub struct FeatureContextNode {}
-/// The context in which a Feature object appears determines which bits of features the node
-/// supports will be set. We use this when creating our own Feature objects to select which bits to
-/// set and when passing around Feature objects to ensure the bits we're checking for are
-/// available.
-///
-/// This Context represents when the Feature appears in the ChannelAnnouncement message, as it is
-/// rumored around the P2P network.
-pub struct FeatureContextChannel {}
-/// The context in which a Feature object appears determines which bits of features the node
-/// supports will be set. We use this when creating our own Feature objects to select which bits to
-/// set and when passing around Feature objects to ensure the bits we're checking for are
-/// available.
-///
-/// This Context represents when the Feature appears in an invoice, used to determine the different
-/// options available for routing a payment.
-///
-/// Note that this is currently unused as invoices come to us via a different crate and are not
-/// native to rust-lightning directly.
-pub struct FeatureContextInvoice {}
-
-/// An internal trait capturing the various future context types
-pub trait FeatureContext {}
-impl FeatureContext for FeatureContextInit {}
-impl FeatureContext for FeatureContextNode {}
-impl FeatureContext for FeatureContextChannel {}
-impl FeatureContext for FeatureContextInvoice {}
-
-/// An internal trait capturing FeatureContextInit and FeatureContextNode
-pub trait FeatureContextInitNode : FeatureContext {}
-impl FeatureContextInitNode for FeatureContextInit {}
-impl FeatureContextInitNode for FeatureContextNode {}
-
-/// Tracks the set of features which a node implements, templated by the context in which it
-/// appears.
-pub struct Features<T: FeatureContext> {
-       #[cfg(not(test))]
-       /// Note that, for convinience, flags is LITTLE endian (despite being big-endian on the wire)
-       flags: Vec<u8>,
-       // Used to test encoding of diverse msgs
-       #[cfg(test)]
-       pub flags: Vec<u8>,
-       mark: PhantomData<T>,
-}
-
-impl<T: FeatureContext> Clone for Features<T> {
-       fn clone(&self) -> Self {
-               Self {
-                       flags: self.flags.clone(),
-                       mark: PhantomData,
-               }
-       }
-}
-impl<T: FeatureContext> PartialEq for Features<T> {
-       fn eq(&self, o: &Self) -> bool {
-               self.flags.eq(&o.flags)
-       }
-}
-impl<T: FeatureContext> fmt::Debug for Features<T> {
-       fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-               self.flags.fmt(fmt)
-       }
-}
-
-/// A feature message as it appears in an init message
-pub type InitFeatures = Features<FeatureContextInit>;
-/// A feature message as it appears in a node_announcement message
-pub type NodeFeatures = Features<FeatureContextNode>;
-/// A feature message as it appears in a channel_announcement message
-pub type ChannelFeatures = Features<FeatureContextChannel>;
-
-impl<T: FeatureContextInitNode> Features<T> {
-       /// Create a Features with the features we support
-       #[cfg(not(feature = "fuzztarget"))]
-       pub(crate) fn supported() -> Features<T> {
-               Features {
-                       flags: vec![2 | 1 << 5],
-                       mark: PhantomData,
-               }
-       }
-       #[cfg(feature = "fuzztarget")]
-       pub fn supported() -> Features<T> {
-               Features {
-                       flags: vec![2 | 1 << 5],
-                       mark: PhantomData,
-               }
-       }
-}
-
-impl Features<FeatureContextChannel> {
-       /// Create a Features with the features we support
-       #[cfg(not(feature = "fuzztarget"))]
-       pub(crate) fn supported() -> Features<FeatureContextChannel> {
-               Features {
-                       flags: Vec::new(),
-                       mark: PhantomData,
-               }
-       }
-       #[cfg(feature = "fuzztarget")]
-       pub fn supported() -> Features<FeatureContextChannel> {
-               Features {
-                       flags: Vec::new(),
-                       mark: PhantomData,
-               }
-       }
-}
-
-impl<T: FeatureContext> Features<T> {
-       /// Create a blank Features with no fetures set
-       pub fn empty() -> Features<T> {
-               Features {
-                       flags: Vec::new(),
-                       mark: PhantomData,
-               }
-       }
-
-       pub(crate) fn requires_unknown_bits(&self) -> bool {
-               self.flags.iter().enumerate().any(|(idx, &byte)| {
-                       ( idx != 0 && (byte & 0x55) != 0 ) || ( idx == 0 && (byte & 0x14) != 0 )
-               })
-       }
-
-       pub(crate) fn supports_unknown_bits(&self) -> bool {
-               self.flags.iter().enumerate().any(|(idx, &byte)| {
-                       ( idx != 0 && byte != 0 ) || ( idx == 0 && (byte & 0xc4) != 0 )
-               })
-       }
-
-       /// The number of bytes required to represent the feaature flags present. This does not include
-       /// the length bytes which are included in the serialized form.
-       pub(crate) fn byte_count(&self) -> usize {
-               self.flags.len()
-       }
-
-       #[cfg(test)]
-       pub(crate) fn set_require_unknown_bits(&mut self) {
-               let newlen = cmp::max(2, self.flags.len());
-               self.flags.resize(newlen, 0u8);
-               self.flags[1] |= 0x40;
-       }
-
-       #[cfg(test)]
-       pub(crate) fn clear_require_unknown_bits(&mut self) {
-               let newlen = cmp::max(2, self.flags.len());
-               self.flags.resize(newlen, 0u8);
-               self.flags[1] &= !0x40;
-               if self.flags.len() == 2 && self.flags[1] == 0 {
-                       self.flags.resize(1, 0u8);
-               }
-       }
-}
-
-impl<T: FeatureContextInitNode> Features<T> {
-       pub(crate) fn supports_data_loss_protect(&self) -> bool {
-               self.flags.len() > 0 && (self.flags[0] & 3) != 0
-       }
-
-       pub(crate) fn supports_upfront_shutdown_script(&self) -> bool {
-               self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0
-       }
-       #[cfg(test)]
-       pub(crate) fn unset_upfront_shutdown_script(&mut self) {
-               self.flags[0] ^= 1 << 5;
-       }
-}
-
-impl Features<FeatureContextInit> {
-       pub(crate) fn initial_routing_sync(&self) -> bool {
-               self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0
-       }
-       pub(crate) fn set_initial_routing_sync(&mut self) {
-               if self.flags.len() == 0 {
-                       self.flags.resize(1, 1 << 3);
-               } else {
-                       self.flags[0] |= 1 << 3;
-               }
-       }
-
-       /// Writes all features present up to, and including, 13.
-       pub(crate) fn write_up_to_13<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
-               let len = cmp::min(2, self.flags.len());
-               w.size_hint(len + 2);
-               (len as u16).write(w)?;
-               for i in (0..len).rev() {
-                       if i == 0 {
-                               self.flags[i].write(w)?;
-                       } else {
-                               (self.flags[i] & ((1 << (14 - 8)) - 1)).write(w)?;
-                       }
-               }
-               Ok(())
-       }
-
-       /// or's another InitFeatures into this one.
-       pub(crate) fn or(&mut self, o: &InitFeatures) {
-               let total_feature_len = cmp::max(self.flags.len(), o.flags.len());
-               self.flags.resize(total_feature_len, 0u8);
-               for (feature, o_feature) in self.flags.iter_mut().zip(o.flags.iter()) {
-                       *feature |= *o_feature;
-               }
-       }
-}
-
-impl<T: FeatureContext> Writeable for Features<T> {
-       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
-               w.size_hint(self.flags.len() + 2);
-               (self.flags.len() as u16).write(w)?;
-               for f in self.flags.iter().rev() { // We have to swap the endianness back to BE for writing
-                       f.write(w)?;
-               }
-               Ok(())
-       }
-}
-
-impl<R: ::std::io::Read, T: FeatureContext> Readable<R> for Features<T> {
-       fn read(r: &mut R) -> Result<Self, DecodeError> {
-               let mut flags: Vec<u8> = Readable::read(r)?;
-               flags.reverse(); // Swap to big-endian
-               Ok(Self {
-                       flags,
-                       mark: PhantomData,
-               })
-       }
-}
-
 /// An init message to be sent or received from a peer
 pub struct Init {
        pub(crate) features: InitFeatures,
@@ -1078,10 +839,9 @@ impl Writeable for Init {
 impl<R: Read> Readable<R> for Init {
        fn read(r: &mut R) -> Result<Self, DecodeError> {
                let global_features: InitFeatures = Readable::read(r)?;
-               let mut features: InitFeatures = Readable::read(r)?;
-               features.or(&global_features);
+               let features: InitFeatures = Readable::read(r)?;
                Ok(Init {
-                       features
+                       features: features.or(global_features),
                })
        }
 }
@@ -1540,8 +1300,6 @@ mod tests {
        use secp256k1::key::{PublicKey,SecretKey};
        use secp256k1::{Secp256k1, Message};
 
-       use std::marker::PhantomData;
-
        #[test]
        fn encoding_channel_reestablish_no_secret() {
                let cr = msgs::ChannelReestablish {
@@ -1627,7 +1385,7 @@ mod tests {
                let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
                let mut features = ChannelFeatures::supported();
                if unknown_features_bits {
-                       features.flags = vec![0xFF, 0xFF];
+                       features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
                }
                let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
                        features,
@@ -1681,13 +1439,12 @@ mod tests {
                let secp_ctx = Secp256k1::new();
                let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
                let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
-               let mut features = NodeFeatures::empty();
-               if unknown_features_bits {
-                       features.flags = vec![0xFF, 0xFF];
+               let features = if unknown_features_bits {
+                       NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
                } else {
                        // Set to some features we may support
-                       features.flags = vec![2 | 1 << 5];
-               }
+                       NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
+               };
                let mut addresses = Vec::new();
                if ipv4 {
                        addresses.push(msgs::NetAddress::IPv4 {
@@ -2141,22 +1898,13 @@ mod tests {
        #[test]
        fn encoding_init() {
                assert_eq!(msgs::Init {
-                       features: InitFeatures {
-                               flags: vec![0xFF, 0xFF, 0xFF],
-                               mark: PhantomData,
-                       },
+                       features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
                }.encode(), hex::decode("00023fff0003ffffff").unwrap());
                assert_eq!(msgs::Init {
-                       features: InitFeatures {
-                               flags: vec![0xFF],
-                               mark: PhantomData,
-                       },
+                       features: InitFeatures::from_le_bytes(vec![0xFF]),
                }.encode(), hex::decode("0001ff0001ff").unwrap());
                assert_eq!(msgs::Init {
-                       features: InitFeatures {
-                               flags: vec![],
-                               mark: PhantomData,
-                       },
+                       features: InitFeatures::from_le_bytes(vec![]),
                }.encode(), hex::decode("00000000").unwrap());
        }
 

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index 902598a79abceed04b68d28f009c29a4d32a3a58..67c53de7435a536712e5068ac62493d41fb7efe0 100644 (file)
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -8,6 +8,7 @@
 
 use secp256k1::key::{SecretKey,PublicKey};
 
+use ln::features::InitFeatures;
 use ln::msgs;
 use util::ser::{Writeable, Writer, Readable};
 use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
@@ -103,7 +104,7 @@ struct Peer {
        channel_encryptor: PeerChannelEncryptor,
        outbound: bool,
        their_node_id: Option<PublicKey>,
-       their_features: Option<msgs::InitFeatures>,
+       their_features: Option<InitFeatures>,
 
        pending_outbound_buffer: LinkedList<Vec<u8>>,
        pending_outbound_buffer_first_msg_offset: usize,
@@ -567,7 +568,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 
                                                                        peer.their_node_id = Some(their_node_id);
                                                                        insert_node_id!();
-                                                                       let mut features = msgs::InitFeatures::supported();
+                                                                       let mut features = InitFeatures::supported();
                                                                        if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
                                                                                self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
                                                                                features.set_initial_routing_sync();
@@ -638,7 +639,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                                peer.their_features = Some(msg.features);
 
                                                                                                if !peer.outbound {
-                                                                                                       let mut features = msgs::InitFeatures::supported();
+                                                                                                       let mut features = InitFeatures::supported();
                                                                                                        if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
                                                                                                                self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
                                                                                                                features.set_initial_routing_sync();

diff --git a/lightning/src/ln/router.rs b/lightning/src/ln/router.rs
index 7737d5c5910d47c0e51ad54df6dc50c85aed3bde..536ec55d73ff4d9ff5fd5c9142d42aed2c5f5b0b 100644 (file)
--- a/lightning/src/ln/router.rs
+++ b/lightning/src/ln/router.rs
@@ -14,7 +14,8 @@ use bitcoin::blockdata::opcodes;
 
 use chain::chaininterface::{ChainError, ChainWatchInterface};
 use ln::channelmanager;
-use ln::msgs::{DecodeError,ErrorAction,LightningError,RoutingMessageHandler,NetAddress,ChannelFeatures,NodeFeatures};
+use ln::features::{ChannelFeatures, NodeFeatures};
+use ln::msgs::{DecodeError,ErrorAction,LightningError,RoutingMessageHandler,NetAddress};
 use ln::msgs;
 use util::ser::{Writeable, Readable, Writer, ReadableArgs};
 use util::logger::Logger;
@@ -1011,7 +1012,8 @@ mod tests {
        use chain::chaininterface;
        use ln::channelmanager;
        use ln::router::{Router,NodeInfo,NetworkMap,ChannelInfo,DirectionalChannelInfo,RouteHint};
-       use ln::msgs::{ChannelFeatures, NodeFeatures, LightningError, ErrorAction};
+       use ln::features::{ChannelFeatures, NodeFeatures};
+       use ln::msgs::{LightningError, ErrorAction};
        use util::test_utils;
        use util::test_utils::TestVecWriter;
        use util::logger::Logger;

diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs
index 8821e8f988cf884dc37f3a6a91b316c49fe8eb95..ebdbcc414ecaeae7bf920fcd69c14c5a47958426 100644 (file)
--- a/lightning/src/util/test_utils.rs
+++ b/lightning/src/util/test_utils.rs
@@ -3,8 +3,9 @@ use chain::chaininterface::ConfirmationTarget;
 use chain::transaction::OutPoint;
 use chain::keysinterface;
 use ln::channelmonitor;
+use ln::features::InitFeatures;
 use ln::msgs;
-use ln::msgs::{Features, FeatureContextInit, LightningError};
+use ln::msgs::LightningError;
 use ln::channelmonitor::HTLCUpdate;
 use util::enforcing_trait_impls::EnforcingChannelKeys;
 use util::events;
@@ -99,8 +100,8 @@ impl TestChannelMessageHandler {
 }
 
 impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
-       fn handle_open_channel(&self, _their_node_id: &PublicKey, _their_features: Features<FeatureContextInit>, _msg: &msgs::OpenChannel) {}
-       fn handle_accept_channel(&self, _their_node_id: &PublicKey, _their_features: Features<FeatureContextInit>, _msg: &msgs::AcceptChannel) {}
+       fn handle_open_channel(&self, _their_node_id: &PublicKey, _their_features: InitFeatures, _msg: &msgs::OpenChannel) {}
+       fn handle_accept_channel(&self, _their_node_id: &PublicKey, _their_features: InitFeatures, _msg: &msgs::AcceptChannel) {}
        fn handle_funding_created(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingCreated) {}
        fn handle_funding_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingSigned) {}
        fn handle_funding_locked(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingLocked) {}