Merge pull request #590 from jkczyz/2020-04-feature-flags

Features module improvements

diff --combined fuzz/src/chanmon_consistency.rs
index b28bbaa12bd8872dc9bf510dc88589926aea8ff9,8603458e7ef9172d264d945cb5983cd8d9f12e11..135249f7414479c8405003f4fd57398f536c9035
--- 1/fuzz/src/chanmon_consistency.rs
--- 2/fuzz/src/chanmon_consistency.rs
+++ b/fuzz/src/chanmon_consistency.rs
@@@ -16,9 -16,10 +16,9 @@@ use bitcoin::blockdata::script::{Builde
  use bitcoin::blockdata::opcodes;
  use bitcoin::network::constants::Network;
  
 -use bitcoin_hashes::Hash as TraitImport;
 -use bitcoin_hashes::hash160::Hash as Hash160;
 -use bitcoin_hashes::sha256::Hash as Sha256;
 -use bitcoin_hashes::sha256d::Hash as Sha256d;
 +use bitcoin::hashes::Hash as TraitImport;
 +use bitcoin::hashes::sha256::Hash as Sha256;
 +use bitcoin::hash_types::{BlockHash, WPubkeyHash};
  
  use lightning::chain::chaininterface;
  use lightning::chain::transaction::OutPoint;
@@@ -39,8 -40,8 +39,8 @@@ use lightning::util::ser::{Readable, Re
  
  use utils::test_logger;
  
 -use secp256k1::key::{PublicKey,SecretKey};
 -use secp256k1::Secp256k1;
 +use bitcoin::secp256k1::key::{PublicKey,SecretKey};
 +use bitcoin::secp256k1::Secp256k1;
  
  use std::mem;
  use std::cmp::Ordering;
@@@ -113,7 -114,7 +113,7 @@@ impl channelmonitor::ManyChannelMonitor
                        hash_map::Entry::Occupied(entry) => entry,
                        hash_map::Entry::Vacant(_) => panic!("Didn't have monitor on update call"),
                };
 -              let mut deserialized_monitor = <(Sha256d, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::
 +              let mut deserialized_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::
                        read(&mut Cursor::new(&map_entry.get().1), Arc::clone(&self.logger)).unwrap().1;
                deserialized_monitor.update_monitor(update.clone(), &&TestBroadcaster {}).unwrap();
                let mut ser = VecWriter(Vec::new());
@@@ -143,7 -144,7 +143,7 @@@ impl KeysInterface for KeyProvider 
        fn get_destination_script(&self) -> Script {
                let secp_ctx = Secp256k1::signing_only();
                let channel_monitor_claim_key = SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, self.node_id]).unwrap();
 -              let our_channel_monitor_claim_key_hash = Hash160::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
 +              let our_channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
                Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script()
        }
  
@@@ -214,7 -215,7 +214,7 @@@ pub fn do_test<Out: test_logger::Output
                        let mut monitors = HashMap::new();
                        let mut old_monitors = $old_monitors.latest_monitors.lock().unwrap();
                        for (outpoint, (update_id, monitor_ser)) in old_monitors.drain() {
 -                              monitors.insert(outpoint, <(Sha256d, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut Cursor::new(&monitor_ser), Arc::clone(&logger)).expect("Failed to read monitor").1);
 +                              monitors.insert(outpoint, <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut Cursor::new(&monitor_ser), Arc::clone(&logger)).expect("Failed to read monitor").1);
                                monitor.latest_monitors.lock().unwrap().insert(outpoint, (update_id, monitor_ser));
                        }
                        let mut monitor_refs = HashMap::new();
@@@ -232,7 -233,7 +232,7 @@@
                                channel_monitors: &mut monitor_refs,
                        };
  
 -                      (<(Sha256d, ChannelManager<EnforcingChannelKeys, Arc<TestChannelMonitor>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>>)>::read(&mut Cursor::new(&$ser.0), read_args).expect("Failed to read manager").1, monitor)
 +                      (<(BlockHash, ChannelManager<EnforcingChannelKeys, Arc<TestChannelMonitor>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>>)>::read(&mut Cursor::new(&$ser.0), read_args).expect("Failed to read manager").1, monitor)
                } }
        }
  
@@@ -248,7 -249,7 +248,7 @@@
                                } else { panic!("Wrong event type"); }
                        };
  
-                       $dest.handle_open_channel(&$source.get_our_node_id(), InitFeatures::supported(), &open_channel);
+                       $dest.handle_open_channel(&$source.get_our_node_id(), InitFeatures::known(), &open_channel);
                        let accept_channel = {
                                let events = $dest.get_and_clear_pending_msg_events();
                                assert_eq!(events.len(), 1);
@@@ -257,7 -258,7 +257,7 @@@
                                } else { panic!("Wrong event type"); }
                        };
  
-                       $source.handle_accept_channel(&$dest.get_our_node_id(), InitFeatures::supported(), &accept_channel);
+                       $source.handle_accept_channel(&$dest.get_our_node_id(), InitFeatures::known(), &accept_channel);
                        let funding_output;
                        {
                                let events = $source.get_and_clear_pending_events();

diff --combined lightning/src/ln/chanmon_update_fail_tests.rs
index adf53b0d5f238c99df18a94e03229395437daa3f,739db729a19bd919383c8e441a6c56c0a528dd38..411c12d990d7151d5a29b95a93a85a46cfc72c1c
--- 1/lightning/src/ln/chanmon_update_fail_tests.rs
--- 2/lightning/src/ln/chanmon_update_fail_tests.rs
+++ b/lightning/src/ln/chanmon_update_fail_tests.rs
@@@ -12,8 -12,8 +12,8 @@@ use ln::msgs::{ChannelMessageHandler, E
  use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
  use util::errors::APIError;
  
 -use bitcoin_hashes::sha256::Hash as Sha256;
 -use bitcoin_hashes::Hash;
 +use bitcoin::hashes::sha256::Hash as Sha256;
 +use bitcoin::hashes::Hash;
  
  use ln::functional_test_utils::*;
  
@@@ -24,7 -24,7 +24,7 @@@ fn test_simple_monitor_permanent_update
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        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]);
@@@ -57,7 -57,7 +57,7 @@@ fn do_test_simple_monitor_temporary_upd
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        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]);
@@@ -161,7 -161,7 +161,7 @@@ fn do_test_monitor_temporary_update_fai
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
  
@@@ -493,7 -493,7 +493,7 @@@ fn test_monitor_update_fail_cs() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        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]);
@@@ -578,7 -578,7 +578,7 @@@ fn test_monitor_update_fail_no_rebroadc
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        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]);
@@@ -624,7 -624,7 +624,7 @@@ fn test_monitor_update_raa_while_paused
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        send_payment(&nodes[0], &[&nodes[1]], 5000000, 5_000_000);
  
@@@ -695,8 -695,8 +695,8 @@@ fn do_test_monitor_update_fail_raa(test
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        // 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);
@@@ -953,8 -953,8 +953,8 @@@ fn test_monitor_update_fail_reestablish
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
  
@@@ -1035,7 -1035,7 +1035,7 @@@ fn raa_no_response_awaiting_raa_state(
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        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]);
@@@ -1152,7 -1152,7 +1152,7 @@@ fn claim_while_disconnected_monitor_upd
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        // Forward a payment for B to claim
        let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
@@@ -1272,7 -1272,7 +1272,7 @@@ fn monitor_failed_no_reestablish_respon
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        // Route the payment and deliver the initial commitment_signed (with a monitor update failure
        // on receipt).
@@@ -1342,7 -1342,7 +1342,7 @@@ fn first_message_on_recv_ordering() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        // 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.
@@@ -1432,8 -1432,8 +1432,8 @@@ fn test_monitor_update_fail_claim() 
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        // 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);
@@@ -1509,8 -1509,8 +1509,8 @@@ fn test_monitor_update_on_pending_forwa
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        // 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);
@@@ -1578,7 -1578,7 +1578,7 @@@ fn monitor_update_claim_fail_no_respons
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        // Forward a payment for B to claim
        let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
@@@ -1640,8 -1640,8 +1640,8 @@@ fn do_during_funding_monitor_fail(confi
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 43, None).unwrap();
-       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()));
+       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &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::known(), &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);
  
@@@ -1741,10 -1741,10 +1741,10 @@@ fn test_path_paused_mpp() 
        let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
        let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
  
-       let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
-       let (chan_2_ann, _, chan_2_id, _) = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::supported(), InitFeatures::supported());
-       let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
-       let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
+       let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+       let (chan_2_ann, _, chan_2_id, _) = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known());
+       let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+       let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
  
        let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
        let payment_secret = PaymentSecret([0xdb; 32]);

diff --combined lightning/src/ln/channel.rs
index bef69235b3e139b95d3a129b6eec1cbe7462b19f,98e515f00215fe952609cf5abda69dab322791d7..469698356af3dcdad9c1e9d50cffc4aad98f78d8
--- 1/lightning/src/ln/channel.rs
--- 2/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@@ -6,13 -6,14 +6,13 @@@ use bitcoin::util::hash::BitcoinHash
  use bitcoin::util::bip143;
  use bitcoin::consensus::encode;
  
 -use bitcoin_hashes::{Hash, HashEngine};
 -use bitcoin_hashes::sha256::Hash as Sha256;
 -use bitcoin_hashes::hash160::Hash as Hash160;
 -use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 +use bitcoin::hashes::{Hash, HashEngine};
 +use bitcoin::hashes::sha256::Hash as Sha256;
 +use bitcoin::hash_types::{Txid, BlockHash, WPubkeyHash};
  
 -use secp256k1::key::{PublicKey,SecretKey};
 -use secp256k1::{Secp256k1,Signature};
 -use secp256k1;
 +use bitcoin::secp256k1::key::{PublicKey,SecretKey};
 +use bitcoin::secp256k1::{Secp256k1,Signature};
 +use bitcoin::secp256k1;
  
  use ln::features::{ChannelFeatures, InitFeatures};
  use ln::msgs;
@@@ -312,11 -313,11 +312,11 @@@ pub(super) struct Channel<ChanSigner: C
        /// to detect unconfirmation after a serialize-unserialize roundtrip where we may not see a full
        /// series of block_connected/block_disconnected calls. Obviously this is not a guarantee as we
        /// could miss the funding_tx_confirmed_in block as well, but it serves as a useful fallback.
 -      funding_tx_confirmed_in: Option<Sha256dHash>,
 +      funding_tx_confirmed_in: Option<BlockHash>,
        short_channel_id: Option<u64>,
        /// Used to deduplicate block_connected callbacks, also used to verify consistency during
        /// ChannelManager deserialization (hence pub(super))
 -      pub(super) last_block_connected: Sha256dHash,
 +      pub(super) last_block_connected: BlockHash,
        funding_tx_confirmations: u64,
  
        their_dust_limit_satoshis: u64,
