X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Ffunctional_test_utils.rs;h=219417d562f2cbd6a503510f9725594487e90c3d;hb=fecac81874c41724a855c9e696c312353609df23;hp=4a56ea412c6c321099dc58b4e58e03c6686fd0fe;hpb=9098240e341cf09578819cdf1d2950303478b137;p=rust-lightning

diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index 4a56ea41..a6d82cce 100644
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -1,26 +1,35 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
 //! A bunch of useful utilities for building networks of nodes and exchanging messages between
 //! nodes for functional tests.
 
-use chain::chaininterface;
+use chain::{BestBlock, Confirm, Listen, Watch};
+use chain::channelmonitor::ChannelMonitor;
 use chain::transaction::OutPoint;
-use chain::keysinterface::KeysInterface;
-use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSecret, PaymentSendFailure};
-use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor};
-use ln::router::{Route, Router, RouterReadArgs};
-use ln::features::InitFeatures;
+use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
+use ln::channelmanager::{ChainParameters, ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentSendFailure};
+use routing::router::{Route, get_route};
+use routing::network_graph::{NetGraphMsgHandler, NetworkGraph};
+use ln::features::{InitFeatures, InvoiceFeatures};
 use ln::msgs;
 use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
-use util::enforcing_trait_impls::EnforcingChannelKeys;
+use util::enforcing_trait_impls::EnforcingSigner;
 use util::test_utils;
-use util::test_utils::TestChannelMonitor;
-use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
+use util::test_utils::TestChainMonitor;
+use util::events::{Event, MessageSendEvent, MessageSendEventsProvider};
 use util::errors::APIError;
-use util::logger::Logger;
 use util::config::UserConfig;
-use util::ser::{ReadableArgs, Writeable};
+use util::ser::{ReadableArgs, Writeable, Readable};
 
-use bitcoin::util::hash::BitcoinHash;
-use bitcoin::blockdata::block::BlockHeader;
+use bitcoin::blockdata::block::{Block, BlockHeader};
+use bitcoin::blockdata::constants::genesis_block;
 use bitcoin::blockdata::transaction::{Transaction, TxOut};
 use bitcoin::network::constants::Network;
 
@@ -28,65 +37,193 @@ use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash;
 use bitcoin::hash_types::BlockHash;
 
-use bitcoin::secp256k1::Secp256k1;
 use bitcoin::secp256k1::key::PublicKey;
 
-use rand::{thread_rng,Rng};
-
-use std::cell::RefCell;
+use prelude::*;
+use core::cell::RefCell;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
-use std::mem;
-use std::collections::HashMap;
+use core::mem;
 
-pub const CHAN_CONFIRM_DEPTH: u32 = 100;
-pub fn confirm_transaction<'a, 'b: 'a>(notifier: &'a chaininterface::BlockNotifierRef<'b>, chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction, chan_id: u32) {
-	assert!(chain.does_match_tx(tx));
-	let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
-	notifier.block_connected_checked(&header, 1, &[tx; 1], &[chan_id; 1]);
-	for i in 2..CHAN_CONFIRM_DEPTH {
-		header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
-		notifier.block_connected_checked(&header, i, &vec![], &[0; 0]);
+pub const CHAN_CONFIRM_DEPTH: u32 = 10;
+
+/// Mine the given transaction in the next block and then mine CHAN_CONFIRM_DEPTH - 1 blocks on
+/// top, giving the given transaction CHAN_CONFIRM_DEPTH confirmations.
+pub fn confirm_transaction<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, tx: &Transaction) {
+	confirm_transaction_at(node, tx, node.best_block_info().1 + 1);
+	connect_blocks(node, CHAN_CONFIRM_DEPTH - 1);
+}
+/// Mine a signle block containing the given transaction
+pub fn mine_transaction<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, tx: &Transaction) {
+	let height = node.best_block_info().1 + 1;
+	confirm_transaction_at(node, tx, height);
+}
+/// Mine the given transaction at the given height, mining blocks as required to build to that
+/// height
+pub fn confirm_transaction_at<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, tx: &Transaction, conf_height: u32) {
+	let first_connect_height = node.best_block_info().1 + 1;
+	assert!(first_connect_height <= conf_height);
+	if conf_height > first_connect_height {
+		connect_blocks(node, conf_height - first_connect_height);
+	}
+	let mut block = Block {
+		header: BlockHeader { version: 0x20000000, prev_blockhash: node.best_block_hash(), merkle_root: Default::default(), time: conf_height, bits: 42, nonce: 42 },
+		txdata: Vec::new(),
+	};
+	for _ in 0..*node.network_chan_count.borrow() { // Make sure we don't end up with channels at the same short id by offsetting by chan_count
+		block.txdata.push(Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() });
 	}
+	block.txdata.push(tx.clone());
+	connect_block(node, &block);
 }
 
-pub fn connect_blocks<'a, 'b>(notifier: &'a chaininterface::BlockNotifierRef<'b>, depth: u32, height: u32, parent: bool, prev_blockhash: BlockHash) -> BlockHash {
-	let mut header = BlockHeader { version: 0x2000000, prev_blockhash: if parent { prev_blockhash } else { Default::default() }, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
-	notifier.block_connected_checked(&header, height + 1, &Vec::new(), &Vec::new());
-	for i in 2..depth + 1 {
-		header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
-		notifier.block_connected_checked(&header, height + i, &Vec::new(), &Vec::new());
+/// The possible ways we may notify a ChannelManager of a new block
+#[derive(Clone, Copy, PartialEq)]
+pub enum ConnectStyle {
+	/// Calls best_block_updated first, detecting transactions in the block only after receiving the
+	/// header and height information.
+	BestBlockFirst,
+	/// The same as BestBlockFirst, however when we have multiple blocks to connect, we only
+	/// make a single best_block_updated call.
+	BestBlockFirstSkippingBlocks,
+	/// Calls transactions_confirmed first, detecting transactions in the block before updating the
+	/// header and height information.
+	TransactionsFirst,
+	/// The same as TransactionsFirst, however when we have multiple blocks to connect, we only
+	/// make a single best_block_updated call.
+	TransactionsFirstSkippingBlocks,
+	/// Provides the full block via the chain::Listen interface. In the current code this is
+	/// equivalent to TransactionsFirst with some additional assertions.
+	FullBlockViaListen,
+}
+
+pub fn connect_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, depth: u32) -> BlockHash {
+	let skip_intermediaries = match *node.connect_style.borrow() {
+		ConnectStyle::BestBlockFirstSkippingBlocks|ConnectStyle::TransactionsFirstSkippingBlocks => true,
+		_ => false,
+	};
+
+	let height = node.best_block_info().1 + 1;
+	let mut block = Block {
+		header: BlockHeader { version: 0x2000000, prev_blockhash: node.best_block_hash(), merkle_root: Default::default(), time: height, bits: 42, nonce: 42 },
+		txdata: vec![],
+	};
+	assert!(depth >= 1);
+	for i in 1..depth {
+		do_connect_block(node, &block, skip_intermediaries);
+		block = Block {
+			header: BlockHeader { version: 0x20000000, prev_blockhash: block.header.block_hash(), merkle_root: Default::default(), time: height + i, bits: 42, nonce: 42 },
+			txdata: vec![],
+		};
+	}
+	connect_block(node, &block);
+	block.header.block_hash()
+}
+
+pub fn connect_block<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: &Block) {
+	do_connect_block(node, block, false);
+}
+
+fn do_connect_block<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: &Block, skip_intermediaries: bool) {
+	let height = node.best_block_info().1 + 1;
+	if !skip_intermediaries {
+		let txdata: Vec<_> = block.txdata.iter().enumerate().collect();
+		match *node.connect_style.borrow() {
+			ConnectStyle::BestBlockFirst|ConnectStyle::BestBlockFirstSkippingBlocks => {
+				node.chain_monitor.chain_monitor.best_block_updated(&block.header, height);
+				node.chain_monitor.chain_monitor.transactions_confirmed(&block.header, &txdata, height);
+				node.node.best_block_updated(&block.header, height);
+				node.node.transactions_confirmed(&block.header, &txdata, height);
+			},
+			ConnectStyle::TransactionsFirst|ConnectStyle::TransactionsFirstSkippingBlocks => {
+				node.chain_monitor.chain_monitor.transactions_confirmed(&block.header, &txdata, height);
+				node.chain_monitor.chain_monitor.best_block_updated(&block.header, height);
+				node.node.transactions_confirmed(&block.header, &txdata, height);
+				node.node.best_block_updated(&block.header, height);
+			},
+			ConnectStyle::FullBlockViaListen => {
+				node.chain_monitor.chain_monitor.block_connected(&block, height);
+				node.node.block_connected(&block, height);
+			}
+		}
+	}
+	node.node.test_process_background_events();
+	node.blocks.lock().unwrap().push((block.header, height));
+}
+
+pub fn disconnect_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, count: u32) {
+	for i in 0..count {
+		let orig_header = node.blocks.lock().unwrap().pop().unwrap();
+		assert!(orig_header.1 > 0); // Cannot disconnect genesis
+		let prev_header = node.blocks.lock().unwrap().last().unwrap().clone();
+
+		match *node.connect_style.borrow() {
+			ConnectStyle::FullBlockViaListen => {
+				node.chain_monitor.chain_monitor.block_disconnected(&orig_header.0, orig_header.1);
+				Listen::block_disconnected(node.node, &orig_header.0, orig_header.1);
+			},
+			ConnectStyle::BestBlockFirstSkippingBlocks|ConnectStyle::TransactionsFirstSkippingBlocks => {
+				if i == count - 1 {
+					node.chain_monitor.chain_monitor.best_block_updated(&prev_header.0, prev_header.1);
+					node.node.best_block_updated(&prev_header.0, prev_header.1);
+				}
+			},
+			_ => {
+				node.chain_monitor.chain_monitor.best_block_updated(&prev_header.0, prev_header.1);
+				node.node.best_block_updated(&prev_header.0, prev_header.1);
+			},
+		}
 	}
-	header.bitcoin_hash()
+}
+
+pub fn disconnect_all_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>) {
+	let count = node.blocks.lock().unwrap().len() as u32 - 1;
+	disconnect_blocks(node, count);
 }
 
 pub struct TestChanMonCfg {
 	pub tx_broadcaster: test_utils::TestBroadcaster,
 	pub fee_estimator: test_utils::TestFeeEstimator,
+	pub chain_source: test_utils::TestChainSource,
+	pub persister: test_utils::TestPersister,
+	pub logger: test_utils::TestLogger,
+	pub keys_manager: test_utils::TestKeysInterface,
 }
 
 pub struct NodeCfg<'a> {
