refactor(test): DRY up interop tests and un-ignore CLN tests

- Move test_receive_keysend into interop_tests! macro, removing
  per-file duplicates across CLN, LND, and Eclair
- Un-ignore test_cln_splice_in (will fail until rust-lightning
  bump past #4472, tracked in lightningdevkit#857)
- Remove unused supports_splice() from ExternalNode trait

Author: febyeji

tests/common/cln.rs

@@ -270,16 +270,6 @@ impl ExternalNode for TestClnNode {
 		Ok(channels)
 	}
 
-	// CLN v25 with --experimental-splicing advertises BOLT-spec bit 62
-	// (OPT_SPLICE), so feature negotiation with LDK succeeds. However,
-	// rust-lightning panics during tx_signatures exchange due to a
-	// debug_assert (fixed in rust-lightning#4472, not yet in pinned rev).
-	// Flip to true after ldk-node bumps rust-lightning past that fix.
-	// Tracking: ldk-node#857
-	fn supports_splice(&self) -> bool {
-		false
-	}
-
 	async fn splice_in(&self, channel_id: &str, amount_sat: u64) -> Result<(), TestFailure> {
 		// Step 1: splice_init with positive relative_amount
 		let ch_id = channel_id.to_string();

tests/common/eclair.rs

@@ -280,14 +280,6 @@ impl ExternalNode for TestEclairNode {
 		Ok(channels)
 	}
 
-	// Eclair uses custom prototype feature bit 154 for splice, not the
-	// BOLT-specified bit 62/63 that LDK uses. Splice interop is not possible
-	// until Eclair migrates to the standard feature bits.
-	// Ref: https://github.com/ACINQ/eclair/blob/master/eclair-core/src/main/scala/fr/acinq/eclair/Features.scala
-	fn supports_splice(&self) -> bool {
-		false
-	}
-
 	async fn splice_in(&self, channel_id: &str, amount_sat: u64) -> Result<(), TestFailure> {
 		let amount_str = amount_sat.to_string();
 		self.post("/splicein", &[("channelId", channel_id), ("amountIn", &amount_str)]).await?;

tests/common/external_node.rs

@@ -145,18 +145,6 @@ pub(crate) trait ExternalNode: Send + Sync {
 		Err(self.make_error(format!("did not reach height {} after 60s", min_height)))
 	}
 
-	/// Whether this implementation supports channel splicing with LDK.
-	///
-	/// Feature bit status:
-	/// - LDK uses BOLT-finalized bit 62/63 ([BOLT 9](https://github.com/lightning/bolts/blob/master/09-features.md))
-	/// - CLN v25 `--experimental-splicing` advertises both standard bit 62 and
-	///   experimental bit 162 ([features.h](https://github.com/ElementsProject/lightning/blob/v25.12/common/features.h)) -- interop works
-	/// - Eclair v0.14 uses custom prototype bit 154 ([Features.scala](https://github.com/ACINQ/eclair/blob/master/eclair-core/src/main/scala/fr/acinq/eclair/Features.scala)) -- not compatible
-	/// - LND does not implement splice
-	fn supports_splice(&self) -> bool {
-		false
-	}
-
 	/// Splice additional funds into an existing channel.
 	///
 	/// Not all implementations support splicing. The default returns `NotSupported`.

tests/common/scenarios/mod.rs

@@ -47,6 +47,7 @@ pub(crate) enum CloseType {
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum PayType {
 	Bolt11,
+	Keysend,
 }
 
 /// Find a specific channel on the external node by its channel ID.
@@ -126,7 +127,7 @@ where
 /// Generated tests:
 /// - `setup_ldk_node()` -- creates and starts an LDK node with electrum backend
 /// - `test_scenarios()` -- runs the full sequential scenario suite
-/// - `test_combos()` -- runs all 16 disconnect/close permutations
+/// - `test_combos()` -- runs all 32 disconnect/close/payment permutations
 macro_rules! interop_tests {
 	($setup_clients:ident) => {
 		fn setup_ldk_node() -> ldk_node::Node {
@@ -156,29 +157,6 @@ macro_rules! interop_tests {
 			node.stop().unwrap();
 		}
 
-		#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-		async fn test_send_keysend() {
-			let (bitcoind, electrs, ext) = $setup_clients().await;
-			let node = setup_ldk_node();
-			common::scenarios::setup_interop_test(&node, &ext, &bitcoind, &electrs).await;
-			let ext_node_id = ext.get_node_id().await.unwrap();
-			let (user_ch, _ext_ch) = common::scenarios::channel::open_channel_to_external(
-				&node,
-				&ext,
-				&bitcoind,
-				&electrs,
-				1_000_000,
-				Some(500_000_000),
-			)
-			.await;
-			node.spontaneous_payment().send(5_000_000, ext_node_id, None).unwrap();
-			common::expect_event!(node, PaymentSuccessful);
-			common::scenarios::channel::cooperative_close_by_ldk(
-				&node, &ext, &bitcoind, &electrs, &user_ch,
-			)
-			.await;
-			node.stop().unwrap();
-		}
 	};
 }
 

tests/common/scenarios/suite.rs

@@ -25,11 +25,16 @@ use super::connectivity::{
 };
 use super::payment::{
 	bidirectional_payments, concurrent_payments, pay_expired_invoice, receive_bolt11_payment,
+	receive_keysend_payment,
 };
 use super::{CloseType, PayType, Phase, Side};
 
 /// Run the standard interop test sequence that is identical across all implementations.
 ///
+/// Covers: basic channel cycle (BOLT11 send/receive), disconnect/reconnect, force close
+/// (both sides), inbound channels, bidirectional payments, expired invoices, concurrent
+/// payments, keysend (send + receive), and fee-change close scenarios.
+///
 /// Caller must have called `setup_interop_test` before this function.
 /// Does NOT call `node.stop()` -- caller handles that.
 pub(crate) async fn run_common_tests<E: ElectrumApi>(
@@ -87,6 +92,15 @@ pub(crate) async fn run_common_tests<E: ElectrumApi>(
 	concurrent_payments(node, peer, 5, 1_000_000).await;
 	cooperative_close_by_ldk(node, peer, bitcoind, electrs, &user_ch).await;
 
+	// Keysend (send + receive in one channel)
+	let (user_ch, _ext_ch) =
+		open_channel_to_external(node, peer, bitcoind, electrs, 1_000_000, Some(500_000_000)).await;
+	let ext_node_id = peer.get_node_id().await.unwrap();
+	node.spontaneous_payment().send(5_000_000, ext_node_id, None).unwrap();
+	expect_event!(node, PaymentSuccessful);
+	receive_keysend_payment(node, peer, 5_000_000).await;
+	cooperative_close_by_ldk(node, peer, bitcoind, electrs, &user_ch).await;
+
 	// Fee change scenarios
 	cooperative_close_after_fee_change(node, peer, bitcoind, electrs).await;
 
@@ -124,6 +138,10 @@ async fn run_combo<E: ElectrumApi>(
 			node.bolt11_payment().send(&parsed, None).unwrap();
 			expect_event!(node, PaymentSuccessful);
 		},
+		PayType::Keysend => {
+			node.spontaneous_payment().send(payment_amount_msat, ext_node_id, None).unwrap();
+			expect_event!(node, PaymentSuccessful);
+		},
 	}
 
 	close_channel(
@@ -139,7 +157,7 @@ async fn run_combo<E: ElectrumApi>(
 	.await;
 }
 
-/// Run all 16 combo permutations (phase × disconnect side × close type × close initiator).
+/// Run all 32 combo permutations (phase × disconnect side × close type × close initiator × pay type).
 ///
 /// Caller must have called `setup_interop_test` before this function.
 /// Does NOT call `node.stop()` -- caller handles that.
@@ -164,28 +182,21 @@ pub(crate) async fn run_combos<E: ElectrumApi>(
 		(Phase::Idle, Side::External, CloseType::Force, Side::Ldk),
 		(Phase::Idle, Side::External, CloseType::Force, Side::External),
 	];
-
-	for (i, (phase, disc, close, initiator)) in combos.iter().enumerate() {
-		println!(
-			"=== combo {}/{}: {:?} {:?} {:?} {:?} ===",
-			i + 1,
-			combos.len(),
-			phase,
-			disc,
-			close,
-			initiator
-		);
-		run_combo(
-			node,
-			peer,
-			bitcoind,
-			electrs,
-			*phase,
-			*disc,
-			*close,
-			*initiator,
-			PayType::Bolt11,
-		)
-		.await;
+	let pay_types = [PayType::Bolt11, PayType::Keysend];
+	let total = combos.len() * pay_types.len();
+
+	let mut i = 0;
+	for (phase, disc, close, initiator) in combos.iter() {
+		for pay_type in pay_types.iter() {
+			i += 1;
+			println!(
+				"=== combo {}/{}: {:?} {:?} {:?} {:?} {:?} ===",
+				i, total, phase, disc, close, initiator, pay_type
+			);
+			run_combo(
+				node, peer, bitcoind, electrs, *phase, *disc, *close, *initiator, *pay_type,
+			)
+			.await;
+		}
 	}
 }

tests/integration_tests_cln.rs

@@ -15,7 +15,6 @@ use common::cln::TestClnNode;
 use common::external_node::ExternalNode;
 use common::scenarios::channel::{cooperative_close_by_ldk, open_channel_to_external};
 use common::scenarios::interop_tests;
-use common::scenarios::payment::receive_keysend_payment;
 use common::scenarios::setup_interop_test;
 use electrsd::corepc_client::client_sync::Auth;
 use electrsd::corepc_node::Client as BitcoindClient;
@@ -37,8 +36,12 @@ interop_tests!(setup_clients);
 
 /// Test splice-in: LDK adds funds to an existing LDK↔CLN channel.
 /// Requires CLN --experimental-splicing (advertises OPT_SPLICE bit 62).
+///
+/// Known issue: rust-lightning panics during tx_signatures exchange
+/// (channel.rs debug_assert). Fix merged in rust-lightning#4472 but not yet
+/// in the pinned rev. Will pass once ldk-node bumps rust-lightning.
+/// Tracking: ldk-node#857
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-#[ignore = "rust-lightning panics during tx_signatures exchange (channel.rs debug_assert), fix merged in rust-lightning#4472 but not yet in pinned rev, see ldk-node#857"]
 async fn test_cln_splice_in() {
 	let (bitcoind, electrs, cln) = setup_clients().await;
 	let node = setup_ldk_node();
@@ -66,20 +69,3 @@ async fn test_cln_splice_in() {
 	cooperative_close_by_ldk(&node, &cln, &bitcoind, &electrs, &user_ch).await;
 	node.stop().unwrap();
 }
-
-/// CLN keysend plugin sets min_final_cltv_expiry=22, but LDK requires at least
-/// 42 (HTLC_FAIL_BACK_BUFFER(39) + 3). CLN's keysend RPC has no parameter to
-/// override this value. See: plugins/keysend.c in CLN source.
-#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-#[ignore = "CLN keysend final_cltv=22 < LDK minimum 42 -- needs CLN upstream fix"]
-async fn test_cln_receive_keysend() {
-	let (bitcoind, electrs, cln) = setup_clients().await;
-	let node = setup_ldk_node();
-	setup_interop_test(&node, &cln, &bitcoind, &electrs).await;
-	let (user_ch, _ext_ch) =
-		open_channel_to_external(&node, &cln, &bitcoind, &electrs, 1_000_000, Some(500_000_000))
-			.await;
-	receive_keysend_payment(&node, &cln, 5_000_000).await;
-	cooperative_close_by_ldk(&node, &cln, &bitcoind, &electrs, &user_ch).await;
-	node.stop().unwrap();
-}

tests/integration_tests_eclair.rs

@@ -11,10 +11,7 @@ mod common;
 
 use base64::prelude::{Engine as _, BASE64_STANDARD};
 use common::eclair::TestEclairNode;
-use common::external_node::ExternalNode;
-use common::scenarios::channel::{cooperative_close_by_ldk, open_channel_to_external};
 use common::scenarios::interop_tests;
-use common::scenarios::payment::receive_keysend_payment;
 use common::scenarios::setup_interop_test;
 use electrsd::corepc_client::client_sync::Auth;
 use electrsd::corepc_node::Client as BitcoindClient;
@@ -50,16 +47,3 @@ async fn setup_clients() -> (BitcoindClient, ElectrumClient, TestEclairNode) {
 }
 
 interop_tests!(setup_clients);
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-async fn test_eclair_receive_keysend() {
-	let (bitcoind, electrs, eclair) = setup_clients().await;
-	let node = setup_ldk_node();
-	setup_interop_test(&node, &eclair, &bitcoind, &electrs).await;
-	let (user_ch, _ext_ch) =
-		open_channel_to_external(&node, &eclair, &bitcoind, &electrs, 1_000_000, Some(500_000_000))
-			.await;
-	receive_keysend_payment(&node, &eclair, 5_000_000).await;
-	cooperative_close_by_ldk(&node, &eclair, &bitcoind, &electrs, &user_ch).await;
-	node.stop().unwrap();
-}

tests/integration_tests_lnd.rs

@@ -9,11 +9,8 @@
 
 mod common;
 
-use common::external_node::ExternalNode;
 use common::lnd::TestLndNode;
-use common::scenarios::channel::{cooperative_close_by_ldk, open_channel_to_external};
 use common::scenarios::interop_tests;
-use common::scenarios::payment::receive_keysend_payment;
 use common::scenarios::setup_interop_test;
 use electrsd::corepc_client::client_sync::Auth;
 use electrsd::corepc_node::Client as BitcoindClient;
@@ -32,16 +29,3 @@ async fn setup_clients() -> (BitcoindClient, ElectrumClient, TestLndNode) {
 }
 
 interop_tests!(setup_clients);
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-async fn test_lnd_receive_keysend() {
-	let (bitcoind, electrs, lnd) = setup_clients().await;
-	let node = setup_ldk_node();
-	setup_interop_test(&node, &lnd, &bitcoind, &electrs).await;
-	let (user_ch, _ext_ch) =
-		open_channel_to_external(&node, &lnd, &bitcoind, &electrs, 1_000_000, Some(500_000_000))
-			.await;
-	receive_keysend_payment(&node, &lnd, 5_000_000).await;
-	cooperative_close_by_ldk(&node, &lnd, &bitcoind, &electrs, &user_ch).await;
-	node.stop().unwrap();
-}