fuzz: add force close actions to chanmon_consistency

Add explicit force-close fuzz actions for the A-B and B-C channels and
enable the holder signing operations needed to exercise them.

The harness records dust HTLC paths before closing so later payment
resolution checks can account for claims blocked by dust outputs.

Author: joostjager

fuzz/src/chanmon_consistency.rs

@@ -15,7 +15,8 @@
 //! actions such as sending payments, handling events, or changing monitor update return values on
 //! a per-node basis. This should allow it to find any cases where the ordering of actions results
 //! in us getting out of sync with ourselves, and, assuming at least one of our recieve- or
-//! send-side handling is correct, other peers.
+//! send-side handling is correct, other peers. The fuzzer also exercises user-initiated
+//! force-closes with on-chain commitment transaction confirmation.
 
 use bitcoin::amount::Amount;
 use bitcoin::constants::genesis_block;
@@ -49,7 +50,7 @@ use lightning::events::{self, EventsProvider};
 use lightning::ln::channel::{
 	FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE, MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS,
 };
-use lightning::ln::channel_state::ChannelDetails;
+use lightning::ln::channel_state::{ChannelDetails, InboundHTLCDetails, OutboundHTLCDetails};
 use lightning::ln::channelmanager::{
 	ChainParameters, ChannelManager, ChannelManagerReadArgs, PaymentId, RecentPaymentDetails,
 	TrustedChannelFeatures,
@@ -648,10 +649,12 @@ impl SignerProvider for KeyProvider {
 	}
 }
 