@@@ -982,7 -983,7 +982,7 @@@ impl<ChanSigner: ChannelKeys> Channel<C
                        log_trace!(self, "   ...including {} output with value {}", if local { "to_remote" } else { "to_local" }, value_to_b);
                        txouts.push((TxOut {
                                script_pubkey: Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0)
 -                                                           .push_slice(&Hash160::hash(&keys.b_payment_key.serialize())[..])
 +                                                           .push_slice(&WPubkeyHash::hash(&keys.b_payment_key.serialize())[..])
                                                             .into_script(),
                                value: value_to_b as u64
                        }, None));
@@@ -1024,7 -1025,7 +1024,7 @@@
  
        #[inline]
        fn get_closing_scriptpubkey(&self) -> Script {
 -              let our_channel_close_key_hash = Hash160::hash(&self.shutdown_pubkey.serialize());
 +              let our_channel_close_key_hash = WPubkeyHash::hash(&self.shutdown_pubkey.serialize());
                Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_close_key_hash[..]).into_script()
        }
  
@@@ -1132,7 -1133,7 +1132,7 @@@
        /// Builds the htlc-success or htlc-timeout transaction which spends a given HTLC output
        /// @local is used only to convert relevant internal structures which refer to remote vs local
        /// to decide value of outputs and direction of HTLCs.
 -      fn build_htlc_transaction(&self, prev_hash: &Sha256dHash, htlc: &HTLCOutputInCommitment, local: bool, keys: &TxCreationKeys, feerate_per_kw: u64) -> Transaction {
 +      fn build_htlc_transaction(&self, prev_hash: &Txid, htlc: &HTLCOutputInCommitment, local: bool, keys: &TxCreationKeys, feerate_per_kw: u64) -> Transaction {
                chan_utils::build_htlc_transaction(prev_hash, feerate_per_kw, if local { self.their_to_self_delay } else { self.our_to_self_delay }, htlc, &keys.a_delayed_payment_key, &keys.revocation_key)
        }
  
@@@ -3298,7 -3299,7 +3298,7 @@@
        // Methods to get unprompted messages to send to the remote end (or where we already returned
        // something in the handler for the message that prompted this message):
  
 -      pub fn get_open_channel<F: Deref>(&self, chain_hash: Sha256dHash, fee_estimator: &F) -> msgs::OpenChannel
 +      pub fn get_open_channel<F: Deref>(&self, chain_hash: BlockHash, fee_estimator: &F) -> msgs::OpenChannel
                where F::Target: FeeEstimator
        {
                if !self.channel_outbound {
@@@ -3430,7 -3431,7 +3430,7 @@@
        /// closing).
        /// Note that the "channel must be funded" requirement is stricter than BOLT 7 requires - see
        /// https://github.com/lightningnetwork/lightning-rfc/issues/468
 -      pub fn get_channel_announcement(&self, our_node_id: PublicKey, chain_hash: Sha256dHash) -> Result<(msgs::UnsignedChannelAnnouncement, Signature), ChannelError> {
 +      pub fn get_channel_announcement(&self, our_node_id: PublicKey, chain_hash: BlockHash) -> Result<(msgs::UnsignedChannelAnnouncement, Signature), ChannelError> {
                if !self.config.announced_channel {
                        return Err(ChannelError::Ignore("Channel is not available for public announcements"));
                }
@@@ -3445,7 -3446,7 +3445,7 @@@
                let our_bitcoin_key = PublicKey::from_secret_key(&self.secp_ctx, self.local_keys.funding_key());
  
                let msg = msgs::UnsignedChannelAnnouncement {
-                       features: ChannelFeatures::supported(),
+                       features: ChannelFeatures::known(),
                        chain_hash: chain_hash,
                        short_channel_id: self.get_short_channel_id().unwrap(),
                        node_id_1: if were_node_one { our_node_id } else { self.get_their_node_id() },
@@@ -4290,7 -4291,7 +4290,7 @@@ mod tests 
        use bitcoin::blockdata::constants::genesis_block;
        use bitcoin::blockdata::opcodes;
        use bitcoin::network::constants::Network;
 -      use bitcoin_hashes::hex::FromHex;
 +      use bitcoin::hashes::hex::FromHex;
        use hex;
        use ln::channelmanager::{HTLCSource, PaymentPreimage, PaymentHash};
        use ln::channel::{Channel,ChannelKeys,InboundHTLCOutput,OutboundHTLCOutput,InboundHTLCState,OutboundHTLCState,HTLCOutputInCommitment,TxCreationKeys};
@@@ -4306,11 -4307,12 +4306,11 @@@
        use util::enforcing_trait_impls::EnforcingChannelKeys;
        use util::test_utils;
        use util::logger::Logger;
 -      use secp256k1::{Secp256k1, Message, Signature, All};
 -      use secp256k1::key::{SecretKey,PublicKey};
 -      use bitcoin_hashes::sha256::Hash as Sha256;
 -      use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 -      use bitcoin_hashes::hash160::Hash as Hash160;
 -      use bitcoin_hashes::Hash;
 +      use bitcoin::secp256k1::{Secp256k1, Message, Signature, All};
 +      use bitcoin::secp256k1::key::{SecretKey,PublicKey};
 +      use bitcoin::hashes::sha256::Hash as Sha256;
 +      use bitcoin::hashes::Hash;
 +      use bitcoin::hash_types::{Txid, WPubkeyHash};
        use std::sync::Arc;
        use rand::{thread_rng,Rng};
  
@@@ -4339,7 -4341,7 +4339,7 @@@
                fn get_destination_script(&self) -> Script {
                        let secp_ctx = Secp256k1::signing_only();
                        let channel_monitor_claim_key = SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
 -                      let our_channel_monitor_claim_key_hash = Hash160::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
 +                      let our_channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
                        Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script()
                }
  
@@@ -4381,11 -4383,11 +4381,11 @@@
                // Create Node B's channel by receiving Node A's open_channel message
                let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.bitcoin_hash(), &&feeest);
                let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
-               let mut node_b_chan = Channel::<EnforcingChannelKeys>::new_from_req(&&feeest, &&keys_provider, node_b_node_id, InitFeatures::supported(), &open_channel_msg, 7, logger, &config).unwrap();
+               let mut node_b_chan = Channel::<EnforcingChannelKeys>::new_from_req(&&feeest, &&keys_provider, node_b_node_id, InitFeatures::known(), &open_channel_msg, 7, logger, &config).unwrap();
  
                // Node B --> Node A: accept channel
                let accept_channel_msg = node_b_chan.get_accept_channel();
-               node_a_chan.accept_channel(&accept_channel_msg, &config, InitFeatures::supported()).unwrap();
+               node_a_chan.accept_channel(&accept_channel_msg, &config, InitFeatures::known()).unwrap();
  
                // Node A --> Node B: funding created
                let output_script = node_a_chan.get_funding_redeemscript();
@@@ -4455,7 -4457,7 +4455,7 @@@
                chan.their_to_self_delay = 144;
                chan.our_dust_limit_satoshis = 546;
  
 -              let funding_info = OutPoint::new(Sha256dHash::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), 0);
 +              let funding_info = OutPoint::new(Txid::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), 0);
                chan.funding_txo = Some(funding_info);
  
                let their_pubkeys = ChannelPublicKeys {

diff --combined lightning/src/ln/channelmanager.rs
index 8d22b8893e7bdf57270624c907bc5ede980ac340,f9b0f70468afb7024b9cd4ab832e66832416db52..08b28cc0f55dcdc1e037058cb10b26522e58ca27
--- 1/lightning/src/ln/channelmanager.rs
--- 2/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@@ -14,17 -14,16 +14,17 @@@ use bitcoin::blockdata::constants::gene
  use bitcoin::network::constants::Network;
  use bitcoin::util::hash::BitcoinHash;
  
 -use bitcoin_hashes::{Hash, HashEngine};
 -use bitcoin_hashes::hmac::{Hmac, HmacEngine};
 -use bitcoin_hashes::sha256::Hash as Sha256;
 -use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 -use bitcoin_hashes::cmp::fixed_time_eq;
 -
 -use secp256k1::key::{SecretKey,PublicKey};
 -use secp256k1::Secp256k1;
 -use secp256k1::ecdh::SharedSecret;
 -use secp256k1;
 +use bitcoin::hashes::{Hash, HashEngine};
 +use bitcoin::hashes::hmac::{Hmac, HmacEngine};
 +use bitcoin::hashes::sha256::Hash as Sha256;
 +use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 +use bitcoin::hashes::cmp::fixed_time_eq;
 +use bitcoin::hash_types::BlockHash;
 +
 +use bitcoin::secp256k1::key::{SecretKey,PublicKey};
 +use bitcoin::secp256k1::Secp256k1;
 +use bitcoin::secp256k1::ecdh::SharedSecret;
 +use bitcoin::secp256k1;
  
  use chain::chaininterface::{BroadcasterInterface,ChainListener,FeeEstimator};
  use chain::transaction::OutPoint;
@@@ -376,7 -375,7 +376,7 @@@ pub struct ChannelManager<ChanSigner: C
          F::Target: FeeEstimator,
  {
        default_configuration: UserConfig,
 -      genesis_hash: Sha256dHash,
 +      genesis_hash: BlockHash,
        fee_estimator: F,
        monitor: M,
        tx_broadcaster: T,
@@@ -385,7 -384,7 +385,7 @@@
        pub(super) latest_block_height: AtomicUsize,
        #[cfg(not(test))]
        latest_block_height: AtomicUsize,
 -      last_block_hash: Mutex<Sha256dHash>,
 +      last_block_hash: Mutex<BlockHash>,
        secp_ctx: Secp256k1<secp256k1::All>,
  
        #[cfg(test)]
@@@ -1508,7 -1507,7 +1508,7 @@@ impl<ChanSigner: ChannelKeys, M: Deref
                }
  
                let announcement = msgs::UnsignedNodeAnnouncement {
-                       features: NodeFeatures::supported(),
+                       features: NodeFeatures::known(),
                        timestamp: self.last_node_announcement_serial.fetch_add(1, Ordering::AcqRel) as u32,
                        node_id: self.get_our_node_id(),
                        rgb, alias, addresses,
@@@ -3687,20 -3686,20 +3687,20 @@@ pub struct ChannelManagerReadArgs<'a, C
  // Implement ReadableArgs for an Arc'd ChannelManager to make it a bit easier to work with the
  // SipmleArcChannelManager type:
  impl<'a, ChanSigner: ChannelKeys + Readable, M: Deref, T: Deref, K: Deref, F: Deref>
 -      ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, Arc<ChannelManager<ChanSigner, M, T, K, F>>)
 +      ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (BlockHash, Arc<ChannelManager<ChanSigner, M, T, K, F>>)
        where M::Target: ManyChannelMonitor<ChanSigner>,
          T::Target: BroadcasterInterface,
          K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
          F::Target: FeeEstimator,
  {
        fn read<R: ::std::io::Read>(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
 -              let (blockhash, chan_manager) = <(Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)>::read(reader, args)?;
 +              let (blockhash, chan_manager) = <(BlockHash, ChannelManager<ChanSigner, M, T, K, F>)>::read(reader, args)?;
                Ok((blockhash, Arc::new(chan_manager)))
        }
  }
  
  impl<'a, ChanSigner: ChannelKeys + Readable, M: Deref, T: Deref, K: Deref, F: Deref>
 -      ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)
 +      ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (BlockHash, ChannelManager<ChanSigner, M, T, K, F>)
        where M::Target: ManyChannelMonitor<ChanSigner>,
          T::Target: BroadcasterInterface,
          K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
@@@ -3713,9 -3712,9 +3713,9 @@@
                        return Err(DecodeError::UnknownVersion);
                }
  
 -              let genesis_hash: Sha256dHash = Readable::read(reader)?;
 +              let genesis_hash: BlockHash = Readable::read(reader)?;
                let latest_block_height: u32 = Readable::read(reader)?;
 -              let last_block_hash: Sha256dHash = Readable::read(reader)?;
 +              let last_block_hash: BlockHash = Readable::read(reader)?;
  
                let mut failed_htlcs = Vec::new();
  

diff --combined lightning/src/ln/functional_tests.rs
index 3a440fb323c82e0ba55c1b09b2745ab1d9480a0d,d7bdcc2d2ac50299bd84dbdf93a3d156aaf7e24e..cfc29394f8b5e56acce9454b2b5d096b5af0e109
--- 1/lightning/src/ln/functional_tests.rs
--- 2/lightning/src/ln/functional_tests.rs
+++ b/lightning/src/ln/functional_tests.rs
@@@ -25,8 -25,7 +25,8 @@@ use util::config::UserConfig
  use util::logger::Logger;
  
  use bitcoin::util::hash::BitcoinHash;
 -use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 +use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 +use bitcoin::hash_types::{Txid, BlockHash};
  use bitcoin::util::bip143;
  use bitcoin::util::address::Address;
  use bitcoin::util::bip32::{ChildNumber, ExtendedPubKey, ExtendedPrivKey};
@@@ -37,11 -36,11 +37,11 @@@ use bitcoin::blockdata::opcodes
  use bitcoin::blockdata::constants::genesis_block;
  use bitcoin::network::constants::Network;
  
 -use bitcoin_hashes::sha256::Hash as Sha256;
 -use bitcoin_hashes::Hash;
 +use bitcoin::hashes::sha256::Hash as Sha256;
 +use bitcoin::hashes::Hash;
  
 -use secp256k1::{Secp256k1, Message};
 -use secp256k1::key::{PublicKey,SecretKey};
 +use bitcoin::secp256k1::{Secp256k1, Message};
 +use bitcoin::secp256k1::key::{PublicKey,SecretKey};
  
  use std::collections::{BTreeSet, HashMap, HashSet};
  use std::default::Default;
@@@ -76,7 -75,7 +76,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(), InitFeatures::supported(), &message_mutator(open_channel_message.clone()));
+               nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &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] {
@@@ -118,7 -117,7 +118,7 @@@ fn test_async_inbound_update_fee() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        let channel_id = chan.2;
  
        // balancing
@@@ -231,7 -230,7 +231,7 @@@ fn test_update_fee_unordered_raa() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        let channel_id = chan.2;
  
        // balancing
@@@ -284,7 -283,7 +284,7 @@@ fn test_multi_flight_update_fee() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        let channel_id = chan.2;
  
        // A                                        B
@@@ -402,7 -401,7 +402,7 @@@ fn test_1_conf_open() 
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(alice_config), Some(bob_config)]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::supported(), InitFeatures::supported());
+       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
        assert!(nodes[0].chain_monitor.does_match_tx(&tx));
        assert!(nodes[1].chain_monitor.does_match_tx(&tx));
  
