Implement block_disconnect for pruning of waiting-conf HTLC updates

Modify ChainListener API by adding height field to block_disconnect

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);
 }
 
 /// An enum that represents the speed at which we want a transaction to confirm used for feerate
@@ -278,11 +282,11 @@ 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();
 		for listener in listeners.iter() {
 			match listener.upgrade() {
-				Some(arc) => arc.block_disconnected(header),
+				Some(arc) => arc.block_disconnected(&block.header, height),
 				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) {
 		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) {
+		let block_hash = header.bitcoin_hash();
+		let mut monitors = self.monitors.lock().unwrap();
+		for monitor in monitors.values_mut() {
+			monitor.block_disconnected(height, &block_hash);
+		}
+	}
 }
 
 impl<Key : Send + cmp::Eq + hash::Hash + 'static> SimpleManyChannelMonitor<Key> {
@@ -1822,6 +1828,13 @@ impl ChannelMonitor {
 		(watch_outputs, spendable_outputs, htlc_updated)
 	}
 
+	fn block_disconnected(&mut self, height: u32, block_hash: &Sha256dHash) {
+		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);
+		height -= 1;
 	}
 	check_closed_broadcast!(nodes[0]);
 	let channel_state = nodes[0].node.channel_state.lock().unwrap();