Implement block_disconnect for pruning of waiting-conf HTLC updates

Modify ChainListener API by adding height, txn_matched,
indexes_of_txn_matched fields to block_disconnect

Modify ChainWatchInterfaceUtil to move to listener previously txn
registered as watched at block_disconnected

Author: Antoine Riard

src/chain/chaininterface.rs

@@ -77,7 +77,11 @@ pub trait ChainListener: Sync + Send {
 	fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]);
 	/// Notifies a listener that a block was disconnected.
 	/// Unlike block_connected, this *must* never be called twice for the same disconnect event.
-	fn block_disconnected(&self, header: &BlockHeader);
+	///
+	/// Provide listeners with filtered txn previously registered as watched because channels are
+	/// driven by onchain events (tx broadcast, height), a cancel of one of them may conduct to
+	/// rollback state (ChannelMonitor or Channel).
+	fn block_disconnected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]);
 }
 
 /// An enum that represents the speed at which we want a transaction to confirm used for feerate
@@ -278,11 +282,20 @@ impl ChainWatchInterfaceUtil {
 	}
 
 	/// Notify listeners that a block was disconnected.
-	pub fn block_disconnected(&self, header: &BlockHeader) {
+	pub fn block_disconnected(&self, block: &Block, height: u32) {
 		let listeners = self.listeners.lock().unwrap().clone();
+		let mut matched = Vec::new();
+		let mut matched_index = Vec::new();
+		let watched = self.watched.lock().unwrap();
+		for (index, transaction) in block.txdata.iter().enumerate() {
+			if self.does_match_tx_unguarded(transaction, &watched) {
+				matched.push(transaction);
+				matched_index.push(index as u32);
+			}
+		}
 		for listener in listeners.iter() {
 			match listener.upgrade() {
-				Some(arc) => arc.block_disconnected(header),
+				Some(arc) => arc.block_disconnected(&block.header, height, matched.as_slice(), matched_index.as_slice()),
 				None => ()
 			}
 		}

src/ln/channelmanager.rs

@@ -2473,7 +2473,7 @@ impl ChainListener for ChannelManager {
 	}
 
 	/// We force-close the channel without letting our counterparty participate in the shutdown
-	fn block_disconnected(&self, header: &BlockHeader) {
+	fn block_disconnected(&self, header: &BlockHeader, _: u32, _: &[&Transaction], _: &[u32]) {
 		let _ = self.total_consistency_lock.read().unwrap();
 		let mut failed_channels = Vec::new();
 		{

src/ln/channelmonitor.rs

@@ -199,7 +199,13 @@ impl<Key : Send + cmp::Eq + hash::Hash> ChainListener for SimpleManyChannelMonit
 		pending_events.append(&mut new_events);
 	}
 
-	fn block_disconnected(&self, _: &BlockHeader) { }
+	fn block_disconnected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], _: &[u32]) {
+		let block_hash = header.bitcoin_hash();
+		let mut monitors = self.monitors.lock().unwrap();
+		for monitor in monitors.values_mut() {
+			monitor.block_disconnected(txn_matched, height, &block_hash);
+		}
+	}
 }
 
 impl<Key : Send + cmp::Eq + hash::Hash + 'static> SimpleManyChannelMonitor<Key> {
@@ -1855,6 +1861,23 @@ impl ChannelMonitor {
 		(watch_outputs, spendable_outputs, htlc_updated)
 	}
 
+	fn block_disconnected(&mut self, txn_matched: &[&Transaction], height: u32, block_hash: &Sha256dHash) {
+		for tx in txn_matched {
+			if tx.input.len() == 1 {
+				let txid = tx.txid();
+				for (idx, _) in tx.output.iter().enumerate() {
+					if let Some(_) = self.htlc_updated_waiting_outpoint_solving.remove(&BitcoinOutPoint { txid, vout: idx as u32 }) {
+						//We discard htlc update there as waiting-solving-trigger tx (non-revoked commitment tx) has been disconnected
+					}
+				}
+			}
+		}
+		if let Some(_) = self.htlc_updated_waiting_threshold_conf.remove(&(height + HTLC_FAIL_ANTI_REORG_DELAY - 1)) {
+			//We discard htlc update there as failure-trigger tx (revoked commitment tx, non-revoked commitment tx, HTLC-timeout tx) has been disconnected
+		}
+		self.last_block_hash = block_hash.clone();
+	}
+
 	pub(super) fn would_broadcast_at_height(&self, height: u32) -> bool {
 		// We need to consider all HTLCs which are:
 		//  * in any unrevoked remote commitment transaction, as they could broadcast said

src/ln/functional_tests.rs

@@ -2526,8 +2526,10 @@ fn test_unconf_chan() {
 		header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 		headers.push(header.clone());
 	}
+	let mut height = 99;
 	while !headers.is_empty() {
-		nodes[0].node.block_disconnected(&headers.pop().unwrap());
+		nodes[0].node.block_disconnected(&headers.pop().unwrap(), height, &Vec::new(), &Vec::new());
+		height -= 1;
 	}
 	check_closed_broadcast!(nodes[0]);
 	let channel_state = nodes[0].node.channel_state.lock().unwrap();