-const SUPPORTED_SIGNER_OPS: [SignerOp; 3] = [
+const SUPPORTED_SIGNER_OPS: [SignerOp; 5] = [
 	SignerOp::SignCounterpartyCommitment,
 	SignerOp::GetPerCommitmentPoint,
 	SignerOp::ReleaseCommitmentSecret,
+	SignerOp::SignHolderCommitment,
+	SignerOp::SignHolderHtlcTransaction,
 ];
 
 impl KeyProvider {
@@ -1432,6 +1435,16 @@ impl<'a> HarnessNode<'a> {
 	}
 }
 
+#[inline]
+fn inbound_dust_blocks_path(htlc: &InboundHTLCDetails) -> bool {
+	htlc.is_dust
+}
+
+#[inline]
+fn outbound_dust_blocks_path(htlc: &OutboundHTLCDetails) -> bool {
+	htlc.is_dust
+}
+
 struct EventQueues {
 	ab: Vec<MessageSendEvent>,
 	ba: Vec<MessageSendEvent>,
@@ -3150,6 +3163,65 @@ impl<'a, 'd, Out: Output + MaybeSend + MaybeSync> Harness<'a, 'd, Out> {
 		assert!(settled, "message-only settle exceeded budget: {}", self.pending_work_summary(),);
 	}
 
+	fn record_force_close_dust(&self, closer_idx: usize, channel_id: ChannelId) {
+		if let Some(channel) = self.nodes[closer_idx]
+			.node
+			.list_channels()
+			.into_iter()
+			.find(|chan| chan.channel_id == channel_id)
+		{
+			let mut dust_parts = channel
+				.pending_inbound_htlcs
+				.iter()
+				.filter(|htlc| inbound_dust_blocks_path(htlc))
+				.map(|htlc| (htlc.payment_hash, htlc.amount_msat))
+				.chain(
+					channel
+						.pending_outbound_htlcs
+						.iter()
+						.filter(|htlc| outbound_dust_blocks_path(htlc))
+						.map(|htlc| (htlc.payment_hash, htlc.amount_msat)),
+				)
+				.collect::<Vec<_>>();
+			let payment_paths = self.payments.payment_paths_by_hash.borrow();
+			let mut blocked_paths = self.payments.blocked_dust_paths_by_hash.borrow_mut();
+			for (payment_hash, amount_msat) in dust_parts.drain(..) {
+				let Some(paths) = payment_paths.get(&payment_hash) else {
+					continue;
+				};
+				let blocked_for_hash =
+					blocked_paths.entry(payment_hash).or_insert_with(HashSet::new);
+				if let Some((path_idx, _)) = paths.iter().enumerate().find(|(path_idx, path)| {
+					!blocked_for_hash.contains(path_idx)
+						&& path.iter().any(|(chan_id, part_amt)| {
+							*chan_id == channel_id && *part_amt == amount_msat
+						})
+				}) {
+					blocked_for_hash.insert(path_idx);
+				}
+			}
+		}
+	}
+
+	fn force_close(
+		&mut self, closer_idx: usize, channel_id: ChannelId, counterparty_idx: usize, reason: &str,
+	) {
+		self.flush_progress(32);
+		self.record_force_close_dust(closer_idx, channel_id);
+		if self.nodes[closer_idx]
+			.node
+			.force_close_broadcasting_latest_txn(
+				&channel_id,
+				&self.nodes[counterparty_idx].our_node_id(),
+				reason.to_string(),
+			)
+			.is_ok()
+		{
+			self.payments.closed_channels.borrow_mut().insert(channel_id);
+			self.flush_progress(32);
+		}
+	}
+
 	fn probe_amount_for_direction(
 		&self, source_idx: usize, dest_chan_id: ChannelId,
 	) -> Option<u64> {
@@ -4092,25 +4164,42 @@ pub fn do_test<Out: Output + MaybeSend + MaybeSync>(data: &[u8], out: Out) {
 				harness.nodes[2].node.signer_unblocked(None);
 			},
 			0xcc => {
-				harness.nodes[1]
+				harness.nodes[0]
 					.keys_manager
-					.enable_op_for_all_signers(SignerOp::ReleaseCommitmentSecret);
-				let filter = Some((harness.nodes[0].our_node_id(), harness.chan_a_id()));
-				harness.nodes[1].node.signer_unblocked(filter);
+					.enable_op_for_all_signers(SignerOp::SignHolderCommitment);
+				harness.nodes[0].node.signer_unblocked(None);
 			},
 			0xcd => {
 				harness.nodes[1]
 					.keys_manager
-					.enable_op_for_all_signers(SignerOp::ReleaseCommitmentSecret);
-				let filter = Some((harness.nodes[2].our_node_id(), harness.chan_b_id()));
-				harness.nodes[1].node.signer_unblocked(filter);
+					.enable_op_for_all_signers(SignerOp::SignHolderCommitment);
+				harness.nodes[1].node.signer_unblocked(None);
 			},
 			0xce => {
 				harness.nodes[2]
 					.keys_manager
-					.enable_op_for_all_signers(SignerOp::ReleaseCommitmentSecret);
+					.enable_op_for_all_signers(SignerOp::SignHolderCommitment);
 				harness.nodes[2].node.signer_unblocked(None);
 			},
+			0xcf => {
+				harness.nodes[0]
+					.keys_manager
+					.enable_op_for_all_signers(SignerOp::SignHolderHtlcTransaction);
+				harness.nodes[1]
+					.keys_manager
+					.enable_op_for_all_signers(SignerOp::SignHolderHtlcTransaction);
+				harness.nodes[2]
+					.keys_manager
+					.enable_op_for_all_signers(SignerOp::SignHolderHtlcTransaction);
+				harness.nodes[0].node.signer_unblocked(None);
+				harness.nodes[1].node.signer_unblocked(None);
+				harness.nodes[2].node.signer_unblocked(None);
+			},
+
+			0xd0 => harness.force_close(0, harness.chan_a_id(), 1, "]]]]]]]]]"),
+			0xd1 => harness.force_close(1, harness.chan_b_id(), 2, "]]]]]]]]"),
+			0xd2 => harness.force_close(1, harness.chan_a_id(), 0, "]]]]]]]"),
+			0xd3 => harness.force_close(2, harness.chan_b_id(), 1, "]]]]]"),
 
 			0xd8 => harness.confirm_broadcasts_for_node(0),
 			0xd9 => harness.confirm_broadcasts_for_node(1),