@@@ -443,11 -442,11 +443,11 @@@ fn do_test_sanity_on_in_flight_opens(st
        let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
  
        if steps & 0x0f == 1 { return; }
-       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::supported(), &open_channel);
+       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &open_channel);
        let accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
  
        if steps & 0x0f == 2 { return; }
-       nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::supported(), &accept_channel);
+       nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_channel);
  
        let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 42);
  
@@@ -521,7 -520,7 +521,7 @@@ fn test_update_fee_vanilla() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        let channel_id = chan.2;
  
        let feerate = get_feerate!(nodes[0], channel_id);
@@@ -563,7 -562,7 +563,7 @@@ fn test_update_fee_that_funder_cannot_a
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
        let channel_value = 1888;
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 700000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 700000, InitFeatures::known(), InitFeatures::known());
        let channel_id = chan.2;
  
        let feerate = 260;
@@@ -612,7 -611,7 +612,7 @@@ fn test_update_fee_with_fundee_update_a
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        let channel_id = chan.2;
  
        // balancing
@@@ -709,7 -708,7 +709,7 @@@ fn test_update_fee() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        let channel_id = chan.2;
  
        // A                                        B
@@@ -813,7 -812,7 +813,7 @@@ fn pre_funding_lock_shutdown_test() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0, InitFeatures::supported(), InitFeatures::supported());
+       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0, InitFeatures::known(), InitFeatures::known());
        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);
@@@ -842,8 -841,8 +842,8 @@@ fn updates_shutdown_wait() 
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
        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();
  
@@@ -915,8 -914,8 +915,8 @@@ fn htlc_fail_async_shutdown() 
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        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]);
@@@ -991,8 -990,8 +991,8 @@@ fn do_test_shutdown_rebroadcast(recv_co
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
  
@@@ -1156,9 -1155,9 +1156,9 @@@ fn fake_network_test() 
        let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       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_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
+       let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
  
        // 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);
@@@ -1176,7 -1175,7 +1176,7 @@@
        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, InitFeatures::supported(), InitFeatures::supported());
+       let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
  
        send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000, 1_000_000);
        send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000, 1_000_000);
@@@ -1250,7 -1249,7 +1250,7 @@@
        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, InitFeatures::supported(), InitFeatures::supported());
+       let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
  
        // Send some payments across both channels
        let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
@@@ -1286,8 -1285,8 +1286,8 @@@ fn holding_cell_htlc_counting() 
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        let mut payments = Vec::new();
        for _ in 0..::ln::channel::OUR_MAX_HTLCS {
@@@ -1409,11 -1408,11 +1409,11 @@@ fn duplicate_htlc_test() 
        let mut nodes = create_network(6, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels to route via 3 to 4/5 from 0/1/2
-       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());
+       create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
  
        let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], 1000000);
  
@@@ -1438,7 -1437,7 +1438,7 @@@ fn test_duplicate_htlc_different_direct
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        // balancing
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
@@@ -1506,8 -1505,8 +1506,8 @@@ fn do_channel_reserve_test(test_recv: b
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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 chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1900, 1001, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1900, 1001, InitFeatures::known(), InitFeatures::known());
  
        let mut stat01 = get_channel_value_stat!(nodes[0], chan_1.2);
        let mut stat11 = get_channel_value_stat!(nodes[1], chan_1.2);
@@@ -1786,7 -1785,7 +1786,7 @@@ fn channel_reserve_in_flight_removes() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let b_chan_values = get_channel_value_stat!(nodes[1], chan_1.2);
        // Route the first two HTLCs.
@@@ -1918,10 -1917,10 +1918,10 @@@ fn channel_monitor_network_test() 
        let nodes = create_network(5, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       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());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
+       let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
+       let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
  
        // 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);
@@@ -2076,7 -2075,7 +2076,7 @@@ fn test_justice_tx() 
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &user_cfgs);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
        // Create some new channels:
-       let chan_5 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_5 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        // A pending HTLC which will be revoked:
        let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
@@@ -2123,7 -2122,7 +2123,7 @@@
  
        // 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, InitFeatures::supported(), InitFeatures::supported());
+       let chan_6 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        {
                let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
                node_txn.clear();
@@@ -2173,7 -2172,7 +2173,7 @@@ fn revoked_output_claim() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        // node[0] is gonna to revoke an old state thus node[1] should be able to claim the revoked output
        let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
        assert_eq!(revoked_local_txn.len(), 1);
@@@ -2207,7 -2206,7 +2207,7 @@@ fn claim_htlc_outputs_shared_tx() 
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some new channel:
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        // Rebalance the network to generate htlc in the two directions
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
@@@ -2276,7 -2275,7 +2276,7 @@@ fn claim_htlc_outputs_single_tx() 
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        // Rebalance the network to generate htlc in the two directions
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
@@@ -2362,8 -2361,8 +2362,8 @@@ fn test_htlc_on_chain_success() 
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       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_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        // 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);
@@@ -2535,8 -2534,8 +2535,8 @@@ fn test_htlc_on_chain_timeout() 
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  
        // Create some intial channels
-       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_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        // 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);
@@@ -2645,8 -2644,8 +2645,8 @@@ fn test_simple_commitment_revoked_fail_
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       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());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
        // Get the will-be-revoked local txn from nodes[2]
@@@ -2711,8 -2710,8 +2711,8 @@@ fn do_test_commitment_revoked_fail_back
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       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());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        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]
@@@ -2922,7 -2921,7 +2922,7 @@@ fn fail_backward_pending_htlc_upon_chan
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, InitFeatures::known(), InitFeatures::known());
  
        // Alice -> Bob: Route a payment but without Bob sending revoke_and_ack.
        {
@@@ -2994,7 -2993,7 +2994,7 @@@ fn test_htlc_ignore_latest_remote_commi
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        route_payment(&nodes[0], &[&nodes[1]], 10000000);
        nodes[0].node.force_close_channel(&nodes[0].node.list_channels()[0].channel_id);
@@@ -3021,8 -3020,8 +3021,8 @@@ fn test_force_close_fail_back() 
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, 42).unwrap();
  
