Add shared interop test scenarios and entry points

- Shared scenarios in tests/common/scenarios/ generic over ExternalNode
- Test entry points for LND, CLN, and Eclair
- Combo orchestrator (combo.rs) with interop_combo_tests! macro generating
  16 tests per implementation (phase × disconnect side × close type × initiator)
- Building blocks use no test_ prefix; full scenarios include setup internally
- #[ignore] annotations for known interop failures:
  CLN keysend (payment_secret issue), Eclair keysend (InvalidOnionPayload),
  CLN/Eclair splice (version requirements)

Co-authored-by: AI (Claude Code)

Author: febyeji

tests/common/mod.rs

@@ -5,7 +5,7 @@
 // http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
 // accordance with one or both of these licenses.
 
-#![cfg(any(test, cln_test, lnd_test, vss_test))]
+#![cfg(any(test, cln_test, lnd_test, eclair_test, vss_test))]
 #![allow(dead_code)]
 
 pub(crate) mod external_node;
@@ -56,9 +56,24 @@ use rand::distr::Alphanumeric;
 use rand::{rng, Rng};
 use serde_json::{json, Value};
 
+/// Shared timeout (in seconds) for waiting on LDK events and external node operations.
+pub(crate) const INTEROP_TIMEOUT_SECS: u64 = 60;
+
 macro_rules! expect_event {
 	($node:expr, $event_type:ident) => {{
-		match $node.next_event_async().await {
+		let event = tokio::time::timeout(
+			std::time::Duration::from_secs(crate::common::INTEROP_TIMEOUT_SECS),
+			$node.next_event_async(),
+		)
+		.await
+		.unwrap_or_else(|_| {
+			panic!(
+				"{} timed out waiting for {} event after 60s",
+				$node.node_id(),
+				std::stringify!($event_type)
+			)
+		});
+		match event {
 			ref e @ Event::$event_type { .. } => {
 				println!("{} got event {:?}", $node.node_id(), e);
 				$node.event_handled().unwrap();
@@ -74,7 +89,15 @@ pub(crate) use expect_event;
 
 macro_rules! expect_channel_pending_event {
 	($node:expr, $counterparty_node_id:expr) => {{
-		match $node.next_event_async().await {
+		let event = tokio::time::timeout(
+			std::time::Duration::from_secs(crate::common::INTEROP_TIMEOUT_SECS),
+			$node.next_event_async(),
+		)
+		.await
+		.unwrap_or_else(|_| {
+			panic!("{} timed out waiting for ChannelPending event after 60s", $node.node_id())
+		});
+		match event {
 			ref e @ Event::ChannelPending { funding_txo, counterparty_node_id, .. } => {
 				println!("{} got event {:?}", $node.node_id(), e);
 				assert_eq!(counterparty_node_id, $counterparty_node_id);
@@ -92,7 +115,15 @@ pub(crate) use expect_channel_pending_event;
 
 macro_rules! expect_channel_ready_event {
 	($node:expr, $counterparty_node_id:expr) => {{
-		match $node.next_event_async().await {
+		let event = tokio::time::timeout(
+			std::time::Duration::from_secs(crate::common::INTEROP_TIMEOUT_SECS),
+			$node.next_event_async(),
+		)
+		.await
+		.unwrap_or_else(|_| {
+			panic!("{} timed out waiting for ChannelReady event after 60s", $node.node_id())
+		});
+		match event {
 			ref e @ Event::ChannelReady { user_channel_id, counterparty_node_id, .. } => {
 				println!("{} got event {:?}", $node.node_id(), e);
 				assert_eq!(counterparty_node_id, Some($counterparty_node_id));
@@ -112,7 +143,15 @@ macro_rules! expect_channel_ready_events {
 	($node:expr, $counterparty_node_id_a:expr, $counterparty_node_id_b:expr) => {{
 		let mut ids = Vec::new();
 		for _ in 0..2 {
-			match $node.next_event_async().await {
+			let event = tokio::time::timeout(
+				std::time::Duration::from_secs(crate::common::INTEROP_TIMEOUT_SECS),
+				$node.next_event_async(),
+			)
+			.await
+			.unwrap_or_else(|_| {
+				panic!("{} timed out waiting for ChannelReady event after 60s", $node.node_id())
+			});
+			match event {
 				ref e @ Event::ChannelReady { counterparty_node_id, .. } => {
 					println!("{} got event {:?}", $node.node_id(), e);
 					ids.push(counterparty_node_id);
@@ -138,7 +177,15 @@ pub(crate) use expect_channel_ready_events;
 
 macro_rules! expect_splice_pending_event {
 	($node:expr, $counterparty_node_id:expr) => {{
-		match $node.next_event_async().await {
+		let event = tokio::time::timeout(
+			std::time::Duration::from_secs(crate::common::INTEROP_TIMEOUT_SECS),
+			$node.next_event_async(),
+		)
+		.await
+		.unwrap_or_else(|_| {
+			panic!("{} timed out waiting for SplicePending event after 60s", $node.node_id())
+		});
+		match event {
 			ref e @ Event::SplicePending { new_funding_txo, counterparty_node_id, .. } => {
 				println!("{} got event {:?}", $node.node_id(), e);
 				assert_eq!(counterparty_node_id, $counterparty_node_id);
@@ -156,19 +203,27 @@ pub(crate) use expect_splice_pending_event;
 
 macro_rules! expect_payment_received_event {
 	($node:expr, $amount_msat:expr) => {{
-		match $node.next_event_async().await {
+		let event = tokio::time::timeout(
+			std::time::Duration::from_secs(crate::common::INTEROP_TIMEOUT_SECS),
+			$node.next_event_async(),
+		)
+		.await
+		.unwrap_or_else(|_| {
+			panic!("{} timed out waiting for PaymentReceived event after 60s", $node.node_id())
+		});
+		match event {
 			ref e @ Event::PaymentReceived { payment_id, amount_msat, .. } => {
 				println!("{} got event {:?}", $node.node_id(), e);
 				assert_eq!(amount_msat, $amount_msat);
 				let payment = $node.payment(&payment_id.unwrap()).unwrap();
-				if !matches!(payment.kind, PaymentKind::Onchain { .. }) {
+				if !matches!(payment.kind, ldk_node::payment::PaymentKind::Onchain { .. }) {
 					assert_eq!(payment.fee_paid_msat, None);
 				}
 				$node.event_handled().unwrap();
 				payment_id
 			},
 			ref e => {
-				panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e);
+				panic!("{} got unexpected event!: {:?}", std::stringify!($node), e);
 			},
 		}
 	}};
@@ -178,7 +233,18 @@ pub(crate) use expect_payment_received_event;
 
 macro_rules! expect_payment_claimable_event {
 	($node:expr, $payment_id:expr, $payment_hash:expr, $claimable_amount_msat:expr) => {{
-		match $node.next_event_async().await {
+		let event = tokio::time::timeout(
+			std::time::Duration::from_secs(crate::common::INTEROP_TIMEOUT_SECS),
+			$node.next_event_async(),
+		)
+		.await
+		.unwrap_or_else(|_| {
+			panic!(
+				"{} timed out waiting for PaymentClaimable event after 60s",
+				std::stringify!($node)
+			)
+		});
+		match event {
 			ref e @ Event::PaymentClaimable {
 				payment_id,
 				payment_hash,
@@ -203,7 +269,15 @@ pub(crate) use expect_payment_claimable_event;
 
 macro_rules! expect_payment_successful_event {
 	($node:expr, $payment_id:expr, $fee_paid_msat:expr) => {{
-		match $node.next_event_async().await {
+		let event = tokio::time::timeout(
+			std::time::Duration::from_secs(crate::common::INTEROP_TIMEOUT_SECS),
+			$node.next_event_async(),
+		)
+		.await
+		.unwrap_or_else(|_| {
+			panic!("{} timed out waiting for PaymentSuccessful event after 60s", $node.node_id())
+		});
+		match event {
 			ref e @ Event::PaymentSuccessful { payment_id, fee_paid_msat, .. } => {
 				println!("{} got event {:?}", $node.node_id(), e);
 				if let Some(fee_msat) = $fee_paid_msat {
@@ -388,6 +462,9 @@ macro_rules! setup_builder {
 
 pub(crate) use setup_builder;
 
+#[cfg(any(cln_test, lnd_test, eclair_test))]
+pub(crate) mod scenarios;
+
 pub(crate) fn setup_two_nodes(
 	chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool,
 	anchors_trusted_no_reserve: bool,
@@ -1697,3 +1774,72 @@ impl TestSyncStoreInner {
 		self.do_list(primary_namespace, secondary_namespace)
 	}
 }
+
+/// Generates 16 individual `#[tokio::test]` functions covering every combination
+/// of (Phase, disconnect Side, CloseType, close Side):
+///   2 phases × 2 disconnect sides × 2 close types × 2 close initiators = 16.
+///
+/// PayType is fixed to Bolt11 — keysend vs bolt11 doesn't affect channel close
+/// behavior and is already covered by dedicated named tests (`test_*_receive_keysend`,
+/// `test_*_receive_payments`). Do NOT add a Keysend axis here: CLN and Eclair
+/// have known keysend interop issues (see `#[ignore]` tests in their entry points).
+///
+/// Usage (inside each `integration_tests_*.rs`):
+/// ```ignore
+/// interop_combo_tests!(test_lnd, setup_clients, setup_ldk_node);
+/// ```
+#[macro_export]
+macro_rules! interop_combo_tests {
+	($prefix:ident, $setup_clients:ident, $setup_ldk_node:ident) => {
+		$crate::interop_combo_tests!(
+			@phase $prefix, $setup_clients, $setup_ldk_node,
+			[payment, Phase::Payment], [idle, Phase::Idle]
+		);
+	};
+
+	(@phase $prefix:ident, $sc:ident, $sn:ident, $([$pn:ident, $pv:expr]),+) => {
+		$(
+			$crate::interop_combo_tests!(
+				@disc $prefix, $sc, $sn, $pn, $pv,
+				[ldk, Side::Ldk], [ext, Side::External]
+			);
+		)+
+	};
+
+	(@disc $prefix:ident, $sc:ident, $sn:ident, $pn:ident, $pv:expr, $([$dn:ident, $dv:expr]),+) => {
+		$(
+			$crate::interop_combo_tests!(
+				@close $prefix, $sc, $sn, $pn, $pv, $dn, $dv,
+				[coop, CloseType::Cooperative], [force, CloseType::Force]
+			);
+		)+
+	};
+
+	(@close $prefix:ident, $sc:ident, $sn:ident, $pn:ident, $pv:expr, $dn:ident, $dv:expr,
+	 $([$cn:ident, $cv:expr]),+) => {
+		$(
+			$crate::interop_combo_tests!(
+				@ci $prefix, $sc, $sn, $pn, $pv, $dn, $dv, $cn, $cv,
+				[ldk, Side::Ldk], [ext, Side::External]
+			);
+		)+
+	};
+
+	(@ci $prefix:ident, $sc:ident, $sn:ident, $pn:ident, $pv:expr, $dn:ident, $dv:expr,
+	 $cn:ident, $cv:expr, $([$cin:ident, $civ:expr]),+) => {
+		$(
+			paste::paste! {
+				#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+				async fn [<$prefix _combo_ $pn _ $dn _ $cn _ $cin>]() {
+					let (bitcoind, electrs, peer) = $sc().await;
+					let node = $sn();
+					run_interop_combo_test(
+						&node, &peer, &bitcoind, &electrs,
+						$pv, $dv, $cv, $civ, PayType::Bolt11,
+					).await;
+					node.stop().unwrap();
+				}
+			}
+		)+
+	};
+}