chanmon_consistency: verify claimable balances after settlement

After the 0xff settlement completes with force-closed channels, check
get_claimable_balances() on all chain monitors. Assert that no
ClaimableOnChannelClose balances remain, since those indicate the
monitor still considers a channel open when it should be closed. This
catches state machine bugs where the force-close state transition is
not properly reflected in balance tracking.

Other balance types (ClaimableAwaitingConfirmations,
MaybeTimeoutClaimableHTLC, etc.) are logged but not asserted empty,
since anchor channel HTLC resolution is not yet fully handled (the
BumpTransaction events are currently dropped).

The check passes open channels via the ignored_channels parameter so
that only closed channel balances are examined.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: joostjager

fuzz/src/chanmon_consistency.rs

@@ -41,7 +41,7 @@ use lightning::chain;
 use lightning::chain::chaininterface::{
 	BroadcasterInterface, ConfirmationTarget, FeeEstimator, TransactionType,
 };
-use lightning::chain::channelmonitor::{ChannelMonitor, MonitorEvent};
+use lightning::chain::channelmonitor::{Balance, ChannelMonitor, MonitorEvent};
 use lightning::chain::transaction::OutPoint;
 use lightning::chain::{
 	chainmonitor, channelmonitor, BestBlock, ChannelMonitorUpdateStatus, Confirm, Watch,
@@ -2989,6 +2989,43 @@ pub fn do_test<Out: Output + MaybeSend + MaybeSync>(
 					);
 				}
 
+				// After settlement, verify that closed channels have no
+				// ClaimableOnChannelClose balances (which would indicate the
+				// monitor still thinks the channel is open).
+				if !closed_channels.borrow().is_empty() {
+					let open_channels = nodes[0]
+						.list_channels()
+						.iter()
+						.chain(nodes[1].list_channels().iter())
+						.chain(nodes[2].list_channels().iter())
+						.map(|c| c.clone())
+						.collect::<Vec<_>>();
+					let open_refs: Vec<&_> = open_channels.iter().collect();
+					for (label, monitor) in
+						[("A", &monitor_a), ("B", &monitor_b), ("C", &monitor_c)]
+					{
+						let balances = monitor.chain_monitor.get_claimable_balances(&open_refs);
+						for balance in &balances {
+							if matches!(balance, Balance::ClaimableOnChannelClose { .. }) {
+								panic!(
+									"Monitor {} has ClaimableOnChannelClose balance after settlement: {:?}",
+									label, balance
+								);
+							}
+						}
+						if !balances.is_empty() {
+							out.locked_write(
+								format!(
+									"Monitor {} has {} remaining balances after settlement.\n",
+									label,
+									balances.len()
+								)
+								.as_bytes(),
+							);
+						}
+					}
+				}
+
 				last_htlc_clear_fee_a = fee_est_a.ret_val.load(atomic::Ordering::Acquire);
 				last_htlc_clear_fee_b = fee_est_b.ret_val.load(atomic::Ordering::Acquire);
 				last_htlc_clear_fee_c = fee_est_c.ret_val.load(atomic::Ordering::Acquire);