@@@ -3079,7 -3078,7 +3079,7 @@@
        // Now check that if we add the preimage to ChannelMonitor it broadcasts our HTLC-Success..
        {
                let mut monitors = nodes[2].chan_monitor.simple_monitor.monitors.lock().unwrap();
 -              monitors.get_mut(&OutPoint::new(Sha256dHash::from_slice(&payment_event.commitment_msg.channel_id[..]).unwrap(), 0)).unwrap()
 +              monitors.get_mut(&OutPoint::new(Txid::from_slice(&payment_event.commitment_msg.channel_id[..]).unwrap(), 0)).unwrap()
                        .provide_payment_preimage(&our_payment_hash, &our_payment_preimage);
        }
        nodes[2].block_notifier.block_connected_checked(&header, 1, &[&tx], &[1]);
@@@ -3100,7 -3099,7 +3100,7 @@@ fn test_unconf_chan() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let channel_state = nodes[0].node.channel_state.lock().unwrap();
        assert_eq!(channel_state.by_id.len(), 1);
@@@ -3133,8 -3132,8 +3133,8 @@@ fn test_simple_peer_disconnect() 
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        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);
@@@ -3190,10 -3189,10 +3190,10 @@@ fn do_test_drop_messages_peer_disconnec
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
        if messages_delivered == 0 {
-               create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::supported(), InitFeatures::supported());
+               create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
                // 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, InitFeatures::supported(), InitFeatures::supported());
+               create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        }
  
        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();
@@@ -3399,7 -3398,7 +3399,7 @@@ fn test_funding_peer_disconnect() 
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::supported(), InitFeatures::supported());
+       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
  
        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);
@@@ -3484,7 -3483,7 +3484,7 @@@ fn test_drop_messages_peer_disconnect_d
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
  
@@@ -3627,7 -3626,7 +3627,7 @@@ fn do_test_htlc_timeout(send_partial_mp
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let our_payment_hash = if send_partial_mpp {
                let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV).unwrap();
@@@ -3685,8 -3684,8 +3685,8 @@@ fn do_test_holding_cell_htlc_add_timeou
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        // Route a first payment to get the 1 -> 2 channel in awaiting_raa...
        let route = nodes[1].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV).unwrap();
@@@ -3765,7 -3764,7 +3765,7 @@@ fn test_invalid_channel_announcement() 
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan_announcement = create_chan_between_nodes(&nodes[0], &nodes[1], InitFeatures::supported(), InitFeatures::supported());
+       let chan_announcement = create_chan_between_nodes(&nodes[0], &nodes[1], InitFeatures::known(), InitFeatures::known());
  
        let a_channel_lock = nodes[0].node.channel_state.lock().unwrap();
        let b_channel_lock = nodes[1].node.channel_state.lock().unwrap();
@@@ -3787,7 -3786,7 +3787,7 @@@
        macro_rules! dummy_unsigned_msg {
                () => {
                        msgs::UnsignedChannelAnnouncement {
-                               features: ChannelFeatures::supported(),
+                               features: ChannelFeatures::known(),
                                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 },
@@@ -3828,7 -3827,7 +3828,7 @@@
        assert!(nodes[0].router.handle_channel_announcement(&chan_announcement).is_err());
  
        let mut unsigned_msg = dummy_unsigned_msg!();
 -      unsigned_msg.chain_hash = Sha256dHash::hash(&[1,2,3,4,5,6,7,8,9]);
 +      unsigned_msg.chain_hash = BlockHash::hash(&[1,2,3,4,5,6,7,8,9]);
        sign_msg!(unsigned_msg);
        assert!(nodes[0].router.handle_channel_announcement(&chan_announcement).is_err());
  }
@@@ -3844,7 -3843,7 +3844,7 @@@ fn test_no_txn_manager_serialize_deseri
        let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>;
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::supported(), InitFeatures::supported());
+       let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
  
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
  
@@@ -3856,7 -3855,7 +3856,7 @@@
        new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new()), &fee_estimator);
        nodes[0].chan_monitor = &new_chan_monitor;
        let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
 -      let (_, mut chan_0_monitor) = <(Sha256dHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read, Arc::new(test_utils::TestLogger::new())).unwrap();
 +      let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read, Arc::new(test_utils::TestLogger::new())).unwrap();
        assert!(chan_0_monitor_read.is_empty());
  
        let mut nodes_0_read = &nodes_0_serialized[..];
@@@ -3865,7 -3864,7 +3865,7 @@@
        let (_, nodes_0_deserialized_tmp) = {
                let mut channel_monitors = HashMap::new();
                channel_monitors.insert(chan_0_monitor.get_funding_txo(), &mut chan_0_monitor);
 -              <(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
 +              <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
                        default_config: config,
                        keys_manager: &keys_manager,
                        fee_estimator: &fee_estimator,
@@@ -3915,7 -3914,7 +3915,7 @@@ fn test_simple_manager_serialize_deseri
        let keys_manager: test_utils::TestKeysInterface;
        let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>;
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
        let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
@@@ -3930,7 -3929,7 +3930,7 @@@
        new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new()), &fee_estimator);
        nodes[0].chan_monitor = &new_chan_monitor;
        let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
 -      let (_, mut chan_0_monitor) = <(Sha256dHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read, Arc::new(test_utils::TestLogger::new())).unwrap();
 +      let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read, Arc::new(test_utils::TestLogger::new())).unwrap();
        assert!(chan_0_monitor_read.is_empty());
  
        let mut nodes_0_read = &nodes_0_serialized[..];
@@@ -3938,7 -3937,7 +3938,7 @@@
        let (_, nodes_0_deserialized_tmp) = {
                let mut channel_monitors = HashMap::new();
                channel_monitors.insert(chan_0_monitor.get_funding_txo(), &mut chan_0_monitor);
 -              <(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
 +              <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
                        default_config: UserConfig::default(),
                        keys_manager: &keys_manager,
                        fee_estimator: &fee_estimator,
@@@ -3972,9 -3971,9 +3972,9 @@@ fn test_manager_serialize_deserialize_i
        let keys_manager: test_utils::TestKeysInterface;
        let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>;
        let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
-       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());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 2, 0, InitFeatures::known(), InitFeatures::known());
+       let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::known(), InitFeatures::known());
  
        let mut node_0_stale_monitors_serialized = Vec::new();
        for monitor in nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter() {
@@@ -4009,7 -4008,7 +4009,7 @@@
        let mut node_0_stale_monitors = Vec::new();
        for serialized in node_0_stale_monitors_serialized.iter() {
                let mut read = &serialized[..];
 -              let (_, monitor) = <(Sha256dHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read, Arc::new(test_utils::TestLogger::new())).unwrap();
 +              let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read, Arc::new(test_utils::TestLogger::new())).unwrap();
                assert!(read.is_empty());
                node_0_stale_monitors.push(monitor);
        }
@@@ -4017,7 -4016,7 +4017,7 @@@
        let mut node_0_monitors = Vec::new();
        for serialized in node_0_monitors_serialized.iter() {
                let mut read = &serialized[..];
 -              let (_, monitor) = <(Sha256dHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read, Arc::new(test_utils::TestLogger::new())).unwrap();
 +              let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read, Arc::new(test_utils::TestLogger::new())).unwrap();
                assert!(read.is_empty());
                node_0_monitors.push(monitor);
        }
@@@ -4026,7 -4025,7 +4026,7 @@@
  
        let mut nodes_0_read = &nodes_0_serialized[..];
        if let Err(msgs::DecodeError::InvalidValue) =
 -              <(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
 +              <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
                default_config: UserConfig::default(),
                keys_manager: &keys_manager,
                fee_estimator: &fee_estimator,
@@@ -4040,7 -4039,7 +4040,7 @@@
  
        let mut nodes_0_read = &nodes_0_serialized[..];
        let (_, nodes_0_deserialized_tmp) =
 -              <(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
 +              <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
                default_config: UserConfig::default(),
                keys_manager: &keys_manager,
                fee_estimator: &fee_estimator,
@@@ -4207,7 -4206,7 +4207,7 @@@ fn test_claim_sizeable_push_msat() 
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::known(), InitFeatures::known());
        nodes[1].node.force_close_channel(&chan.2);
        check_closed_broadcast!(nodes[1], false);
        check_added_monitors!(nodes[1], 1);
@@@ -4234,7 -4233,7 +4234,7 @@@ fn test_claim_on_remote_sizeable_push_m
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::known(), InitFeatures::known());
        nodes[0].node.force_close_channel(&chan.2);
        check_closed_broadcast!(nodes[0], false);
        check_added_monitors!(nodes[0], 1);
@@@ -4266,7 -4265,7 +4266,7 @@@ fn test_claim_on_remote_revoked_sizeabl
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 59000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 59000000, InitFeatures::known(), InitFeatures::known());
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan.2);
        assert_eq!(revoked_local_txn[0].input.len(), 1);
@@@ -4298,7 -4297,7 +4298,7 @@@ fn test_static_spendable_outputs_preima
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
  
@@@ -4347,7 -4346,7 +4347,7 @@@ fn test_static_spendable_outputs_timeou
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        // Rebalance the network a bit by relaying one payment through all the channels ...
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
@@@ -4394,7 -4393,7 +4394,7 @@@ fn test_static_spendable_outputs_justic
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
@@@ -4430,7 -4429,7 +4430,7 @@@ fn test_static_spendable_outputs_justic
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
@@@ -4486,7 -4485,7 +4486,7 @@@ fn test_static_spendable_outputs_justic
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
@@@ -4547,8 -4546,8 +4547,8 @@@ fn test_onchain_to_onchain_claim() 
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       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_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        // 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);
@@@ -4641,8 -4640,8 +4641,8 @@@ fn test_duplicate_payment_hash_one_fail
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  
-       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());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        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;
@@@ -4757,7 -4756,7 +4757,7 @@@ fn test_dynamic_spendable_outputs_local
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000).0;
        let local_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
@@@ -4816,11 -4815,11 +4816,11 @@@ fn do_test_fail_backwards_unrevoked_rem
        let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
        let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
  
-       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());
+       create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
+       let chan = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
  
        // Rebalance and check output sanity...
        send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000, 500_000);
@@@ -5059,7 -5058,7 +5059,7 @@@ fn test_dynamic_spendable_outputs_local
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
        let local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
