Add splice state fuzz checks

Expose a fuzz-only splice state probe so chanmon consistency can
check tx_abort cleanup without relying on API error strings.

The helper reports queued, active, and pending splice states directly.

Author: joostjager

fuzz/src/chanmon_consistency.rs

@@ -49,7 +49,7 @@ use lightning::chain::{
 };
 use lightning::events;
 use lightning::ln::channel::{
-	FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE, MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS,
+	SpliceProbeState, FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE, MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS,
 };
 use lightning::ln::channel_state::ChannelDetails;
 use lightning::ln::channelmanager::{
@@ -2224,6 +2224,27 @@ fn build_node_config(chan_type: ChanType) -> UserConfig {
 	config
 }
 
+fn assert_no_stale_splice_negotiation(
+	node: &HarnessNode<'_>, channel_id: &ChannelId, counterparty_node_id: &PublicKey, context: &str,
+) {
+	let state = match node.node.splice_probe_state(channel_id, counterparty_node_id) {
+		Ok(state) => state,
+		Err(APIError::ChannelUnavailable { ref err })
+			if err.starts_with("No such channel_id") || err.starts_with("No such peer") =>
+		{
+			// The channel may already be removed when close-related cleanup events are handled.
+			return;
+		},
+		Err(e) => panic!("{:?}", e),
+	};
+	assert!(
+		matches!(state, SpliceProbeState::None | SpliceProbeState::PendingWithoutNegotiation),
+		"{} left splice negotiation state behind: {:?}",
+		context,
+		state
+	);
+}
+
 fn assert_test_invariants(nodes: &[HarnessNode<'_>; 3]) {
 	assert_eq!(nodes[0].list_channels().len(), 3);
 	assert_eq!(nodes[1].list_channels().len(), 6);
@@ -2918,6 +2939,12 @@ impl<'a, Out: Output + MaybeSend + MaybeSync> Harness<'a, Out> {
 				MessageSendEvent::SendTxAbort { ref node_id, ref msg } => {
 					let dest_idx = log_peer_message(node_idx, node_id, nodes, out, "tx_abort");
 					nodes[dest_idx].handle_tx_abort(source_node_id, msg);
+					assert_no_stale_splice_negotiation(
+						&nodes[dest_idx],
+						&msg.channel_id,
+						&source_node_id,
+						"tx_abort",
+					);
 					None
 				},
 				MessageSendEvent::SendTxInitRbf { ref node_id, ref msg } => {

lightning/src/ln/channel.rs

@@ -1537,6 +1537,20 @@ enum ChannelPhase<SP: SignerProvider> {
 	Funded(FundedChannel<SP>),
 }
 
+/// Fuzz-only view of splice state used to validate cleanup paths.
+#[cfg(fuzzing)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SpliceProbeState {
+	/// No pending splice state is present.
+	None,
+	/// A splice action is queued to start once quiescence completes.
+	QueuedAction,
+	/// A splice negotiation is active.
+	ActiveNegotiation { is_initiator: bool },
+	/// Splice state remains, but no negotiation is currently active.
+	PendingWithoutNegotiation,
+}
+
 impl<SP: SignerProvider> Channel<SP>
 where
 	SP::EcdsaSigner: ChannelSigner,
@@ -1617,6 +1631,14 @@ where
 		}
 	}
 
+	/// Returns a read-only view of splice state for fuzz invariants.
+	#[cfg(fuzzing)]
+	pub fn splice_probe_state(&self) -> SpliceProbeState {
+		self.as_funded()
+			.map(|channel| channel.splice_probe_state())
+			.unwrap_or(SpliceProbeState::None)
+	}
+
 	pub fn as_funded_mut(&mut self) -> Option<&mut FundedChannel<SP>> {
 		if let ChannelPhase::Funded(channel) = &mut self.phase {
 			Some(channel)
@@ -7331,6 +7353,22 @@ where
 		}
 	}
 
+	#[cfg(fuzzing)]
+	fn splice_probe_state(&self) -> SpliceProbeState {
+		if self.quiescent_action.is_some() {
+			return SpliceProbeState::QueuedAction;
+		}
+		if let Some(pending_splice) = &self.pending_splice {
+			if let Some(funding_negotiation) = &pending_splice.funding_negotiation {
+				return SpliceProbeState::ActiveNegotiation {
+					is_initiator: funding_negotiation.is_initiator(),
+				};
+			}
+			return SpliceProbeState::PendingWithoutNegotiation;
+		}
+		SpliceProbeState::None
+	}
+
 	fn funding_and_pending_funding_iter_mut(&mut self) -> impl Iterator<Item = &mut FundingScope> {
 		core::iter::once(&mut self.funding).chain(
 			self.pending_splice

lightning/src/ln/channelmanager.rs

@@ -4976,6 +4976,28 @@ impl<
 		}
 	}
 
+	/// Returns a read-only view of channel splice state for fuzz invariants.
+	#[cfg(fuzzing)]
+	pub fn splice_probe_state(
+		&self, channel_id: &ChannelId, counterparty_node_id: &PublicKey,
+	) -> Result<channel::SpliceProbeState, APIError> {
+		let per_peer_state = self.per_peer_state.read().unwrap();
+
+		let peer_state_mutex = match per_peer_state
+			.get(counterparty_node_id)
+			.ok_or_else(|| APIError::no_such_peer(counterparty_node_id))
+		{
+			Ok(p) => p,
+			Err(e) => return Err(e),
+		};
+
+		let peer_state = peer_state_mutex.lock().unwrap();
+		match peer_state.channel_by_id.get(channel_id) {
+			Some(chan_phase) => Ok(chan_phase.splice_probe_state()),
+			None => Err(APIError::no_such_channel_for_peer(channel_id, counterparty_node_id)),
+		}
+	}
+
 	/// Cancels an in-flight [`FundingContribution`].
 	///
 	/// This is primarily useful after receiving an [`Event::FundingTransactionReadyForSigning`] for