f - Test handling events from ChainMonitor

Author: jkczyz

lightning-background-processor/src/lib.rs

@@ -170,10 +170,13 @@ impl BackgroundProcessor {
 
 #[cfg(test)]
 mod tests {
+	use bitcoin::blockdata::block::BlockHeader;
 	use bitcoin::blockdata::constants::genesis_block;
 	use bitcoin::blockdata::transaction::{Transaction, TxOut};
 	use bitcoin::network::constants::Network;
+	use lightning::chain::Confirm;
 	use lightning::chain::chainmonitor;
+	use lightning::chain::channelmonitor::ANTI_REORG_DELAY;
 	use lightning::chain::keysinterface::{InMemorySigner, KeysInterface, KeysManager};
 	use lightning::chain::transaction::OutPoint;
 	use lightning::get_event_msg;
@@ -192,6 +195,8 @@ mod tests {
 	use std::time::Duration;
 	use super::{BackgroundProcessor, FRESHNESS_TIMER};
 
+	const EVENT_DEADLINE: u64 = 5 * FRESHNESS_TIMER;
+
 	#[derive(Clone, Eq, Hash, PartialEq)]
 	struct TestDescriptor{}
 	impl SocketDescriptor for TestDescriptor {
@@ -209,7 +214,9 @@ mod tests {
 		peer_manager: Arc<PeerManager<TestDescriptor, Arc<test_utils::TestChannelMessageHandler>, Arc<test_utils::TestRoutingMessageHandler>, Arc<test_utils::TestLogger>>>,
 		chain_monitor: Arc<ChainMonitor>,
 		persister: Arc<FilesystemPersister>,
+		tx_broadcaster: Arc<test_utils::TestBroadcaster>,
 		logger: Arc<test_utils::TestLogger>,
+		best_block: BestBlock,
 	}
 
 	impl Drop for Node {
@@ -241,14 +248,12 @@ mod tests {
 			let now = Duration::from_secs(genesis_block(network).header.time as u64);
 			let keys_manager = Arc::new(KeysManager::new(&seed, now.as_secs(), now.subsec_nanos()));
 			let chain_monitor = Arc::new(chainmonitor::ChainMonitor::new(Some(chain_source.clone()), tx_broadcaster.clone(), logger.clone(), fee_estimator.clone(), persister.clone()));
-			let params = ChainParameters {
-				network,
-				best_block: BestBlock::from_genesis(network),
-			};
-			let manager = Arc::new(ChannelManager::new(fee_estimator.clone(), chain_monitor.clone(), tx_broadcaster, logger.clone(), keys_manager.clone(), UserConfig::default(), params));
+			let best_block = BestBlock::from_genesis(network);
+			let params = ChainParameters { network, best_block };
+			let manager = Arc::new(ChannelManager::new(fee_estimator.clone(), chain_monitor.clone(), tx_broadcaster.clone(), logger.clone(), keys_manager.clone(), UserConfig::default(), params));
 			let msg_handler = MessageHandler { chan_handler: Arc::new(test_utils::TestChannelMessageHandler::new()), route_handler: Arc::new(test_utils::TestRoutingMessageHandler::new() )};
 			let peer_manager = Arc::new(PeerManager::new(msg_handler, keys_manager.get_node_secret(), &seed, logger.clone()));
-			let node = Node { node: manager, peer_manager, chain_monitor, persister, logger };
+			let node = Node { node: manager, peer_manager, chain_monitor, persister, tx_broadcaster, logger, best_block };
 			nodes.push(node);
 		}
 		nodes
@@ -298,6 +303,27 @@ mod tests {
 		}}
 	}
 
+	fn confirm_transaction(node: &mut Node, tx: &Transaction) {
+		for i in 1..=ANTI_REORG_DELAY {
+			let prev_blockhash = node.best_block.block_hash();
+			let height = node.best_block.height() + 1;
+			let header = BlockHeader { version: 0x20000000, prev_blockhash, merkle_root: Default::default(), time: height, bits: 42, nonce: 42 };
+			let txdata = vec![(0, tx)];
+			node.best_block = BestBlock::new(header.block_hash(), height);
+			match i {
+				1 => {
+					node.node.transactions_confirmed(&header, &txdata, height);
+					node.chain_monitor.transactions_confirmed(&header, &txdata, height);
+				},
+				ANTI_REORG_DELAY => {
+					node.node.best_block_updated(&header, height);
+					node.chain_monitor.best_block_updated(&header, height);
+				},
+				_ => {},
+			}
+		}
+	}
+
 	#[test]
 	fn test_background_processor() {
 		// Test that when a new channel is created, the ChannelManager needs to be re-persisted with
@@ -391,7 +417,7 @@ mod tests {
 
 	#[test]
 	fn test_background_event_handling() {
-		let nodes = create_nodes(2, "test_background_event_handling".to_string());
+		let mut nodes = create_nodes(2, "test_background_event_handling".to_string());
 		let channel_value = 100000;
 		let data_dir = nodes[0].persister.get_data_dir();
 		let persister = move |node: &_| FilesystemPersister::persist_manager(data_dir.clone(), node);
@@ -401,15 +427,39 @@ mod tests {
 		let event_handler = move |event| {
 			sender.send(handle_funding_generation_ready!(event, channel_value)).unwrap();
 		};
-		let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
+		let bg_processor = BackgroundProcessor::start(persister.clone(), event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
 
 		// Open a channel and check that the FundingGenerationReady event was handled.
 		begin_open_channel!(nodes[0], nodes[1], channel_value);
-		let timeout = Duration::from_secs(5 * FRESHNESS_TIMER);
-		let (temporary_channel_id, tx) = receiver
-			.recv_timeout(timeout)
+		let (temporary_channel_id, funding_tx) = receiver
+			.recv_timeout(Duration::from_secs(EVENT_DEADLINE))
 			.expect("FundingGenerationReady not handled within deadline");
-		end_open_channel!(nodes[0], nodes[1], temporary_channel_id, tx);
+		end_open_channel!(nodes[0], nodes[1], temporary_channel_id, funding_tx);
+
+		// Confirm the funding transaction.
+		confirm_transaction(&mut nodes[0], &funding_tx);
+		confirm_transaction(&mut nodes[1], &funding_tx);
+		nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingLocked, nodes[0].node.get_our_node_id()));
+		nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendFundingLocked, nodes[1].node.get_our_node_id()));
+
+		assert!(bg_processor.stop().is_ok());
+
+		// Set up a background event handler for SpendableOutputs events.
+		let (sender, receiver) = std::sync::mpsc::sync_channel(1);
+		let event_handler = move |event| sender.send(event).unwrap();
+		let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
+
+		// Force close the channel and check that the SpendableOutputs event was handled.
+		nodes[0].node.force_close_channel(&nodes[0].node.list_channels()[0].channel_id).unwrap();
+		let commitment_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().pop().unwrap();
+		confirm_transaction(&mut nodes[0], &commitment_tx);
+		let event = receiver
+			.recv_timeout(Duration::from_secs(EVENT_DEADLINE))
+			.expect("SpendableOutputs not handled within deadline");
+		match event {
+			Event::SpendableOutputs { .. } => {},
+			_ => panic!("Unexpected event: {:?}", event),
+		}
 
 		assert!(bg_processor.stop().is_ok());
 	}

lightning/src/chain/channelmonitor.rs

@@ -226,7 +226,7 @@ pub(crate) const LATENCY_GRACE_PERIOD_BLOCKS: u32 = 3;
 /// It may cause spurrious generation of bumped claim txn but that's allright given the outpoint is already
 /// solved by a previous claim tx. What we want to avoid is reorg evicting our claim tx and us not
 /// keeping bumping another claim tx to solve the outpoint.
-pub(crate) const ANTI_REORG_DELAY: u32 = 6;
+pub const ANTI_REORG_DELAY: u32 = 6;
 /// Number of blocks before confirmation at which we fail back an un-relayed HTLC or at which we
 /// refuse to accept a new HTLC.
 ///