@@@ -5100,7 -5099,7 +5100,7 @@@ fn test_static_output_closing_tx() 
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        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;
@@@ -5126,7 -5125,7 +5126,7 @@@ fn do_htlc_claim_local_commitment_only(
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], if use_dust { 50000 } else { 3000000 });
  
@@@ -5167,7 -5166,7 +5167,7 @@@ fn do_htlc_claim_current_remote_commitm
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        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]);
@@@ -5196,7 -5195,7 +5196,7 @@@ fn do_htlc_claim_previous_remote_commit
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        // 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.
@@@ -5441,12 -5440,12 +5441,12 @@@ fn run_onion_failure_test_with_fail_int
  
  impl msgs::ChannelUpdate {
        fn dummy() -> msgs::ChannelUpdate {
 -              use secp256k1::ffi::Signature as FFISignature;
 -              use secp256k1::Signature;
 +              use bitcoin::secp256k1::ffi::Signature as FFISignature;
 +              use bitcoin::secp256k1::Signature;
                msgs::ChannelUpdate {
                        signature: Signature::from(FFISignature::new()),
                        contents: msgs::UnsignedChannelUpdate {
 -                              chain_hash: Sha256dHash::hash(&vec![0u8][..]),
 +                              chain_hash: BlockHash::hash(&vec![0u8][..]),
                                short_channel_id: 0,
                                timestamp: 0,
                                flags: 0,
@@@ -5478,7 -5477,7 +5478,7 @@@ impl Writeable for BogusOnionHopData 
  fn test_onion_failure() {
        use ln::msgs::ChannelUpdate;
        use ln::channelmanager::CLTV_FAR_FAR_AWAY;
 -      use secp256k1;
 +      use bitcoin::secp256k1;
  
        const BADONION: u16 = 0x8000;
        const PERM: u16 = 0x4000;
@@@ -5492,7 -5491,7 +5492,7 @@@
        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, InitFeatures::supported(), InitFeatures::supported()), create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported())];
+       let channels = [create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()), create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known())];
        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
@@@ -5728,7 -5727,7 +5728,7 @@@ fn bolt2_open_channel_sending_node_chec
        let push_msat=10001;
        nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).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(), InitFeatures::supported(), &node0_to_1_send_open_channel);
+       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &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, None).is_err());
@@@ -5790,7 -5789,7 +5790,7 @@@ fn test_update_add_htlc_bolt2_sender_va
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
+       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
        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]);
  
@@@ -5809,7 -5808,7 +5809,7 @@@ fn test_update_add_htlc_bolt2_sender_ze
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
+       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
        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]);
  
@@@ -5828,7 -5827,7 +5828,7 @@@ fn test_update_add_htlc_bolt2_receiver_
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
+       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
        let 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]);
  
@@@ -5851,7 -5850,7 +5851,7 @@@ fn test_update_add_htlc_bolt2_sender_cl
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 0, InitFeatures::supported(), InitFeatures::supported());
+       let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 0, InitFeatures::known(), InitFeatures::known());
        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]);
  
@@@ -5868,7 -5867,7 +5868,7 @@@ fn test_update_add_htlc_bolt2_sender_ex
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 0, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 0, InitFeatures::known(), InitFeatures::known());
        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 {
@@@ -5911,7 -5910,7 +5911,7 @@@ fn test_update_add_htlc_bolt2_sender_ex
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
        let channel_value = 100000;
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, InitFeatures::known(), InitFeatures::known());
        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);
@@@ -5935,7 -5934,7 +5935,7 @@@ fn test_update_add_htlc_bolt2_receiver_
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
        let htlc_minimum_msat: u64;
        {
                let chan_lock = nodes[0].node.channel_state.lock().unwrap();
@@@ -5962,7 -5961,7 +5962,7 @@@ fn test_update_add_htlc_bolt2_receiver_
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
  
        let their_channel_reserve = get_channel_value_stat!(nodes[0], chan.2).channel_reserve_msat;
  
@@@ -5989,7 -5988,7 +5989,7 @@@ fn test_update_add_htlc_bolt2_receiver_
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
        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]);
  
@@@ -6034,7 -6033,7 +6034,7 @@@ fn test_update_add_htlc_bolt2_receiver_
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
        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, &None).unwrap();
@@@ -6056,7 -6055,7 +6056,7 @@@ fn test_update_add_htlc_bolt2_receiver_
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
        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, &None).unwrap();
@@@ -6080,7 -6079,7 +6080,7 @@@ fn test_update_add_htlc_bolt2_receiver_
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        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, &None).unwrap();
@@@ -6125,7 -6124,7 +6125,7 @@@ fn test_update_fulfill_htlc_bolt2_updat
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        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]);
@@@ -6156,7 -6155,7 +6156,7 @@@ fn test_update_fulfill_htlc_bolt2_updat
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        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]);
@@@ -6187,7 -6186,7 +6187,7 @@@ fn test_update_fulfill_htlc_bolt2_updat
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        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]);
@@@ -6219,7 -6218,7 +6219,7 @@@ fn test_update_fulfill_htlc_bolt2_incor
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
  
@@@ -6260,7 -6259,7 +6260,7 @@@ fn test_update_fulfill_htlc_bolt2_wrong
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
  
@@@ -6301,7 -6300,7 +6301,7 @@@ fn test_update_fulfill_htlc_bolt2_missi
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
        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, &None).unwrap();
@@@ -6347,8 -6346,8 +6347,8 @@@ fn test_update_fulfill_htlc_bolt2_after
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       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());
+       create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
  
        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]);
@@@ -6425,7 -6424,7 +6425,7 @@@ fn do_test_failure_delay_dust_htlc_loca
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan =create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan =create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
  
@@@ -6514,7 -6513,7 +6514,7 @@@ fn test_no_failure_dust_htlc_local_comm
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        // Rebalance a bit
        send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
@@@ -6571,7 -6570,7 +6571,7 @@@ fn do_test_sweep_outbound_htlc_failure_
        let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
  
@@@ -6671,7 -6670,7 +6671,7 @@@ fn test_upfront_shutdown_script() 
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  
        // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign
-       let flags = InitFeatures::supported();
+       let flags = InitFeatures::known();
        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());
@@@ -6695,8 -6694,7 +6695,7 @@@
        }
  
        // We test that if case of peer non-signaling we don't enforce committed script at channel opening
-       let mut flags_no = InitFeatures::supported();
-       flags_no.unset_upfront_shutdown_script();
+       let flags_no = InitFeatures::known().clear_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();
        let mut node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
@@@ -6769,7 -6767,7 +6768,7 @@@ fn test_user_configurable_csv_delay() 
        nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42, None).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(), InitFeatures::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::known(), &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"),
@@@ -6778,10 -6776,10 +6777,10 @@@
  
        // 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, None).unwrap();
-       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[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &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(), InitFeatures::supported(), &accept_channel);
+       nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_channel);
        if let MessageSendEvent::HandleError { ref action, .. } = nodes[0].node.get_and_clear_pending_msg_events()[0] {
                match action {
                        &ErrorAction::SendErrorMessage { ref msg } => {
@@@ -6795,7 -6793,7 +6794,7 @@@
        nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42, None).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(), InitFeatures::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::known(), &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"),
@@@ -6819,7 -6817,7 +6818,7 @@@ fn test_data_loss_protect() 
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
  
        // Cache node A state before any channel update
        let previous_node_state = nodes[0].node.encode();
@@@ -6834,7 -6832,7 +6833,7 @@@
  
        // Restore node A from previous state
        let logger: Arc<Logger> = Arc::new(test_utils::TestLogger::with_id(format!("node {}", 0)));
 -      let mut chan_monitor = <(Sha256dHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut ::std::io::Cursor::new(previous_chan_monitor_state.0), Arc::clone(&logger)).unwrap().1;
 +      let mut chan_monitor = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut ::std::io::Cursor::new(previous_chan_monitor_state.0), Arc::clone(&logger)).unwrap().1;
        let chain_monitor = Arc::new(ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&logger)));
        tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())};
        fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
@@@ -6843,7 -6841,7 +6842,7 @@@
        node_state_0 = {
                let mut channel_monitors = HashMap::new();
                channel_monitors.insert(OutPoint { txid: chan.3.txid(), index: 0 }, &mut chan_monitor);
 -              <(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut ::std::io::Cursor::new(previous_node_state), ChannelManagerReadArgs {
 +              <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut ::std::io::Cursor::new(previous_node_state), ChannelManagerReadArgs {
                        keys_manager: &keys_manager,
                        fee_estimator: &fee_estimator,
                        monitor: &monitor,
@@@ -6927,7 -6925,7 +6926,7 @@@ fn test_check_htlc_underpaying() 
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channels
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
        let (payment_preimage, payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 10_000);
  
@@@ -6971,9 -6969,9 +6970,9 @@@ fn test_announce_disable_channels() 
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       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;
+       let short_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+       let short_id_2 = create_announced_chan_between_nodes(&nodes, 1, 0, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+       let short_id_3 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
  
        // Disconnect peers
        nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
@@@ -7033,7 -7031,7 +7032,7 @@@ fn test_bump_penalty_txn_on_revoked_com
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
        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);
@@@ -7136,7 -7134,7 +7135,7 @@@ fn test_bump_penalty_txn_on_revoked_htl
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
        // 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;
@@@ -7259,7 -7257,7 +7258,7 @@@ fn test_bump_penalty_txn_on_remote_comm
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
        let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000).0;
  
@@@ -7367,7 -7365,7 +7366,7 @@@ fn test_set_outpoints_partial_claiming(
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
        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;
  
@@@ -7468,7 -7466,7 +7467,7 @@@ fn test_counterparty_raa_skip_no_crash(
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
+       let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
  
        let commitment_seed = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&channel_id).unwrap().local_keys.commitment_seed().clone();
        const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
@@@ -7492,7 -7490,7 +7491,7 @@@ fn test_bump_txn_sanitize_tracking_maps
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
-       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::supported(), InitFeatures::supported());
+       let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
        // 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;
@@@ -7566,7 -7564,7 +7565,7 @@@ fn test_override_0msat_htlc_minimum() 
        let res = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
        assert_eq!(res.htlc_minimum_msat, 1);
  
-       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::supported(), &res);
+       nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &res);
        let res = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
        assert_eq!(res.htlc_minimum_msat, 1);
  }
@@@ -7580,8 -7578,8 +7579,8 @@@ fn test_simple_payment_secret() 
        let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
        let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  
