Add block_disconnecting tests to cancel HTLC failure updates

Author: Antoine Riard

fuzz/fuzz_targets/full_stack_target.rs

@@ -208,8 +208,8 @@ impl<'a> MoneyLossDetector<'a> {
 		if self.height > 0 && (self.max_height < 6 || self.height >= self.max_height - 6) {
 			self.height -= 1;
 			let header = BlockHeader { version: 0x20000000, prev_blockhash: self.header_hashes[self.height], merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
-			self.manager.block_disconnected(&header, height);
-			self.monitor.block_disconnected(&header, height);
+			self.manager.block_disconnected(&header, self.height);
+			self.monitor.block_disconnected(&header, self.height);
 			let removal_height = self.height;
 			self.txids_confirmed.retain(|_, height| {
 				removal_height != *height

src/ln/functional_test_utils.rs

@@ -15,7 +15,7 @@ use util::logger::Logger;
 use util::config::UserConfig;
 
 use bitcoin::util::hash::{BitcoinHash, Sha256dHash};
-use bitcoin::blockdata::block::BlockHeader;
+use bitcoin::blockdata::block::{BlockHeader, Block};
 use bitcoin::blockdata::transaction::{Transaction, TxOut};
 use bitcoin::network::constants::Network;
 
@@ -55,6 +55,20 @@ pub fn connect_blocks(chain: &chaininterface::ChainWatchInterfaceUtil, depth: u3
 	}
 }
 
+pub fn disconnect_blocks(chain: &chaininterface::ChainWatchInterfaceUtil, depth: u32, height: u32, parent: bool, prev_blockhash: Sha256dHash) {
+	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 };
+	let mut blocks = Vec::new();
+	for _ in 0..depth {
+		blocks.push(Block { header, txdata: Vec::new() });
+		header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+	}
+	let mut height = height;
+	for block in blocks.pop() {
+		chain.block_disconnected(&block, height);
+		height -= 1;
+	}
+}
+
 pub struct Node {
 	pub chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
 	pub tx_broadcaster: Arc<test_utils::TestBroadcaster>,

src/ln/functional_tests.rs

@@ -5187,3 +5187,90 @@ fn test_failure_delay_dust_htlc_local_commitment() {
 	do_test_failure_delay_dust_htlc_local_commitment(true);
 	do_test_failure_delay_dust_htlc_local_commitment(false);
 }
+
+fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
+
+	let nodes = create_network(2);
+	let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
+
+	let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
+
+	let (payment_preimage_1, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
+	let (payment_preimage_2, payment_hash_2) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
+
+	let as_commitment_tx = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().last_local_commitment_txn.clone();
+	let bs_commitment_tx = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().last_local_commitment_txn.clone();
+
+	if revoked {
+		let (payment_preimage_3, payment_hash_3) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
+		claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3);
+		let events = nodes[0].node.get_and_clear_pending_events();
+		assert_eq!(events.len(), 1);
+		match events[0] {
+			Event::PaymentReceived { payment_hash, .. } => {
+				assert_eq!(payment_hash, payment_hash_3);
+			},
+			_ => panic!("Unexpected event"),
+		}
+	}
+	println!("Before, A channels {}", nodes[0].node.list_channels().len());
+
+	let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+	let header_2  = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+	let timeout_tx;
+	if local {
+		nodes[0].chain_monitor.block_connected_checked(&header, 1, &[&as_commitment_tx[0]], &[1; 1]);
+		timeout_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone();
+		assert_eq!(timeout_tx.input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
+		nodes[0].chain_monitor.block_connected_checked(&header_2, 1, &[&timeout_tx], &[1; 1]);
+	} else {
+		nodes[0].chain_monitor.block_connected_checked(&header, 1, &[&bs_commitment_tx[0]], &[1; 1]);
+		timeout_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone();
+		assert_eq!(timeout_tx.input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
+		nodes[0].chain_monitor.block_connected_checked(&header_2, 1, &[&timeout_tx], &[1; 1]);
+	}
+	println!("After 2 block connected, A channels {}", nodes[0].node.list_channels().len());
+
+	let events = nodes[0].node.get_and_clear_pending_msg_events();
+	assert_eq!(events.len(), 1);
+	match events[0] {
+		MessageSendEvent::BroadcastChannelUpdate { .. } => {},
+		_ => panic!("Unexpected event"),
+	}
+
+	assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
+	connect_blocks(&nodes[0].chain_monitor, 3, 2, true, header.bitcoin_hash());
+	assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
+
+	disconnect_blocks(&nodes[0].chain_monitor, 3, 5, true, header.bitcoin_hash());
+	nodes[0].chain_monitor.block_disconnected(&Block { header: header_2, txdata: vec![timeout_tx] }, 2);
+	nodes[0].chain_monitor.block_disconnected(&Block { header, txdata: vec![if local { as_commitment_tx[0].clone() } else { bs_commitment_tx[0].clone() }] }, 1);
+	assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
+
+	println!("After 5 disconnected, A channels {}", nodes[0].node.list_channels().len());
+	//claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
+	//claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_2);
+
+	//let events = nodes[0].get_and_clear_pending_events();
+	//assert_eq!(events.len(), 2);
+	//let mut first_claimed = false;
+	//for event in events {
+	//	match event {
+	//		Event::PaymentReceived { payment_hash, .. } => {
+	//			if payment_hash == payment_hash_1 {
+	//				assert!(!first_claimed);
+	//				first_claimed = true;
+	//			} else {
+	//				assert_eq!(payment_hash, payment_hash_2);
+	//			}
+	//		}
+	//		_ => panic!("Unexpected event"),
+	//	}
+	//}
+}
+
+#[test]
+fn test_sweep_outbound_htlc_failure_update() {
+	//do_test_sweep_outbound_htlc_failure_update(false, true);
+	do_test_sweep_outbound_htlc_failure_update(false, false);
+}