-	pub chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
+	pub chain_source: &'a test_utils::TestChainSource,
 	pub tx_broadcaster: &'a test_utils::TestBroadcaster,
 	pub fee_estimator: &'a test_utils::TestFeeEstimator,
-	pub chan_monitor: test_utils::TestChannelMonitor<'a>,
-	pub keys_manager: test_utils::TestKeysInterface,
-	pub logger: Arc<test_utils::TestLogger>,
+	pub chain_monitor: test_utils::TestChainMonitor<'a>,
+	pub keys_manager: &'a test_utils::TestKeysInterface,
+	pub logger: &'a test_utils::TestLogger,
 	pub node_seed: [u8; 32],
 }
 
 pub struct Node<'a, 'b: 'a, 'c: 'b> {
-	pub block_notifier: chaininterface::BlockNotifierRef<'a>,
-	pub chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
+	pub chain_source: &'c test_utils::TestChainSource,
 	pub tx_broadcaster: &'c test_utils::TestBroadcaster,
-	pub chan_monitor: &'b test_utils::TestChannelMonitor<'c>,
+	pub chain_monitor: &'b test_utils::TestChainMonitor<'c>,
 	pub keys_manager: &'b test_utils::TestKeysInterface,
-	pub node: &'a ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator>,
-	pub router: Router,
+	pub node: &'a ChannelManager<EnforcingSigner, &'b TestChainMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestLogger>,
+	pub net_graph_msg_handler: NetGraphMsgHandler<&'c test_utils::TestChainSource, &'c test_utils::TestLogger>,
 	pub node_seed: [u8; 32],
 	pub network_payment_count: Rc<RefCell<u8>>,
 	pub network_chan_count: Rc<RefCell<u32>>,
-	pub logger: Arc<test_utils::TestLogger>
+	pub logger: &'c test_utils::TestLogger,
+	pub blocks: Arc<Mutex<Vec<(BlockHeader, u32)>>>,
+	pub connect_style: Rc<RefCell<ConnectStyle>>,
+}
+impl<'a, 'b, 'c> Node<'a, 'b, 'c> {
+	pub fn best_block_hash(&self) -> BlockHash {
+		self.blocks.lock().unwrap().last().unwrap().0.block_hash()
+	}
+	pub fn best_block_info(&self) -> (BlockHash, u32) {
+		self.blocks.lock().unwrap().last().map(|(a, b)| (a.block_hash(), *b)).unwrap()
+	}
+	pub fn get_block_header(&self, height: u32) -> BlockHeader {
+		self.blocks.lock().unwrap()[height as usize].0
+	}
 }
 
 impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
@@ -95,20 +232,22 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 			// Check that we processed all pending events
 			assert!(self.node.get_and_clear_pending_msg_events().is_empty());
 			assert!(self.node.get_and_clear_pending_events().is_empty());