-       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
-       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
+       create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+       create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
        let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
        let payment_secret = PaymentSecret([0xdb; 32]);
@@@ -7602,10 -7600,10 +7601,10 @@@ fn test_simple_mpp() 
        let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
        let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
  
-       let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
-       let chan_2_id = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
-       let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
-       let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
+       let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+       let chan_2_id = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+       let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
+       let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
  
        let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
        let payment_secret = PaymentSecret([0xdb; 32]);
@@@ -7642,7 -7640,7 +7641,7 @@@ fn test_update_err_monitor_lockdown() 
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
        // Create some initial channel
-       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
+       let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
  
        // Rebalance the network to generate htlc in the two directions
@@@ -7658,7 -7656,7 +7657,7 @@@
                let monitor = monitors.get(&outpoint).unwrap();
                let mut w = test_utils::TestVecWriter(Vec::new());
                monitor.write_for_disk(&mut w).unwrap();
 -              let new_monitor = <(Sha256dHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::read(
 +              let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::read(
                                &mut ::std::io::Cursor::new(&w.0), Arc::new(test_utils::TestLogger::new())).unwrap().1;
                assert!(new_monitor == *monitor);
                let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, logger.clone() as Arc<Logger>));

diff --combined lightning/src/ln/msgs.rs
index fb506c4759528a768a0ef98158c2e4d2b20c67dc,de8014a6adaec2559a8d9941e0ecbea064175556..cce8c3d0b121722ff4b3ec24f592cc89067687de
--- 1/lightning/src/ln/msgs.rs
--- 2/lightning/src/ln/msgs.rs
+++ b/lightning/src/ln/msgs.rs
@@@ -15,11 -15,11 +15,11 @@@
  //! raw socket events into your non-internet-facing system and then send routing events back to
  //! track the network on the less-secure system.
  
 -use secp256k1::key::PublicKey;
 -use secp256k1::Signature;
 -use secp256k1;
 -use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 +use bitcoin::secp256k1::key::PublicKey;
 +use bitcoin::secp256k1::Signature;
 +use bitcoin::secp256k1;
  use bitcoin::blockdata::script::Script;
 +use bitcoin::hash_types::{Txid, BlockHash};
  
  use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
  
