From: Matt Corallo <649246+TheBlueMatt@users.noreply.github.com>
Date: Wed, 29 Apr 2020 18:49:39 +0000 (+0000)
Subject: Merge pull request #590 from jkczyz/2020-04-feature-flags
X-Git-Tag: v0.0.12~69
X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=9098240e341cf09578819cdf1d2950303478b137;hp=-c;p=rust-lightning

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

Features module improvements
---

9098240e341cf09578819cdf1d2950303478b137
diff --combined fuzz/src/chanmon_consistency.rs
index b28bbaa12,8603458e7..135249f74
--- a/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 adf53b0d5,739db729a..411c12d99
--- a/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 bef69235b,98e515f00..469698356
--- a/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 8d22b8893,f9b0f7046..08b28cc0f
--- a/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 3a440fb32,d7bdcc2d2..cfc29394f
--- a/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 fb506c475,de8014a6a..cce8c3d0b
--- a/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 b99f2f522,2dadf2ec6..51a546de6
--- a/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 b98569d3d,1eec7533b..037303d91
--- a/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 b436d0c13,8385c39c1..6a652aa6b
--- a/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()
  	}
  }