-			assert!(self.chan_monitor.added_monitors.lock().unwrap().is_empty());
+			assert!(self.chain_monitor.added_monitors.lock().unwrap().is_empty());
 
 			// Check that if we serialize the Router, we can deserialize it again.
 			{
 				let mut w = test_utils::TestVecWriter(Vec::new());
-				self.router.write(&mut w).unwrap();
-				let deserialized_router = Router::read(&mut ::std::io::Cursor::new(&w.0), RouterReadArgs {
-					chain_monitor: Arc::clone(&self.chain_monitor) as Arc<chaininterface::ChainWatchInterface>,
-					logger: Arc::clone(&self.logger) as Arc<Logger>
-				}).unwrap();
+				let network_graph_ser = self.net_graph_msg_handler.network_graph.read().unwrap();
+				network_graph_ser.write(&mut w).unwrap();
+				let network_graph_deser = <NetworkGraph>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap();
+				assert!(network_graph_deser == *self.net_graph_msg_handler.network_graph.read().unwrap());
+				let net_graph_msg_handler = NetGraphMsgHandler::from_net_graph(
+					Some(self.chain_source), self.logger, network_graph_deser
+				);
 				let mut chan_progress = 0;
 				loop {
-					let orig_announcements = self.router.get_next_channel_announcements(chan_progress, 255);
-					let deserialized_announcements = deserialized_router.get_next_channel_announcements(chan_progress, 255);
+					let orig_announcements = self.net_graph_msg_handler.get_next_channel_announcements(chan_progress, 255);
+					let deserialized_announcements = net_graph_msg_handler.get_next_channel_announcements(chan_progress, 255);
 					assert!(orig_announcements == deserialized_announcements);
 					chan_progress = match orig_announcements.last() {
 						Some(announcement) => announcement.0.contents.short_channel_id + 1,
@@ -117,8 +256,8 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 				}
 				let mut node_progress = None;
 				loop {
-					let orig_announcements = self.router.get_next_node_announcements(node_progress.as_ref(), 255);
-					let deserialized_announcements = deserialized_router.get_next_node_announcements(node_progress.as_ref(), 255);
+					let orig_announcements = self.net_graph_msg_handler.get_next_node_announcements(node_progress.as_ref(), 255);
+					let deserialized_announcements = net_graph_msg_handler.get_next_node_announcements(node_progress.as_ref(), 255);
 					assert!(orig_announcements == deserialized_announcements);
 					node_progress = match orig_announcements.last() {
 						Some(announcement) => Some(announcement.contents.node_id),
@@ -133,12 +272,12 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 			let feeest = test_utils::TestFeeEstimator { sat_per_kw: 253 };
 			let mut deserialized_monitors = Vec::new();
 			{
-				let old_monitors = self.chan_monitor.simple_monitor.monitors.lock().unwrap();
+				let old_monitors = self.chain_monitor.chain_monitor.monitors.read().unwrap();
 				for (_, old_monitor) in old_monitors.iter() {
 					let mut w = test_utils::TestVecWriter(Vec::new());
-					old_monitor.write_for_disk(&mut w).unwrap();
-					let (_, deserialized_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(
-						&mut ::std::io::Cursor::new(&w.0), Arc::clone(&self.logger) as Arc<Logger>).unwrap();
+					old_monitor.write(&mut w).unwrap();
+					let (_, deserialized_monitor) = <(BlockHash, ChannelMonitor<EnforcingSigner>)>::read(
+						&mut ::std::io::Cursor::new(&w.0), self.keys_manager).unwrap();
 					deserialized_monitors.push(deserialized_monitor);
 				}
 			}
@@ -148,32 +287,39 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 			{
 				let mut channel_monitors = HashMap::new();
 				for monitor in deserialized_monitors.iter_mut() {
-					channel_monitors.insert(monitor.get_funding_txo(), monitor);
+					channel_monitors.insert(monitor.get_funding_txo().0, monitor);
 				}
 
 				let mut w = test_utils::TestVecWriter(Vec::new());
 				self.node.write(&mut w).unwrap();
-				<(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut ::std::io::Cursor::new(w.0), ChannelManagerReadArgs {
-					default_config: UserConfig::default(),
+				<(BlockHash, ChannelManager<EnforcingSigner, &test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut ::std::io::Cursor::new(w.0), ChannelManagerReadArgs {
+					default_config: *self.node.get_current_default_configuration(),
 					keys_manager: self.keys_manager,
 					fee_estimator: &test_utils::TestFeeEstimator { sat_per_kw: 253 },
-					monitor: self.chan_monitor,
-					tx_broadcaster: self.tx_broadcaster.clone(),
-					logger: Arc::new(test_utils::TestLogger::new()),
-					channel_monitors: &mut channel_monitors,
+					chain_monitor: self.chain_monitor,
+					tx_broadcaster: &test_utils::TestBroadcaster {
+						txn_broadcasted: Mutex::new(self.tx_broadcaster.txn_broadcasted.lock().unwrap().clone()),
+						blocks: Arc::new(Mutex::new(self.tx_broadcaster.blocks.lock().unwrap().clone())),
+					},
+					logger: &test_utils::TestLogger::new(),
+					channel_monitors,
 				}).unwrap();
 			}
 
-			let chain_watch = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&self.logger) as Arc<Logger>));
-			let channel_monitor = test_utils::TestChannelMonitor::new(chain_watch.clone(), self.tx_broadcaster.clone(), self.logger.clone(), &feeest);
+			let persister = test_utils::TestPersister::new();
+			let broadcaster = test_utils::TestBroadcaster {
+				txn_broadcasted: Mutex::new(self.tx_broadcaster.txn_broadcasted.lock().unwrap().clone()),
+				blocks: Arc::new(Mutex::new(self.tx_broadcaster.blocks.lock().unwrap().clone())),
+			};
+			let chain_source = test_utils::TestChainSource::new(Network::Testnet);
+			let chain_monitor = test_utils::TestChainMonitor::new(Some(&chain_source), &broadcaster, &self.logger, &feeest, &persister, &self.keys_manager);
 			for deserialized_monitor in deserialized_monitors.drain(..) {
-				if let Err(_) = channel_monitor.add_monitor(deserialized_monitor.get_funding_txo(), deserialized_monitor) {
+				if let Err(_) = chain_monitor.watch_channel(deserialized_monitor.get_funding_txo().0, deserialized_monitor) {
 					panic!();
 				}
 			}
-			if *chain_watch != *self.chain_monitor {
-				panic!();
-			}
+			assert_eq!(*chain_source.watched_txn.lock().unwrap(), *self.chain_source.watched_txn.lock().unwrap());
+			assert_eq!(*chain_source.watched_outputs.lock().unwrap(), *self.chain_source.watched_outputs.lock().unwrap());
 		}
 	}
 }
@@ -215,6 +361,8 @@ macro_rules! get_revoke_commit_msgs {
 	}
 }
 
+/// Get an specific event message from the pending events queue.
+#[macro_export]
 macro_rules! get_event_msg {
 	($node: expr, $event_type: path, $node_id: expr) => {
 		{
@@ -231,6 +379,25 @@ macro_rules! get_event_msg {
 	}
 }
 
+/// Get a specific event from the pending events queue.
+#[macro_export]
+macro_rules! get_event {
+	($node: expr, $event_type: path) => {
+		{
+			let mut events = $node.node.get_and_clear_pending_events();
+			assert_eq!(events.len(), 1);
+			let ev = events.pop().unwrap();
+			match ev {
+				$event_type { .. } => {
+					ev
+				},
+				_ => panic!("Unexpected event"),
+			}
+		}
+	}
+}
+
+#[cfg(test)]
 macro_rules! get_htlc_update_msgs {
 	($node: expr, $node_id: expr) => {
 		{
@@ -247,6 +414,7 @@ macro_rules! get_htlc_update_msgs {
 	}
 }
 
+#[cfg(test)]
 macro_rules! get_feerate {
 	($node: expr, $channel_id: expr) => {
 		{
@@ -257,14 +425,16 @@ macro_rules! get_feerate {
 	}
 }
 
+/// Returns any local commitment transactions for the channel.
+#[macro_export]
 macro_rules! get_local_commitment_txn {
 	($node: expr, $channel_id: expr) => {
 		{
-			let mut monitors = $node.chan_monitor.simple_monitor.monitors.lock().unwrap();
+			let monitors = $node.chain_monitor.chain_monitor.monitors.read().unwrap();
 			let mut commitment_txn = None;
-			for (funding_txo, monitor) in monitors.iter_mut() {
+			for (funding_txo, monitor) in monitors.iter() {
 				if funding_txo.to_channel_id() == $channel_id {
-					commitment_txn = Some(monitor.unsafe_get_latest_local_commitment_txn());
+					commitment_txn = Some(monitor.unsafe_get_latest_holder_commitment_txn(&$node.logger));
 					break;
 				}
 			}
@@ -273,6 +443,8 @@ macro_rules! get_local_commitment_txn {
 	}
 }
 
+/// Check the error from attempting a payment.
+#[macro_export]
 macro_rules! unwrap_send_err {
 	($res: expr, $all_failed: expr, $type: pat, $check: expr) => {
 		match &$res {
@@ -295,10 +467,12 @@ macro_rules! unwrap_send_err {
 	}
 }
 
+/// Check whether N channel monitor(s) have been added.
+#[macro_export]
 macro_rules! check_added_monitors {
 	($node: expr, $count: expr) => {
 		{
-			let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap();
+			let mut added_monitors = $node.chain_monitor.added_monitors.lock().unwrap();
 			assert_eq!(added_monitors.len(), $count);
 			added_monitors.clear();
 		}
@@ -315,10 +489,10 @@ pub fn create_funding_transaction<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, expected_
 			assert_eq!(*channel_value_satoshis, expected_chan_value);
 			assert_eq!(user_channel_id, expected_user_chan_id);
 
-			let tx = Transaction { version: chan_id as u32, lock_time: 0, input: Vec::new(), output: vec![TxOut {
+			let tx = Transaction { version: chan_id as i32, lock_time: 0, input: Vec::new(), output: vec![TxOut {
 				value: *channel_value_satoshis, script_pubkey: output_script.clone(),
 			}]};
-			let funding_outpoint = OutPoint::new(tx.txid(), 0);
+			let funding_outpoint = OutPoint { txid: tx.txid(), index: 0 };
 			(*temporary_channel_id, tx, funding_outpoint)
 		},
 		_ => panic!("Unexpected event"),
@@ -332,12 +506,12 @@ pub fn create_chan_between_nodes_with_value_init<'a, 'b, 'c>(node_a: &Node<'a, '
 
 	let (temporary_channel_id, tx, funding_output) = create_funding_transaction(node_a, channel_value, 42);
 
-	node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output);
+	node_a.node.funding_transaction_generated(&temporary_channel_id, tx.clone()).unwrap();
 	check_added_monitors!(node_a, 0);
 
 	node_b.node.handle_funding_created(&node_a.node.get_our_node_id(), &get_event_msg!(node_a, MessageSendEvent::SendFundingCreated, node_b.node.get_our_node_id()));
 	{
-		let mut added_monitors = node_b.chan_monitor.added_monitors.lock().unwrap();
+		let mut added_monitors = node_b.chain_monitor.added_monitors.lock().unwrap();
 		assert_eq!(added_monitors.len(), 1);
 		assert_eq!(added_monitors[0].0, funding_output);
 		added_monitors.clear();
@@ -345,27 +519,25 @@ pub fn create_chan_between_nodes_with_value_init<'a, 'b, 'c>(node_a: &Node<'a, '
 
 	node_a.node.handle_funding_signed(&node_b.node.get_our_node_id(), &get_event_msg!(node_b, MessageSendEvent::SendFundingSigned, node_a.node.get_our_node_id()));
 	{
-		let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap();
+		let mut added_monitors = node_a.chain_monitor.added_monitors.lock().unwrap();
 		assert_eq!(added_monitors.len(), 1);
 		assert_eq!(added_monitors[0].0, funding_output);
 		added_monitors.clear();
 	}
 
 	let events_4 = node_a.node.get_and_clear_pending_events();
-	assert_eq!(events_4.len(), 1);
-	match events_4[0] {
-		Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
-			assert_eq!(user_channel_id, 42);
-			assert_eq!(*funding_txo, funding_output);
-		},
-		_ => panic!("Unexpected event"),
-	};
+	assert_eq!(events_4.len(), 0);
+
+	assert_eq!(node_a.tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
+	assert_eq!(node_a.tx_broadcaster.txn_broadcasted.lock().unwrap()[0], tx);
+	node_a.tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 
 	tx
 }
 
-pub fn create_chan_between_nodes_with_value_confirm_first<'a, 'b, 'c, 'd>(node_recv: &'a Node<'b, 'c, 'c>, node_conf: &'a Node<'b, 'c, 'd>, tx: &Transaction) {
-	confirm_transaction(&node_conf.block_notifier, &node_conf.chain_monitor, &tx, tx.version);
+pub fn create_chan_between_nodes_with_value_confirm_first<'a, 'b, 'c, 'd>(node_recv: &'a Node<'b, 'c, 'c>, node_conf: &'a Node<'b, 'c, 'd>, tx: &Transaction, conf_height: u32) {
+	confirm_transaction_at(node_conf, tx, conf_height);
+	connect_blocks(node_conf, CHAN_CONFIRM_DEPTH - 1);
 	node_recv.node.handle_funding_locked(&node_conf.node.get_our_node_id(), &get_event_msg!(node_conf, MessageSendEvent::SendFundingLocked, node_recv.node.get_our_node_id()));
 }
 
@@ -390,8 +562,10 @@ pub fn create_chan_between_nodes_with_value_confirm_second<'a, 'b, 'c>(node_recv
 }
 
 pub fn create_chan_between_nodes_with_value_confirm<'a, 'b, 'c, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, tx: &Transaction) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32]) {
-	create_chan_between_nodes_with_value_confirm_first(node_a, node_b, tx);
-	confirm_transaction(&node_a.block_notifier, &node_a.chain_monitor, &tx, tx.version);
+	let conf_height = core::cmp::max(node_a.best_block_info().1 + 1, node_b.best_block_info().1 + 1);
+	create_chan_between_nodes_with_value_confirm_first(node_a, node_b, tx, conf_height);
+	confirm_transaction_at(node_a, tx, conf_height);
+	connect_blocks(node_a, CHAN_CONFIRM_DEPTH - 1);
 	create_chan_between_nodes_with_value_confirm_second(node_b, node_a)
 }
 
@@ -439,11 +613,29 @@ pub fn create_announced_chan_between_nodes<'a, 'b, 'c, 'd>(nodes: &'a Vec<Node<'
 
 pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a Vec<Node<'b, 'c, 'd>>, a: usize, b: usize, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
 	let chan_announcement = create_chan_between_nodes_with_value(&nodes[a], &nodes[b], channel_value, push_msat, a_flags, b_flags);
+	update_nodes_with_chan_announce(nodes, a, b, &chan_announcement.0, &chan_announcement.1, &chan_announcement.2);
+	(chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4)
+}
 
+pub fn update_nodes_with_chan_announce<'a, 'b, 'c, 'd>(nodes: &'a Vec<Node<'b, 'c, 'd>>, a: usize, b: usize, ann: &msgs::ChannelAnnouncement, upd_1: &msgs::ChannelUpdate, upd_2: &msgs::ChannelUpdate) {
 	nodes[a].node.broadcast_node_announcement([0, 0, 0], [0; 32], Vec::new());
 	let a_events = nodes[a].node.get_and_clear_pending_msg_events();
-	assert_eq!(a_events.len(), 1);
-	let a_node_announcement = match a_events[0] {
+	assert!(a_events.len() >= 2);
+
+	// ann should be re-generated by broadcast_node_announcement - check that we have it.
+	let mut found_ann_1 = false;
+	for event in a_events.iter() {
+		match event {
+			MessageSendEvent::BroadcastChannelAnnouncement { ref msg, .. } => {
+				if msg == ann { found_ann_1 = true; }
+			},
+			MessageSendEvent::BroadcastNodeAnnouncement { .. } => {},
+			_ => panic!("Unexpected event {:?}", event),
+		}
+	}
+	assert!(found_ann_1);
+
+	let a_node_announcement = match a_events.last().unwrap() {
 		MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => {
 			(*msg).clone()
 		},
@@ -452,8 +644,22 @@ pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a
 
 	nodes[b].node.broadcast_node_announcement([1, 1, 1], [1; 32], Vec::new());
 	let b_events = nodes[b].node.get_and_clear_pending_msg_events();
-	assert_eq!(b_events.len(), 1);
-	let b_node_announcement = match b_events[0] {
+	assert!(b_events.len() >= 2);
+
+	// ann should be re-generated by broadcast_node_announcement - check that we have it.
+	let mut found_ann_2 = false;
+	for event in b_events.iter() {
+		match event {
+			MessageSendEvent::BroadcastChannelAnnouncement { ref msg, .. } => {
+				if msg == ann { found_ann_2 = true; }
+			},
+			MessageSendEvent::BroadcastNodeAnnouncement { .. } => {},
+			_ => panic!("Unexpected event"),
+		}
+	}
+	assert!(found_ann_2);
+
+	let b_node_announcement = match b_events.last().unwrap() {
 		MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => {
 			(*msg).clone()
 		},
@@ -461,26 +667,37 @@ pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a
 	};
 
 	for node in nodes {
-		assert!(node.router.handle_channel_announcement(&chan_announcement.0).unwrap());
-		node.router.handle_channel_update(&chan_announcement.1).unwrap();
-		node.router.handle_channel_update(&chan_announcement.2).unwrap();
-		node.router.handle_node_announcement(&a_node_announcement).unwrap();
-		node.router.handle_node_announcement(&b_node_announcement).unwrap();
+		assert!(node.net_graph_msg_handler.handle_channel_announcement(ann).unwrap());
+		node.net_graph_msg_handler.handle_channel_update(upd_1).unwrap();
+		node.net_graph_msg_handler.handle_channel_update(upd_2).unwrap();
+		node.net_graph_msg_handler.handle_node_announcement(&a_node_announcement).unwrap();
+		node.net_graph_msg_handler.handle_node_announcement(&b_node_announcement).unwrap();
 	}
-	(chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4)
 }
 
 macro_rules! check_spends {
 	($tx: expr, $($spends_txn: expr),*) => {
 		{
-			$tx.verify(|out_point| {
+			let get_output = |out_point: &bitcoin::blockdata::transaction::OutPoint| {
 				$(
 					if out_point.txid == $spends_txn.txid() {
 						return $spends_txn.output.get(out_point.vout as usize).cloned()
 					}
 				)*
 				None
-			}).unwrap();
+			};
+			let mut total_value_in = 0;
+			for input in $tx.input.iter() {
+				total_value_in += get_output(&input.previous_output).unwrap().value;
+			}
+			let mut total_value_out = 0;
+			for output in $tx.output.iter() {
+				total_value_out += output.value;
+			}
+			let min_fee = ($tx.get_weight() as u64 + 3) / 4; // One sat per vbyte (ie per weight/4, rounded up)
+			// Input amount - output amount = fee, so check that out + min_fee is smaller than input
+			assert!(total_value_out + min_fee <= total_value_in);
+			$tx.verify(get_output).unwrap();
 		}
 	}
 }
@@ -509,6 +726,9 @@ macro_rules! get_closing_signed_broadcast {
 	}
 }
 
+/// Check that a channel's closing channel update has been broadcasted, and optionally
+/// check whether an error message event has occurred.
+#[macro_export]
 macro_rules! check_closed_broadcast {
 	($node: expr, $with_error_msg: expr) => {{
 		let events = $node.node.get_and_clear_pending_msg_events();
@@ -537,7 +757,7 @@ pub fn close_channel<'a, 'b, 'c>(outbound_node: &Node<'a, 'b, 'c>, inbound_node:
 	let (tx_a, tx_b);
 
 	node_a.close_channel(channel_id).unwrap();
-	node_b.handle_shutdown(&node_a.get_our_node_id(), &get_event_msg!(struct_a, MessageSendEvent::SendShutdown, node_b.get_our_node_id()));
+	node_b.handle_shutdown(&node_a.get_our_node_id(), &InitFeatures::known(), &get_event_msg!(struct_a, MessageSendEvent::SendShutdown, node_b.get_our_node_id()));
 
 	let events_1 = node_b.get_and_clear_pending_msg_events();
 	assert!(events_1.len() >= 1);
@@ -562,7 +782,7 @@ pub fn close_channel<'a, 'b, 'c>(outbound_node: &Node<'a, 'b, 'c>, inbound_node:
 		})
 	};
 
-	node_a.handle_shutdown(&node_b.get_our_node_id(), &shutdown_b);
+	node_a.handle_shutdown(&node_b.get_our_node_id(), &InitFeatures::known(), &shutdown_b);
 	let (as_update, bs_update) = if close_inbound_first {
 		assert!(node_a.get_and_clear_pending_msg_events().is_empty());
 		node_a.handle_closing_signed(&node_b.get_our_node_id(), &closing_signed_b.unwrap());
@@ -706,17 +926,32 @@ macro_rules! commitment_signed_dance {
 	}
 }
 
+/// Get a payment preimage and hash.
+#[macro_export]
 macro_rules! get_payment_preimage_hash {
-	($node: expr) => {
+	($dest_node: expr) => {
 		{
-			let payment_preimage = PaymentPreimage([*$node.network_payment_count.borrow(); 32]);
-			*$node.network_payment_count.borrow_mut() += 1;
+			let payment_preimage = PaymentPreimage([*$dest_node.network_payment_count.borrow(); 32]);
+			*$dest_node.network_payment_count.borrow_mut() += 1;
 			let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner());
-			(payment_preimage, payment_hash)
+			let payment_secret = $dest_node.node.create_inbound_payment_for_hash(payment_hash, None, 7200, 0).unwrap();
+			(payment_preimage, payment_hash, payment_secret)
 		}
 	}
 }
 
+#[cfg(test)]
+macro_rules! get_route_and_payment_hash {
+	($send_node: expr, $recv_node: expr, $recv_value: expr) => {{
+		let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash!($recv_node);
+		let net_graph_msg_handler = &$send_node.net_graph_msg_handler;
+		let route = get_route(&$send_node.node.get_our_node_id(),
+			&net_graph_msg_handler.network_graph.read().unwrap(),
+			&$recv_node.node.get_our_node_id(), None, None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, $send_node.logger).unwrap();
+		(route, payment_hash, payment_preimage, payment_secret)
+	}}
+}
+
 macro_rules! expect_pending_htlcs_forwardable_ignore {
 	($node: expr) => {{
 		let events = $node.node.get_and_clear_pending_events();
@@ -735,14 +970,16 @@ macro_rules! expect_pending_htlcs_forwardable {
 	}}
 }
 
+#[cfg(any(test, feature = "unstable"))]
 macro_rules! expect_payment_received {
-	($node: expr, $expected_payment_hash: expr, $expected_recv_value: expr) => {
+	($node: expr, $expected_payment_hash: expr, $expected_payment_secret: expr, $expected_recv_value: expr) => {
 		let events = $node.node.get_and_clear_pending_events();
 		assert_eq!(events.len(), 1);
 		match events[0] {
-			Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
+			Event::PaymentReceived { ref payment_hash, ref payment_preimage, ref payment_secret, amt, user_payment_id: _ } => {
 				assert_eq!($expected_payment_hash, *payment_hash);
-				assert_eq!(None, *payment_secret);
+				assert!(payment_preimage.is_none());
+				assert_eq!($expected_payment_secret, *payment_secret);
 				assert_eq!($expected_recv_value, amt);
 			},
 			_ => panic!("Unexpected event"),
@@ -763,19 +1000,44 @@ macro_rules! expect_payment_sent {
 	}
 }
 
+#[cfg(test)]
+macro_rules! expect_payment_failure_chan_update {
+	($node: expr, $scid: expr, $chan_closed: expr) => {
+		let events = $node.node.get_and_clear_pending_msg_events();
+		assert_eq!(events.len(), 1);
+		match events[0] {
+			MessageSendEvent::PaymentFailureNetworkUpdate { ref update } => {
+				match update {
+					&HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg } if !$chan_closed => {
+						assert_eq!(msg.contents.short_channel_id, $scid);
+						assert_eq!(msg.contents.flags & 2, 0);
+					},
+					&HTLCFailChannelUpdate::ChannelClosed { short_channel_id, is_permanent } if $chan_closed => {
+						assert_eq!(short_channel_id, $scid);
+						assert!(is_permanent);
+					},
+					_ => panic!("Unexpected update type"),
+				}
+			},
+			_ => panic!("Unexpected event"),
+		}
+	}
+}
+
+#[cfg(test)]
 macro_rules! expect_payment_failed {
 	($node: expr, $expected_payment_hash: expr, $rejected_by_dest: expr $(, $expected_error_code: expr, $expected_error_data: expr)*) => {
 		let events = $node.node.get_and_clear_pending_events();
 		assert_eq!(events.len(), 1);
 		match events[0] {
 			Event::PaymentFailed { ref payment_hash, rejected_by_dest, ref error_code, ref error_data } => {
-				assert_eq!(*payment_hash, $expected_payment_hash);
-				assert_eq!(rejected_by_dest, $rejected_by_dest);
-				assert!(error_code.is_some());
-				assert!(error_data.is_some());
+				assert_eq!(*payment_hash, $expected_payment_hash, "unexpected payment_hash");
+				assert_eq!(rejected_by_dest, $rejected_by_dest, "unexpected rejected_by_dest value");
+				assert!(error_code.is_some(), "expected error_code.is_some() = true");
+				assert!(error_data.is_some(), "expected error_data.is_some() = true");
 				$(
-					assert_eq!(error_code.unwrap(), $expected_error_code);
-					assert_eq!(&error_data.as_ref().unwrap()[..], $expected_error_data);
+					assert_eq!(error_code.unwrap(), $expected_error_code, "unexpected error code");
+					assert_eq!(&error_data.as_ref().unwrap()[..], $expected_error_data, "unexpected error data");
 				)*
 			},
 			_ => panic!("Unexpected event"),
@@ -783,13 +1045,13 @@ macro_rules! expect_payment_failed {
 	}
 }
 
-pub fn send_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_paths: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option<PaymentSecret>) {
-	origin_node.node.send_payment(&route, our_payment_hash, &our_payment_secret).unwrap();
+pub fn send_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_paths: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: PaymentSecret) {
+	origin_node.node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
 	check_added_monitors!(origin_node, expected_paths.len());
 	pass_along_route(origin_node, expected_paths, recv_value, our_payment_hash, our_payment_secret);
 }
 
-pub fn pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path: &[&Node<'a, 'b, 'c>], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option<PaymentSecret>, ev: MessageSendEvent, payment_received_expected: bool) {
+pub fn pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path: &[&Node<'a, 'b, 'c>], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: PaymentSecret, ev: MessageSendEvent, payment_received_expected: bool) {
 	let mut payment_event = SendEvent::from_event(ev);
 	let mut prev_node = origin_node;
 
@@ -807,8 +1069,9 @@ pub fn pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path
 			if payment_received_expected {
 				assert_eq!(events_2.len(), 1);
 				match events_2[0] {
-					Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
+					Event::PaymentReceived { ref payment_hash, ref payment_preimage, ref payment_secret, amt, user_payment_id: _ } => {
 						assert_eq!(our_payment_hash, *payment_hash);
+						assert!(payment_preimage.is_none());
 						assert_eq!(our_payment_secret, *payment_secret);
 						assert_eq!(amt, recv_value);
 					},
@@ -829,7 +1092,7 @@ pub fn pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path
 	}
 }
 
-pub fn pass_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option<PaymentSecret>) {
+pub fn pass_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: PaymentSecret) {
 	let mut events = origin_node.node.get_and_clear_pending_msg_events();
 	assert_eq!(events.len(), expected_route.len());
 	for (path_idx, (ev, expected_path)) in events.drain(..).zip(expected_route.iter()).enumerate() {
@@ -840,21 +1103,17 @@ pub fn pass_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_rou
 	}
 }
 
-pub fn send_along_route_with_hash<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64, our_payment_hash: PaymentHash) {
-	send_along_route_with_secret(origin_node, route, &[expected_route], recv_value, our_payment_hash, None);
+pub fn send_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash, PaymentSecret) {
+	let (our_payment_preimage, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(expected_route.last().unwrap());
+	send_along_route_with_secret(origin_node, route, &[expected_route], recv_value, our_payment_hash, our_payment_secret);
+	(our_payment_preimage, our_payment_hash, our_payment_secret)
 }
 
-pub fn send_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash) {
-	let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(origin_node);
-	send_along_route_with_hash(origin_node, route, expected_route, recv_value, our_payment_hash);
-	(our_payment_preimage, our_payment_hash)
-}
-
-pub fn claim_payment_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_paths: &[&[&Node<'a, 'b, 'c>]], skip_last: bool, our_payment_preimage: PaymentPreimage, our_payment_secret: Option<PaymentSecret>, expected_amount: u64) {
+pub fn claim_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_paths: &[&[&Node<'a, 'b, 'c>]], skip_last: bool, our_payment_preimage: PaymentPreimage) {
 	for path in expected_paths.iter() {
 		assert_eq!(path.last().unwrap().node.get_our_node_id(), expected_paths[0].last().unwrap().node.get_our_node_id());
 	}
-	assert!(expected_paths[0].last().unwrap().node.claim_funds(our_payment_preimage, &our_payment_secret, expected_amount));
+	assert!(expected_paths[0].last().unwrap().node.claim_funds(our_payment_preimage));
 	check_added_monitors!(expected_paths[0].last().unwrap(), expected_paths.len());
 
 	macro_rules! msgs_from_ev {
@@ -938,18 +1197,16 @@ pub fn claim_payment_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a,
 	}
 }
 
-pub fn claim_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], skip_last: bool, our_payment_preimage: PaymentPreimage, expected_amount: u64) {
-	claim_payment_along_route_with_secret(origin_node, &[expected_route], skip_last, our_payment_preimage, None, expected_amount);
-}
-
-pub fn claim_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], our_payment_preimage: PaymentPreimage, expected_amount: u64) {
-	claim_payment_along_route(origin_node, expected_route, false, our_payment_preimage, expected_amount);
+pub fn claim_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], our_payment_preimage: PaymentPreimage) {
+	claim_payment_along_route(origin_node, &[expected_route], false, our_payment_preimage);
 }
 
-pub const TEST_FINAL_CLTV: u32 = 32;
+pub const TEST_FINAL_CLTV: u32 = 70;
 
-pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash) {
-	let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
+pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash, PaymentSecret) {
+	let net_graph_msg_handler = &origin_node.net_graph_msg_handler;
+	let logger = test_utils::TestLogger::new();
+	let route = get_route(&origin_node.node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &expected_route.last().unwrap().node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), recv_value, TEST_FINAL_CLTV, &logger).unwrap();
 	assert_eq!(route.paths.len(), 1);
 	assert_eq!(route.paths[0].len(), expected_route.len());
 	for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {
@@ -960,25 +1217,27 @@ pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route:
 }
 
 pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64)  {
-	let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
+	let logger = test_utils::TestLogger::new();
+	let net_graph_msg_handler = &origin_node.net_graph_msg_handler;
+	let route = get_route(&origin_node.node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &expected_route.last().unwrap().node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), recv_value, TEST_FINAL_CLTV, &logger).unwrap();
 	assert_eq!(route.paths.len(), 1);
 	assert_eq!(route.paths[0].len(), expected_route.len());
 	for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {
 		assert_eq!(hop.pubkey, node.node.get_our_node_id());
 	}
 
-	let (_, our_payment_hash) = get_payment_preimage_hash!(origin_node);
-	unwrap_send_err!(origin_node.node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err },
-		assert_eq!(err, "Cannot send value that would put us over the max HTLC value in flight our peer will accept"));
+	let (_, our_payment_hash, our_payment_preimage) = get_payment_preimage_hash!(expected_route.last().unwrap());
+	unwrap_send_err!(origin_node.node.send_payment(&route, our_payment_hash, &Some(our_payment_preimage)), true, APIError::ChannelUnavailable { ref err },
+		assert!(err.contains("Cannot send value that would put us over the max HTLC value in flight our peer will accept")));
 }
 
-pub fn send_payment<'a, 'b, 'c>(origin: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64, expected_value: u64)  {
+pub fn send_payment<'a, 'b, 'c>(origin: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64)  {
 	let our_payment_preimage = route_payment(&origin, expected_route, recv_value).0;
-	claim_payment(&origin, expected_route, our_payment_preimage, expected_value);
+	claim_payment(&origin, expected_route, our_payment_preimage);
 }
 
 pub fn fail_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], skip_last: bool, our_payment_hash: PaymentHash)  {
-	assert!(expected_route.last().unwrap().node.fail_htlc_backwards(&our_payment_hash, &None));
+	assert!(expected_route.last().unwrap().node.fail_htlc_backwards(&our_payment_hash));
 	expect_pending_htlcs_forwardable!(expected_route.last().unwrap());
 	check_added_monitors!(expected_route.last().unwrap(), 1);
 
@@ -1052,10 +1311,19 @@ pub fn fail_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route:
 
 pub fn create_chanmon_cfgs(node_count: usize) -> Vec<TestChanMonCfg> {
 	let mut chan_mon_cfgs = Vec::new();
-	for _ in 0..node_count {
-		let tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())};
+	for i in 0..node_count {
+		let tx_broadcaster = test_utils::TestBroadcaster {
+			txn_broadcasted: Mutex::new(Vec::new()),
+			blocks: Arc::new(Mutex::new(vec![(genesis_block(Network::Testnet).header, 0)])),
+		};
 		let fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
-		chan_mon_cfgs.push(TestChanMonCfg{ tx_broadcaster, fee_estimator });
+		let chain_source = test_utils::TestChainSource::new(Network::Testnet);
+		let logger = test_utils::TestLogger::with_id(format!("node {}", i));
+		let persister = test_utils::TestPersister::new();
+		let seed = [i as u8; 32];
+		let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
+
+		chan_mon_cfgs.push(TestChanMonCfg{ tx_broadcaster, fee_estimator, chain_source, logger, persister, keys_manager });
 	}
 
 	chan_mon_cfgs
@@ -1063,65 +1331,68 @@ pub fn create_chanmon_cfgs(node_count: usize) -> Vec<TestChanMonCfg> {
 
 pub fn create_node_cfgs<'a>(node_count: usize, chanmon_cfgs: &'a Vec<TestChanMonCfg>) -> Vec<NodeCfg<'a>> {
 	let mut nodes = Vec::new();
-	let mut rng = thread_rng();
 
 	for i in 0..node_count {
-		let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
-		let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, logger.clone() as Arc<Logger>));
-		let mut seed = [0; 32];
-		rng.fill_bytes(&mut seed);
-		let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet, logger.clone() as Arc<Logger>);
-		let chan_monitor = test_utils::TestChannelMonitor::new(chain_monitor.clone(), &chanmon_cfgs[i].tx_broadcaster, logger.clone(), &chanmon_cfgs[i].fee_estimator);
-		nodes.push(NodeCfg { chain_monitor, logger, tx_broadcaster: &chanmon_cfgs[i].tx_broadcaster, fee_estimator: &chanmon_cfgs[i].fee_estimator, chan_monitor, keys_manager, node_seed: seed });
+		let chain_monitor = test_utils::TestChainMonitor::new(Some(&chanmon_cfgs[i].chain_source), &chanmon_cfgs[i].tx_broadcaster, &chanmon_cfgs[i].logger, &chanmon_cfgs[i].fee_estimator, &chanmon_cfgs[i].persister, &chanmon_cfgs[i].keys_manager);
+		let seed = [i as u8; 32];
+		nodes.push(NodeCfg { chain_source: &chanmon_cfgs[i].chain_source, logger: &chanmon_cfgs[i].logger, tx_broadcaster: &chanmon_cfgs[i].tx_broadcaster, fee_estimator: &chanmon_cfgs[i].fee_estimator, chain_monitor, keys_manager: &chanmon_cfgs[i].keys_manager, node_seed: seed });
 	}
 
 	nodes
 }
 
-pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg<'b>>, node_config: &[Option<UserConfig>]) -> Vec<ChannelManager<EnforcingChannelKeys, &'a TestChannelMonitor<'b>, &'b test_utils::TestBroadcaster, &'a test_utils::TestKeysInterface, &'b test_utils::TestFeeEstimator>> {
+pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg<'b>>, node_config: &[Option<UserConfig>]) -> Vec<ChannelManager<EnforcingSigner, &'a TestChainMonitor<'b>, &'b test_utils::TestBroadcaster, &'a test_utils::TestKeysInterface, &'b test_utils::TestFeeEstimator, &'b test_utils::TestLogger>> {
 	let mut chanmgrs = Vec::new();
 	for i in 0..node_count {
 		let mut default_config = UserConfig::default();
+		// Set cltv_expiry_delta slightly lower to keep the final CLTV values inside one byte in our
+		// tests so that our script-length checks don't fail (see ACCEPTED_HTLC_SCRIPT_WEIGHT).
+		default_config.channel_options.cltv_expiry_delta = 6*6;
 		default_config.channel_options.announced_channel = true;
 		default_config.peer_channel_config_limits.force_announced_channel_preference = false;
 		default_config.own_channel_config.our_htlc_minimum_msat = 1000; // sanitization being done by the sender, to exerce receiver logic we need to lift of limit
-		let node = ChannelManager::new(Network::Testnet, cfgs[i].fee_estimator, &cfgs[i].chan_monitor, cfgs[i].tx_broadcaster, cfgs[i].logger.clone(), &cfgs[i].keys_manager, if node_config[i].is_some() { node_config[i].clone().unwrap() } else { default_config }, 0).unwrap();
+		let network = Network::Testnet;
+		let params = ChainParameters {
+			network,
+			best_block: BestBlock::from_genesis(network),
+		};
+		let node = ChannelManager::new(cfgs[i].fee_estimator, &cfgs[i].chain_monitor, cfgs[i].tx_broadcaster, cfgs[i].logger, cfgs[i].keys_manager, if node_config[i].is_some() { node_config[i].clone().unwrap() } else { default_config }, params);
 		chanmgrs.push(node);
 	}
 
 	chanmgrs
 }
 
-pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeCfg<'c>>, chan_mgrs: &'a Vec<ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator>>) -> Vec<Node<'a, 'b, 'c>> {
-	let secp_ctx = Secp256k1::new();
+pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeCfg<'c>>, chan_mgrs: &'a Vec<ChannelManager<EnforcingSigner, &'b TestChainMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestLogger>>) -> Vec<Node<'a, 'b, 'c>> {
 	let mut nodes = Vec::new();
 	let chan_count = Rc::new(RefCell::new(0));
 	let payment_count = Rc::new(RefCell::new(0));
+	let connect_style = Rc::new(RefCell::new(ConnectStyle::FullBlockViaListen));
 
 	for i in 0..node_count {
-		let block_notifier = chaininterface::BlockNotifier::new(cfgs[i].chain_monitor.clone());
-		block_notifier.register_listener(&cfgs[i].chan_monitor.simple_monitor as &chaininterface::ChainListener);
-		block_notifier.register_listener(&chan_mgrs[i] as &chaininterface::ChainListener);
-		let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &cfgs[i].keys_manager.get_node_secret()), cfgs[i].chain_monitor.clone(), cfgs[i].logger.clone() as Arc<Logger>);
-		nodes.push(Node{ chain_monitor: cfgs[i].chain_monitor.clone(), block_notifier,
-										 tx_broadcaster: cfgs[i].tx_broadcaster, chan_monitor: &cfgs[i].chan_monitor,
-										 keys_manager: &cfgs[i].keys_manager, node: &chan_mgrs[i], router,
-										 node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),
-										 network_payment_count: payment_count.clone(), logger: cfgs[i].logger.clone(),
+		let net_graph_msg_handler = NetGraphMsgHandler::new(cfgs[i].chain_source.genesis_hash, None, cfgs[i].logger);
+		nodes.push(Node{ chain_source: cfgs[i].chain_source,
+		                 tx_broadcaster: cfgs[i].tx_broadcaster, chain_monitor: &cfgs[i].chain_monitor,
+		                 keys_manager: &cfgs[i].keys_manager, node: &chan_mgrs[i], net_graph_msg_handler,
+		                 node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),
+		                 network_payment_count: payment_count.clone(), logger: cfgs[i].logger,
+		                 blocks: Arc::clone(&cfgs[i].tx_broadcaster.blocks),
+		                 connect_style: Rc::clone(&connect_style),
 		})
 	}
 
 	nodes
 }
 
-pub const ACCEPTED_HTLC_SCRIPT_WEIGHT: usize = 138; //Here we have a diff due to HTLC CLTV expiry being < 2^15 in test
+// Note that the following only works for CLTV values up to 128
+pub const ACCEPTED_HTLC_SCRIPT_WEIGHT: usize = 137; //Here we have a diff due to HTLC CLTV expiry being < 2^15 in test
 pub const OFFERED_HTLC_SCRIPT_WEIGHT: usize = 133;
 
 #[derive(PartialEq)]
 pub enum HTLCType { NONE, TIMEOUT, SUCCESS }
 /// Tests that the given node has broadcast transactions for the given Channel
 ///
-/// First checks that the latest local commitment tx has been broadcast, unless an explicit
+/// First checks that the latest holder commitment tx has been broadcast, unless an explicit
 /// commitment_tx is provided, which may be used to test that a remote commitment tx was
 /// broadcast and the revoked outputs were claimed.
 ///
@@ -1217,31 +1488,55 @@ pub fn check_preimage_claim<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, prev_txn: &Vec<
 	res
 }
 
-pub fn get_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec<Node<'a, 'b, 'c>>, a: usize, b: usize)  {
+pub fn handle_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec<Node<'a, 'b, 'c>>, a: usize, b: usize, needs_err_handle: bool, expected_error: &str)  {
 	let events_1 = nodes[a].node.get_and_clear_pending_msg_events();
-	assert_eq!(events_1.len(), 1);
+	assert_eq!(events_1.len(), 2);
 	let as_update = match events_1[0] {
 		MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
 			msg.clone()
 		},
 		_ => panic!("Unexpected event"),
 	};
+	match events_1[1] {
+		MessageSendEvent::HandleError { node_id, action: msgs::ErrorAction::SendErrorMessage { ref msg } } => {
+			assert_eq!(node_id, nodes[b].node.get_our_node_id());
+			assert_eq!(msg.data, expected_error);
+			if needs_err_handle {
+				nodes[b].node.handle_error(&nodes[a].node.get_our_node_id(), msg);
+			}
+		},
+		_ => panic!("Unexpected event"),
+	}
 
 	let events_2 = nodes[b].node.get_and_clear_pending_msg_events();
-	assert_eq!(events_2.len(), 1);
+	assert_eq!(events_2.len(), if needs_err_handle { 1 } else { 2 });
 	let bs_update = match events_2[0] {
 		MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
 			msg.clone()
 		},
 		_ => panic!("Unexpected event"),
 	};
+	if !needs_err_handle {
+		match events_2[1] {
+			MessageSendEvent::HandleError { node_id, action: msgs::ErrorAction::SendErrorMessage { ref msg } } => {
+				assert_eq!(node_id, nodes[a].node.get_our_node_id());
+				assert_eq!(msg.data, expected_error);
+			},
+			_ => panic!("Unexpected event"),
+		}
+	}
 
 	for node in nodes {
-		node.router.handle_channel_update(&as_update).unwrap();
-		node.router.handle_channel_update(&bs_update).unwrap();
+		node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
+		node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
 	}
 }
 
+pub fn get_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec<Node<'a, 'b, 'c>>, a: usize, b: usize)  {
+	handle_announce_close_broadcast_events(nodes, a, b, false, "Commitment or closing transaction was confirmed on chain.");
+}
+
+#[cfg(test)]
 macro_rules! get_channel_value_stat {
 	($node: expr, $channel_id: expr) => {{
 		let chan_lock = $node.node.channel_state.lock().unwrap();
@@ -1280,6 +1575,11 @@ macro_rules! handle_chan_reestablish_msgs {
 				None
 			};
 
+			if let Some(&MessageSendEvent::SendAnnouncementSignatures { ref node_id, msg: _ }) = msg_events.get(idx) {
+				idx += 1;
+				assert_eq!(*node_id, $dst_node.node.get_our_node_id());
+			}
+
 			let mut revoke_and_ack = None;
 			let mut commitment_update = None;
 			let order = if let Some(ev) = msg_events.get(idx) {
@@ -1324,7 +1624,7 @@ macro_rules! handle_chan_reestablish_msgs {
 
 /// pending_htlc_adds includes both the holding cell and in-flight update_add_htlcs, whereas
 /// for claims/fails they are separated out.
-pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, send_funding_locked: (bool, bool), pending_htlc_adds: (i64, i64), pending_htlc_claims: (usize, usize), pending_cell_htlc_claims: (usize, usize), pending_cell_htlc_fails: (usize, usize), pending_raa: (bool, bool))  {
+pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, send_funding_locked: (bool, bool), pending_htlc_adds: (i64, i64), pending_htlc_claims: (usize, usize), pending_htlc_fails: (usize, usize), pending_cell_htlc_claims: (usize, usize), pending_cell_htlc_fails: (usize, usize), pending_raa: (bool, bool))  {
 	node_a.node.peer_connected(&node_b.node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
 	let reestablish_1 = get_chan_reestablish_msgs!(node_a, node_b);
 	node_b.node.peer_connected(&node_a.node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
@@ -1346,7 +1646,7 @@ pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a,
 	}
 	if send_funding_locked.0 || send_funding_locked.1 {
 		// If we expect any funding_locked's, both sides better have set
-		// next_local_commitment_number to 1
+		// next_holder_commitment_number to 1
 		for reestablish in reestablish_1.iter() {
 			assert_eq!(reestablish.next_local_commitment_number, 1);
 		}
@@ -1378,8 +1678,10 @@ pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a,
 	}
 
 	// We don't yet support both needing updates, as that would require a different commitment dance:
-	assert!((pending_htlc_adds.0 == 0 && pending_htlc_claims.0 == 0 && pending_cell_htlc_claims.0 == 0 && pending_cell_htlc_fails.0 == 0) ||
-			(pending_htlc_adds.1 == 0 && pending_htlc_claims.1 == 0 && pending_cell_htlc_claims.1 == 0 && pending_cell_htlc_fails.1 == 0));
+	assert!((pending_htlc_adds.0 == 0 && pending_htlc_claims.0 == 0 && pending_htlc_fails.0 == 0 &&
+			 pending_cell_htlc_claims.0 == 0 && pending_cell_htlc_fails.0 == 0) ||
+			(pending_htlc_adds.1 == 0 && pending_htlc_claims.1 == 0 && pending_htlc_fails.1 == 0 &&
+			 pending_cell_htlc_claims.1 == 0 && pending_cell_htlc_fails.1 == 0));
 
 	for chan_msgs in resp_1.drain(..) {
 		if send_funding_locked.0 {
@@ -1402,7 +1704,7 @@ pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a,
 		} else {
 			assert!(chan_msgs.1.is_none());
 		}
-		if pending_htlc_adds.0 != 0 || pending_htlc_claims.0 != 0 || pending_cell_htlc_claims.0 != 0 || pending_cell_htlc_fails.0 != 0 {
+		if pending_htlc_adds.0 != 0 || pending_htlc_claims.0 != 0 || pending_htlc_fails.0 != 0 || pending_cell_htlc_claims.0 != 0 || pending_cell_htlc_fails.0 != 0 {
 			let commitment_update = chan_msgs.2.unwrap();
 			if pending_htlc_adds.0 != -1 { // We use -1 to denote a response commitment_signed
 				assert_eq!(commitment_update.update_add_htlcs.len(), pending_htlc_adds.0 as usize);
@@ -1410,7 +1712,7 @@ pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a,
 				assert!(commitment_update.update_add_htlcs.is_empty());
 			}
 			assert_eq!(commitment_update.update_fulfill_htlcs.len(), pending_htlc_claims.0 + pending_cell_htlc_claims.0);
-			assert_eq!(commitment_update.update_fail_htlcs.len(), pending_cell_htlc_fails.0);
+			assert_eq!(commitment_update.update_fail_htlcs.len(), pending_htlc_fails.0 + pending_cell_htlc_fails.0);
 			assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
 			for update_add in commitment_update.update_add_htlcs {
 				node_a.node.handle_update_add_htlc(&node_b.node.get_our_node_id(), &update_add);
@@ -1459,13 +1761,13 @@ pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a,
 		} else {
 			assert!(chan_msgs.1.is_none());
 		}
-		if pending_htlc_adds.1 != 0 || pending_htlc_claims.1 != 0 || pending_cell_htlc_claims.1 != 0 || pending_cell_htlc_fails.1 != 0 {
+		if pending_htlc_adds.1 != 0 || pending_htlc_claims.1 != 0 || pending_htlc_fails.1 != 0 || pending_cell_htlc_claims.1 != 0 || pending_cell_htlc_fails.1 != 0 {
 			let commitment_update = chan_msgs.2.unwrap();
 			if pending_htlc_adds.1 != -1 { // We use -1 to denote a response commitment_signed
 				assert_eq!(commitment_update.update_add_htlcs.len(), pending_htlc_adds.1 as usize);
 			}
-			assert_eq!(commitment_update.update_fulfill_htlcs.len(), pending_htlc_claims.0 + pending_cell_htlc_claims.0);
-			assert_eq!(commitment_update.update_fail_htlcs.len(), pending_cell_htlc_fails.0);
+			assert_eq!(commitment_update.update_fulfill_htlcs.len(), pending_htlc_claims.1 + pending_cell_htlc_claims.1);
+			assert_eq!(commitment_update.update_fail_htlcs.len(), pending_htlc_fails.1 + pending_cell_htlc_fails.1);
 			assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
 			for update_add in commitment_update.update_add_htlcs {
 				node_b.node.handle_update_add_htlc(&node_a.node.get_our_node_id(), &update_add);