@@@ -84,7 -84,7 +84,7 @@@ pub struct Pong 
  /// An open_channel message to be sent or received from a peer
  #[derive(Clone)]
  pub struct OpenChannel {
 -      pub(crate) chain_hash: Sha256dHash,
 +      pub(crate) chain_hash: BlockHash,
        pub(crate) temporary_channel_id: [u8; 32],
        pub(crate) funding_satoshis: u64,
        pub(crate) push_msat: u64,
@@@ -129,7 -129,7 +129,7 @@@ pub struct AcceptChannel 
  #[derive(Clone)]
  pub struct FundingCreated {
        pub(crate) temporary_channel_id: [u8; 32],
 -      pub(crate) funding_txid: Sha256dHash,
 +      pub(crate) funding_txid: Txid,
        pub(crate) funding_output_index: u16,
        pub(crate) signature: Signature,
  }
@@@ -403,7 -403,7 +403,7 @@@ pub struct NodeAnnouncement 
  #[derive(PartialEq, Clone, Debug)]
  pub struct UnsignedChannelAnnouncement {
        pub(crate) features: ChannelFeatures,
 -      pub(crate) chain_hash: Sha256dHash,
 +      pub(crate) chain_hash: BlockHash,
        pub(crate) short_channel_id: u64,
        /// One of the two node_ids which are endpoints of this channel
        pub        node_id_1: PublicKey,
@@@ -425,7 -425,7 +425,7 @@@ pub struct ChannelAnnouncement 
  
  #[derive(PartialEq, Clone, Debug)]
  pub(crate) struct UnsignedChannelUpdate {
 -      pub(crate) chain_hash: Sha256dHash,
 +      pub(crate) chain_hash: BlockHash,
        pub(crate) short_channel_id: u64,
        pub(crate) timestamp: u32,
        pub(crate) flags: u16,
@@@ -1360,15 -1360,15 +1360,15 @@@ mod tests 
        use ln::channelmanager::{PaymentPreimage, PaymentHash, PaymentSecret};
        use util::ser::{Writeable, Readable};
  
 -      use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 -      use bitcoin_hashes::hex::FromHex;
 +      use bitcoin::hashes::hex::FromHex;
        use bitcoin::util::address::Address;
        use bitcoin::network::constants::Network;
        use bitcoin::blockdata::script::Builder;
        use bitcoin::blockdata::opcodes;
 +      use bitcoin::hash_types::{Txid, BlockHash};
  
 -      use secp256k1::key::{PublicKey,SecretKey};
 -      use secp256k1::{Secp256k1, Message};
 +      use bitcoin::secp256k1::key::{PublicKey,SecretKey};
 +      use bitcoin::secp256k1::{Secp256k1, Message};
  
        use std::io::Cursor;
  
@@@ -1455,13 -1455,13 +1455,13 @@@
                let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
                let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
                let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
-               let mut features = ChannelFeatures::supported();
+               let mut features = ChannelFeatures::known();
                if unknown_features_bits {
                        features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
                }
                let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
                        features,
 -                      chain_hash: if !non_bitcoin_chain_hash { Sha256dHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap() } else { Sha256dHash::from_hex("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943").unwrap() },
 +                      chain_hash: if !non_bitcoin_chain_hash { BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap() } else { BlockHash::from_hex("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943").unwrap() },
                        short_channel_id: 2316138423780173,
                        node_id_1: pubkey_1,
                        node_id_2: pubkey_2,
@@@ -1611,7 -1611,7 +1611,7 @@@
                let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
                let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
                let unsigned_channel_update = msgs::UnsignedChannelUpdate {
 -                      chain_hash: if !non_bitcoin_chain_hash { Sha256dHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap() } else { Sha256dHash::from_hex("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943").unwrap() },
 +                      chain_hash: if !non_bitcoin_chain_hash { BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap() } else { BlockHash::from_hex("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943").unwrap() },
                        short_channel_id: 2316138423780173,
                        timestamp: 20190119,
                        flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 } | if htlc_maximum_msat { 1 << 8 } else { 0 },
@@@ -1673,7 -1673,7 +1673,7 @@@
                let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
                let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
                let open_channel = msgs::OpenChannel {
 -                      chain_hash: if !non_bitcoin_chain_hash { Sha256dHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap() } else { Sha256dHash::from_hex("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943").unwrap() },
 +                      chain_hash: if !non_bitcoin_chain_hash { BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap() } else { BlockHash::from_hex("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943").unwrap() },
                        temporary_channel_id: [2; 32],
                        funding_satoshis: 1311768467284833366,
                        push_msat: 2536655962884945560,
@@@ -1767,7 -1767,7 +1767,7 @@@
                let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
                let funding_created = msgs::FundingCreated {
                        temporary_channel_id: [2; 32],
 -                      funding_txid: Sha256dHash::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
 +                      funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
                        funding_output_index: 255,
                        signature: sig_1,
                };

diff --combined lightning/src/ln/peer_handler.rs
index b99f2f522709dd56cbe01a5d441bb77f7892b255,2dadf2ec6149e565d65e155c6c844694fede4096..51a546de60b24c6926c36be422679a6826c32122
--- 1/lightning/src/ln/peer_handler.rs
--- 2/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@@ -6,7 -6,7 +6,7 @@@
  //! call into the provided message handlers (probably a ChannelManager and Router) with messages
  //! they should handle, and encoding/sending response messages.
  
 -use secp256k1::key::{SecretKey,PublicKey};
 +use bitcoin::secp256k1::key::{SecretKey,PublicKey};
  
  use ln::features::InitFeatures;
  use ln::msgs;
@@@ -26,9 -26,9 +26,9 @@@ use std::sync::atomic::{AtomicUsize, Or
  use std::{cmp,error,hash,fmt};
  use std::ops::Deref;
  
 -use bitcoin_hashes::sha256::Hash as Sha256;
 -use bitcoin_hashes::sha256::HashEngine as Sha256Engine;
 -use bitcoin_hashes::{HashEngine, Hash};
 +use bitcoin::hashes::sha256::Hash as Sha256;
 +use bitcoin::hashes::sha256::HashEngine as Sha256Engine;
 +use bitcoin::hashes::{HashEngine, Hash};
  
  /// Provides references to trait impls which handle different types of messages.
  pub struct MessageHandler<CM: Deref> where CM::Target: msgs::ChannelMessageHandler {
@@@ -548,9 -548,9 +548,9 @@@ impl<Descriptor: SocketDescriptor, CM: 
  
                                                                        peer.their_node_id = Some(their_node_id);
                                                                        insert_node_id!();
-                                                                       let mut features = InitFeatures::supported();
-                                                                       if self.message_handler.route_handler.should_request_full_sync(&peer.their_node_id.unwrap()) {
-                                                                               features.set_initial_routing_sync();
+                                                                       let mut features = InitFeatures::known();
+                                                                       if !self.message_handler.route_handler.should_request_full_sync(&peer.their_node_id.unwrap()) {
+                                                                               features.clear_initial_routing_sync();
                                                                        }
  
                                                                        let resp = msgs::Init { features };
@@@ -642,9 -642,9 +642,9 @@@
                                                                                                }
  
                                                                                                if !peer.outbound {
-                                                                                                       let mut features = InitFeatures::supported();
-                                                                                                       if self.message_handler.route_handler.should_request_full_sync(&peer.their_node_id.unwrap()) {
-                                                                                                               features.set_initial_routing_sync();
+                                                                                                       let mut features = InitFeatures::known();
+                                                                                                       if !self.message_handler.route_handler.should_request_full_sync(&peer.their_node_id.unwrap()) {
+                                                                                                               features.clear_initial_routing_sync();
                                                                                                        }
  
                                                                                                        let resp = msgs::Init { features };
@@@ -1153,7 -1153,7 +1153,7 @@@
  
  #[cfg(test)]
  mod tests {
 -      use secp256k1::Signature;
 +      use bitcoin::secp256k1::Signature;
        use bitcoin::BitcoinHash;
        use bitcoin::network::constants::Network;
        use bitcoin::blockdata::constants::genesis_block;
@@@ -1164,8 -1164,8 +1164,8 @@@
        use util::test_utils;
        use util::logger::Logger;
  
 -      use secp256k1::Secp256k1;
 -      use secp256k1::key::{SecretKey, PublicKey};
 +      use bitcoin::secp256k1::Secp256k1;
 +      use bitcoin::secp256k1::key::{SecretKey, PublicKey};
  
        use rand::{thread_rng, Rng};
  
@@@ -1247,6 -1247,13 +1247,13 @@@
                (fd_a.clone(), fd_b.clone())
        }
  
+       fn establish_connection_and_read_events<'a>(peer_a: &PeerManager<FileDescriptor, &'a test_utils::TestChannelMessageHandler>, peer_b: &PeerManager<FileDescriptor, &'a test_utils::TestChannelMessageHandler>) -> (FileDescriptor, FileDescriptor) {
+               let (mut fd_a, mut fd_b) = establish_connection(peer_a, peer_b);
+               assert_eq!(peer_b.read_event(&mut fd_b, &fd_a.outbound_data.lock().unwrap().split_off(0)).unwrap(), false);
+               assert_eq!(peer_a.read_event(&mut fd_a, &fd_b.outbound_data.lock().unwrap().split_off(0)).unwrap(), false);
+               (fd_a.clone(), fd_b.clone())
+       }
+ 
        #[test]
        fn test_disconnect_peer() {
                // Simple test which builds a network of PeerManager, connects and brings them to NoiseState::Finished and
@@@ -1343,7 -1350,7 +1350,7 @@@
        }
  
        fn get_dummy_channel_announcement(short_chan_id: u64) -> msgs::ChannelAnnouncement {
 -              use secp256k1::ffi::Signature as FFISignature;
 +              use bitcoin::secp256k1::ffi::Signature as FFISignature;
                let secp_ctx = Secp256k1::new();
                let network = Network::Testnet;
                let node_1_privkey = SecretKey::from_slice(&[42; 32]).unwrap();
@@@ -1351,7 -1358,7 +1358,7 @@@
                let node_1_btckey = SecretKey::from_slice(&[40; 32]).unwrap();
                let node_2_btckey = SecretKey::from_slice(&[39; 32]).unwrap();
                let unsigned_ann = msgs::UnsignedChannelAnnouncement {
-                       features: ChannelFeatures::supported(),
+                       features: ChannelFeatures::known(),
                        chain_hash: genesis_block(network).header.bitcoin_hash(),
                        short_channel_id: short_chan_id,
                        node_id_1: PublicKey::from_secret_key(&secp_ctx, &node_1_privkey),
@@@ -1371,7 -1378,7 +1378,7 @@@
        }
  
        fn get_dummy_channel_update(short_chan_id: u64) -> msgs::ChannelUpdate {
 -              use secp256k1::ffi::Signature as FFISignature;
 +              use bitcoin::secp256k1::ffi::Signature as FFISignature;
                let network = Network::Testnet;
                msgs::ChannelUpdate {
                        signature: Signature::from(FFISignature::new()),
@@@ -1421,4 -1428,47 +1428,47 @@@
                assert_eq!(routing_handlers_concrete[1].clone().chan_upds_recvd.load(Ordering::Acquire), 100);
                assert_eq!(routing_handlers_concrete[1].clone().chan_anns_recvd.load(Ordering::Acquire), 50);
        }
+ 
+       #[test]
+       fn limit_initial_routing_sync_requests() {
+               // Inbound peer 0 requests initial_routing_sync, but outbound peer 1 does not.
+               {
+                       let chan_handlers = create_chan_handlers(2);
+                       let routing_handlers: Vec<Arc<msgs::RoutingMessageHandler>> = vec![
+                               Arc::new(test_utils::TestRoutingMessageHandler::new().set_request_full_sync()),
+                               Arc::new(test_utils::TestRoutingMessageHandler::new()),
+                       ];
+                       let peers = create_network(2, &chan_handlers, Some(&routing_handlers));
+                       let (fd_0_to_1, fd_1_to_0) = establish_connection_and_read_events(&peers[0], &peers[1]);
+ 
+                       let peer_0 = peers[0].peers.lock().unwrap();
+                       let peer_1 = peers[1].peers.lock().unwrap();
+ 
+                       let peer_0_features = peer_1.peers.get(&fd_1_to_0).unwrap().their_features.as_ref();
+                       let peer_1_features = peer_0.peers.get(&fd_0_to_1).unwrap().their_features.as_ref();
+ 
+                       assert!(peer_0_features.unwrap().initial_routing_sync());
+                       assert!(!peer_1_features.unwrap().initial_routing_sync());
+               }
+ 
+               // Outbound peer 1 requests initial_routing_sync, but inbound peer 0 does not.
+               {
+                       let chan_handlers = create_chan_handlers(2);
+                       let routing_handlers: Vec<Arc<msgs::RoutingMessageHandler>> = vec![
+                               Arc::new(test_utils::TestRoutingMessageHandler::new()),
+                               Arc::new(test_utils::TestRoutingMessageHandler::new().set_request_full_sync()),
+                       ];
+                       let peers = create_network(2, &chan_handlers, Some(&routing_handlers));
+                       let (fd_0_to_1, fd_1_to_0) = establish_connection_and_read_events(&peers[0], &peers[1]);
+ 
+                       let peer_0 = peers[0].peers.lock().unwrap();
+                       let peer_1 = peers[1].peers.lock().unwrap();
+ 
+                       let peer_0_features = peer_1.peers.get(&fd_1_to_0).unwrap().their_features.as_ref();
+                       let peer_1_features = peer_0.peers.get(&fd_0_to_1).unwrap().their_features.as_ref();
+ 
+                       assert!(!peer_0_features.unwrap().initial_routing_sync());
+                       assert!(peer_1_features.unwrap().initial_routing_sync());
+               }
+       }
  }

diff --combined lightning/src/ln/router.rs
index b98569d3d1bfba18ba971b8ac942940b244ac5da,1eec7533b653b8ff7ef5cf3f986f64cb2e4044fd..037303d917cfa8a911ddc0cacbe8cb7ae583b819
--- 1/lightning/src/ln/router.rs
--- 2/lightning/src/ln/router.rs
+++ b/lightning/src/ln/router.rs
@@@ -3,13 -3,12 +3,13 @@@
  //! You probably want to create a Router and use that as your RoutingMessageHandler and then
  //! interrogate it to get routes for your own payments.
  
 -use secp256k1::key::PublicKey;
 -use secp256k1::Secp256k1;
 -use secp256k1;
 +use bitcoin::secp256k1::key::PublicKey;
 +use bitcoin::secp256k1::Secp256k1;
 +use bitcoin::secp256k1;
  
 -use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 -use bitcoin_hashes::Hash;
 +use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 +use bitcoin::hashes::Hash;
 +use bitcoin::hash_types::BlockHash;
  use bitcoin::blockdata::script::Builder;
  use bitcoin::blockdata::opcodes;
  
@@@ -330,19 -329,19 +330,19 @@@ impl std::fmt::Display for NetworkMap 
  impl NetworkMap {
        #[cfg(feature = "non_bitcoin_chain_hash_routing")]
        #[inline]
 -      fn get_key(short_channel_id: u64, chain_hash: Sha256dHash) -> (u64, Sha256dHash) {
 +      fn get_key(short_channel_id: u64, chain_hash: BlockHash) -> (u64, BlockHash) {
                (short_channel_id, chain_hash)
        }
  
        #[cfg(not(feature = "non_bitcoin_chain_hash_routing"))]
        #[inline]
 -      fn get_key(short_channel_id: u64, _: Sha256dHash) -> u64 {
 +      fn get_key(short_channel_id: u64, _: BlockHash) -> u64 {
                short_channel_id
        }
  
        #[cfg(feature = "non_bitcoin_chain_hash_routing")]
        #[inline]
 -      fn get_short_id(id: &(u64, Sha256dHash)) -> &u64 {
 +      fn get_short_id(id: &(u64, BlockHash)) -> &u64 {
                &id.0
        }
  
@@@ -894,9 -893,9 +894,9 @@@ impl Router 
                                        return Ok(Route {
                                                paths: vec![vec![RouteHop {
                                                        pubkey: chan.remote_network_id,
-                                                       node_features: NodeFeatures::with_known_relevant_init_flags(&chan.counterparty_features),
+                                                       node_features: chan.counterparty_features.to_context(),
                                                        short_channel_id,
-                                                       channel_features: ChannelFeatures::with_known_relevant_init_flags(&chan.counterparty_features),
+                                                       channel_features: chan.counterparty_features.to_context(),
                                                        fee_msat: final_value_msat,
                                                        cltv_expiry_delta: final_cltv,
                                                }]],
@@@ -973,7 -972,7 +973,7 @@@
                        ( $node: expr, $node_id: expr, $fee_to_target_msat: expr ) => {
                                if first_hops.is_some() {
                                        if let Some(&(ref first_hop, ref features)) = first_hop_targets.get(&$node_id) {
-                                               add_entry!(first_hop, $node_id, dummy_directional_info, ChannelFeatures::with_known_relevant_init_flags(&features), $fee_to_target_msat);
+                                               add_entry!(first_hop, $node_id, dummy_directional_info, features.to_context(), $fee_to_target_msat);
                                        }
                                }
  
@@@ -1017,7 -1016,7 +1017,7 @@@
                                                        // bit lazy here. In the future, we should pull them out via our
                                                        // ChannelManager, but there's no reason to waste the space until we
                                                        // need them.
-                                                       add_entry!(first_hop, hop.src_node_id, dummy_directional_info, ChannelFeatures::with_known_relevant_init_flags(&features), 0);
+                                                       add_entry!(first_hop, hop.src_node_id, dummy_directional_info, features.to_context(), 0);
                                                }
                                        }
                                        // BOLT 11 doesn't allow inclusion of features for the last hop hints, which
@@@ -1032,7 -1031,7 +1032,7 @@@
                                let mut res = vec!(dist.remove(&network.our_node_id).unwrap().3);
                                loop {
                                        if let Some(&(_, ref features)) = first_hop_targets.get(&res.last().unwrap().pubkey) {
-                                               res.last_mut().unwrap().node_features = NodeFeatures::with_known_relevant_init_flags(&features);
+                                               res.last_mut().unwrap().node_features = features.to_context();
                                        } else if let Some(node) = network.nodes.get(&res.last().unwrap().pubkey) {
                                                res.last_mut().unwrap().node_features = node.features.clone();
                                        } else {
@@@ -1086,9 -1085,8 +1086,9 @@@ mod tests 
        use util::logger::Logger;
        use util::ser::{Writeable, Readable};
  
 -      use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 -      use bitcoin_hashes::Hash;
 +      use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 +      use bitcoin::hashes::Hash;
 +      use bitcoin::hash_types::BlockHash;
        use bitcoin::network::constants::Network;
        use bitcoin::blockdata::constants::genesis_block;
        use bitcoin::blockdata::script::Builder;
@@@ -1097,9 -1095,9 +1097,9 @@@
  
        use hex;
  
 -      use secp256k1::key::{PublicKey,SecretKey};
 -      use secp256k1::All;
 -      use secp256k1::Secp256k1;
 +      use bitcoin::secp256k1::key::{PublicKey,SecretKey};
 +      use bitcoin::secp256k1::All;
 +      use bitcoin::secp256k1::Secp256k1;
  
        use std::sync::Arc;
        use std::collections::btree_map::Entry as BtreeEntry;
@@@ -1183,7 -1181,7 +1183,7 @@@
                let node7 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0808080808080808080808080808080808080808080808080808080808080808").unwrap()[..]).unwrap());
                let node8 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0909090909090909090909090909090909090909090909090909090909090909").unwrap()[..]).unwrap());
  
 -              let zero_hash = Sha256dHash::hash(&[0; 32]);
 +              let zero_hash = BlockHash::hash(&[0; 32]);
  
                macro_rules! id_to_feature_flags {
                        // Set the feature flags to the id'th odd (ie non-required) feature bit so that we can
@@@ -1541,8 -1539,8 +1541,8 @@@
  
                { // Disable channels 4 and 12 by requiring unknown feature bits
                        let mut network = router.network_map.write().unwrap();
-                       network.channels.get_mut(&NetworkMap::get_key(4, zero_hash.clone())).unwrap().features.set_require_unknown_bits();
-                       network.channels.get_mut(&NetworkMap::get_key(12, zero_hash.clone())).unwrap().features.set_require_unknown_bits();
+                       network.channels.get_mut(&NetworkMap::get_key(4, zero_hash.clone())).unwrap().features.set_required_unknown_bits();
+                       network.channels.get_mut(&NetworkMap::get_key(12, zero_hash.clone())).unwrap().features.set_required_unknown_bits();
                }
  
                { // If all the channels require some features we don't understand, route should fail
@@@ -1583,15 -1581,15 +1583,15 @@@
  
                { // Re-enable channels 4 and 12 by wiping the unknown feature bits
                        let mut network = router.network_map.write().unwrap();
-                       network.channels.get_mut(&NetworkMap::get_key(4, zero_hash.clone())).unwrap().features.clear_require_unknown_bits();
-                       network.channels.get_mut(&NetworkMap::get_key(12, zero_hash.clone())).unwrap().features.clear_require_unknown_bits();
+                       network.channels.get_mut(&NetworkMap::get_key(4, zero_hash.clone())).unwrap().features.clear_unknown_bits();
+                       network.channels.get_mut(&NetworkMap::get_key(12, zero_hash.clone())).unwrap().features.clear_unknown_bits();
                }
  
                { // Disable nodes 1, 2, and 8 by requiring unknown feature bits
                        let mut network = router.network_map.write().unwrap();
-                       network.nodes.get_mut(&node1).unwrap().features.set_require_unknown_bits();
-                       network.nodes.get_mut(&node2).unwrap().features.set_require_unknown_bits();
-                       network.nodes.get_mut(&node8).unwrap().features.set_require_unknown_bits();
+                       network.nodes.get_mut(&node1).unwrap().features.set_required_unknown_bits();
+                       network.nodes.get_mut(&node2).unwrap().features.set_required_unknown_bits();
+                       network.nodes.get_mut(&node8).unwrap().features.set_required_unknown_bits();
                }
  
                { // If all nodes require some features we don't understand, route should fail
@@@ -1632,9 -1630,9 +1632,9 @@@
  
                { // Re-enable nodes 1, 2, and 8
                        let mut network = router.network_map.write().unwrap();
-                       network.nodes.get_mut(&node1).unwrap().features.clear_require_unknown_bits();
-                       network.nodes.get_mut(&node2).unwrap().features.clear_require_unknown_bits();
-                       network.nodes.get_mut(&node8).unwrap().features.clear_require_unknown_bits();
+                       network.nodes.get_mut(&node1).unwrap().features.clear_unknown_bits();
+                       network.nodes.get_mut(&node2).unwrap().features.clear_unknown_bits();
+                       network.nodes.get_mut(&node8).unwrap().features.clear_unknown_bits();
                }
  
                // Note that we don't test disabling node 3 and failing to route to it, as we (somewhat
@@@ -1908,7 -1906,7 +1908,7 @@@
                let first_announcement_time = 500;
  
                let mut unsigned_announcement = UnsignedNodeAnnouncement {
-                       features: NodeFeatures::supported(),
+                       features: NodeFeatures::known(),
                        timestamp: first_announcement_time,
                        node_id: node_id_1,
                        rgb: [0; 3],
@@@ -1931,7 -1929,7 +1931,7 @@@
                {
                        // Announce a channel to add a corresponding node.
                        let unsigned_announcement = UnsignedChannelAnnouncement {
-                               features: ChannelFeatures::supported(),
+                               features: ChannelFeatures::known(),
                                chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
                                short_channel_id: 0,
                                node_id_1,
@@@ -2022,7 -2020,7 +2022,7 @@@
  
  
                let mut unsigned_announcement = UnsignedChannelAnnouncement {
-                       features: ChannelFeatures::supported(),
+                       features: ChannelFeatures::known(),
                        chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
                        short_channel_id: 0,
                        node_id_1,
@@@ -2593,7 -2591,7 +2593,7 @@@
  
                {
                        let mut unsigned_announcement = UnsignedNodeAnnouncement {
-                               features: NodeFeatures::supported(),
+                               features: NodeFeatures::known(),
                                timestamp: 1000,
                                node_id: node_id_1,
                                rgb: [0; 3],
@@@ -2635,7 -2633,7 +2635,7 @@@
                {
                        // Later announcement which should not be relayed (excess data) prevent us from sharing a node
                        let unsigned_announcement = UnsignedNodeAnnouncement {
-                               features: NodeFeatures::supported(),
+                               features: NodeFeatures::known(),
                                timestamp: 1010,
                                node_id: node_id_2,
                                rgb: [0; 3],

diff --combined lightning/src/util/test_utils.rs
index b436d0c13d9e93caadce620bf5d04bf25f576f2b,8385c39c1db081940bdbc373bf23d461cccc9e19..6a652aa6b39c0016c0ac3705cfcf9206733e04a8
--- 1/lightning/src/util/test_utils.rs
--- 2/lightning/src/util/test_utils.rs
+++ b/lightning/src/util/test_utils.rs
@@@ -16,10 -16,10 +16,10 @@@ use bitcoin::blockdata::transaction::Tr
  use bitcoin::blockdata::script::{Builder, Script};
  use bitcoin::blockdata::block::Block;
  use bitcoin::blockdata::opcodes;
 -use bitcoin_hashes::sha256d::Hash as Sha256dHash;
  use bitcoin::network::constants::Network;
 +use bitcoin::hash_types::{Txid, BlockHash};
  
 -use secp256k1::{SecretKey, PublicKey};
 +use bitcoin::secp256k1::{SecretKey, PublicKey};
  
  use std::time::{SystemTime, UNIX_EPOCH};
  use std::sync::{Arc,Mutex};
@@@ -72,7 -72,7 +72,7 @@@ impl<'a> channelmonitor::ManyChannelMon
                // to a watchtower and disk...
                let mut w = TestVecWriter(Vec::new());
                monitor.write_for_disk(&mut w).unwrap();
 -              let new_monitor = <(Sha256dHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::read(
 +              let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::read(
                                &mut ::std::io::Cursor::new(&w.0), Arc::new(TestLogger::new())).unwrap().1;
                assert!(new_monitor == monitor);
                self.latest_monitor_update_id.lock().unwrap().insert(funding_txo.to_channel_id(), (funding_txo, monitor.get_latest_update_id()));
@@@ -101,7 -101,7 +101,7 @@@
                let monitor = monitors.get(&funding_txo).unwrap();
                w.0.clear();
                monitor.write_for_disk(&mut w).unwrap();
 -              let new_monitor = <(Sha256dHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::read(
 +              let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::read(
                                &mut ::std::io::Cursor::new(&w.0), Arc::new(TestLogger::new())).unwrap().1;
                assert!(new_monitor == *monitor);
                self.added_monitors.lock().unwrap().push((funding_txo, new_monitor));
@@@ -170,11 -170,20 +170,20 @@@ impl events::MessageSendEventsProvider 
        }
  }
  
- pub struct TestRoutingMessageHandler {}
+ pub struct TestRoutingMessageHandler {
+       request_full_sync: bool,
+ }
  
  impl TestRoutingMessageHandler {
        pub fn new() -> Self {
-               TestRoutingMessageHandler {}
+               TestRoutingMessageHandler {
+                       request_full_sync: false,
+               }
+       }
+ 
+       pub fn set_request_full_sync(mut self) -> Self {
+               self.request_full_sync = true;
+               self
        }
  }
  impl msgs::RoutingMessageHandler for TestRoutingMessageHandler {
@@@ -195,7 -204,7 +204,7 @@@
                Vec::new()
        }
        fn should_request_full_sync(&self, _node_id: &PublicKey) -> bool {
-               true
+               self.request_full_sync
        }
  }
  
@@@ -288,15 -297,15 +297,15 @@@ impl TestChainWatcher 
  }
  
  impl ChainWatchInterface for TestChainWatcher {
 -      fn install_watch_tx(&self, _txid: &Sha256dHash, _script_pub_key: &Script) { }
 -      fn install_watch_outpoint(&self, _outpoint: (Sha256dHash, u32), _out_script: &Script) { }
 +      fn install_watch_tx(&self, _txid: &Txid, _script_pub_key: &Script) { }
 +      fn install_watch_outpoint(&self, _outpoint: (Txid, u32), _out_script: &Script) { }
        fn watch_all_txn(&self) { }
        fn filter_block<'a>(&self, _block: &'a Block) -> (Vec<&'a Transaction>, Vec<u32>) {
                (Vec::new(), Vec::new())
        }
        fn reentered(&self) -> usize { 0 }
  
 -      fn get_chain_utxo(&self, _genesis_hash: Sha256dHash, _unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError> {
 +      fn get_chain_utxo(&self, _genesis_hash: BlockHash, _unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError> {
                self.utxo_ret.lock().unwrap().clone()
        }
  }