Test splice failure surfacing and recovery

A disconnect during the interactive negotiation fails the splice with
PeerDisconnected. The first test asserts that exactly one
SpliceNegotiationFailed reaches the user — carrying the reason and the
originating request's parameters — and that a new splice initiated
afterwards completes with a single funding payment. The window only
exists mid-negotiation: a contribution still queued at disconnect is
resumed by LDK itself on reconnect, and one awaiting signatures
survives re-establishment. The test therefore synchronizes on the
counterparty's splice_ack — logged by LDK's peer handler — and
stretches the negotiation by funding the splice from many small UTXOs,
each of which adds an interactive-tx round trip.

A splice dropped by a restart is recovered silently: startup
reconciliation releases what the wallet reserved and drops the record
without fabricating a failure event. What does reach the user is the
failure LDK persisted at shutdown and replays at startup — once, with
parameters only when it still matches a kept record. The restart tests
cover both cases: a dropped splice-out surfaces without parameters and
a further restart stays silent, while a dropped fee bump — whose record
reconciliation keeps, since LDK still holds the negotiated splice —
surfaces with the bump's parameters. In both, the application
re-initiates and the splice completes. A splice confirmed while its
node was offline keeps exactly one payment record under its splice-time
id regardless of whether wallet sync or classification sees the
confirmation first.

Developed with assistance from Claude Code.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: jkczyz

tests/common/logging.rs

@@ -192,17 +192,21 @@ impl CollectingLogWriter {
 		self.logs.lock().unwrap().iter().filter(|message| message.contains(text)).count()
 	}
 
-	/// Waits up to ten seconds for a logged message containing `text`, returning whether one
-	/// arrived. Polling beats a fixed sleep: it returns as soon as the line lands and only pays
-	/// the full timeout when the line never comes.
+	/// Waits up to [`INTEROP_TIMEOUT_SECS`] for a logged message containing `text`, returning
+	/// whether one arrived. Polling beats a fixed sleep: it returns as soon as the line lands and
+	/// only pays the full timeout when the line never comes.
+	///
+	/// [`INTEROP_TIMEOUT_SECS`]: super::INTEROP_TIMEOUT_SECS
 	pub(crate) async fn wait_for(&self, text: &str) -> bool {
 		self.wait_for_count(text, 1).await
 	}
 
-	/// Waits up to ten seconds for `occurrences` logged messages containing `text`, returning
-	/// whether they arrived.
+	/// Waits up to [`INTEROP_TIMEOUT_SECS`] for `occurrences` logged messages containing `text`,
+	/// returning whether they arrived.
+	///
+	/// [`INTEROP_TIMEOUT_SECS`]: super::INTEROP_TIMEOUT_SECS
 	pub(crate) async fn wait_for_count(&self, text: &str, occurrences: usize) -> bool {
-		for _ in 0..100 {
+		for _ in 0..(super::INTEROP_TIMEOUT_SECS * 10) {
 			if self.count(text) >= occurrences {
 				return true;
 			}
@@ -217,3 +221,30 @@ impl LogWriter for CollectingLogWriter {
 		self.logs.lock().unwrap().push(record.args.to_string());
 	}
 }
+
+/// Forwards every record to an inner [`CollectingLogWriter`] and signals `seen` when a record
+/// contains `marker`. The signal fires from inside the logging call, so a test can react within
+/// the emitting code path's timing — where the collector's polling `wait_for` (100ms granularity)
+/// is too coarse.
+pub(crate) struct MarkerLogWriter {
+	inner: Arc<CollectingLogWriter>,
+	marker: &'static str,
+	seen: Arc<tokio::sync::Notify>,
+}
+
+impl MarkerLogWriter {
+	pub(crate) fn new(
+		inner: Arc<CollectingLogWriter>, marker: &'static str, seen: Arc<tokio::sync::Notify>,
+	) -> Self {
+		Self { inner, marker, seen }
+	}
+}
+
+impl LogWriter for MarkerLogWriter {
+	fn log(&self, record: LogRecord) {
+		if record.args.to_string().contains(self.marker) {
+			self.seen.notify_one();
+		}
+		LogWriter::log(&*self.inner, record);
+	}
+}