tests: Add interoperability tests for BOLT12 (Offers) with CLN

tests/common/cln.rs

@@ -181,6 +181,41 @@ impl ExternalNode for TestClnNode {
 		Ok(invoice.bolt11)
 	}
 
+	async fn create_offer(
+		&self, amount_msat: u64, description: &str,
+	) -> Result<String, TestFailure> {
+		let desc = description.to_string();
+		let label = format!(
+			"{}-{}",
+			desc,
+			std::time::SystemTime::now()
+				.duration_since(std::time::UNIX_EPOCH)
+				.unwrap_or_default()
+				.as_nanos()
+		);
+
+		let params = serde_json::json!({
+			"amount": format!("{}msat", amount_msat),
+			"description": desc,
+			"label": label,
+			"single_use": true,
+		});
+
+		let response: serde_json::Value = self
+			.rpc(move |c| c.call("offer", params))
+			.await
+			.map_err(|e| self.make_error(format!("offer RPC call failed: {}", e)))?;
+
+		let offer_str = response["bolt12"]
+			.as_str()
+			.ok_or_else(|| {
+				self.make_error("Failed to parse 'bolt12' from CLN response".to_string())
+			})?
+			.to_string();
+
+		Ok(offer_str)
+	}
+
 	async fn pay_invoice(&self, invoice: &str) -> Result<String, TestFailure> {
 		let inv = invoice.to_string();
 		let result = self
@@ -190,6 +225,40 @@ impl ExternalNode for TestClnNode {
 		Ok(result.payment_preimage)
 	}
 
+	async fn pay_offer(
+		&self, offer_str: &str, amount_msat: Option<u64>,
+	) -> Result<String, TestFailure> {
+		let offer = offer_str.to_string();
+
+		let mut fetch_params = serde_json::json!({
+			"offer": offer,
+			"quantity": 1,
+		});
+
+		if let Some(msat) = amount_msat {
+			fetch_params["amount_msat"] = serde_json::json!(format!("{}msat", msat));
+		}
+
+		let fetch_response: serde_json::Value =
+			self.rpc(move |c| c.call("fetchinvoice", fetch_params)).await.map_err(|e| {
+				self.make_error(format!("fetchinvoice RPC call failed for BOLT12: {}", e))
+			})?;
+
+		let inv = fetch_response["invoice"]
+			.as_str()
+			.ok_or_else(|| {
+				self.make_error("Failed to parse 'invoice' from fetchinvoice response".to_string())
+			})?
+			.to_string();
+
+		let result = self
+			.rpc(move |c| c.pay(&inv, PayOptions::default()))
+			.await
+			.map_err(|e| self.make_error(format!("pay: {}", e)))?;
+
+		Ok(result.payment_preimage)
+	}
+
 	async fn send_keysend(
 		&self, peer_id: PublicKey, amount_msat: u64,
 	) -> Result<String, TestFailure> {

tests/common/eclair.rs

@@ -211,6 +211,12 @@ impl ExternalNode for TestEclairNode {
 		Ok(invoice.to_string())
 	}
 
+	async fn create_offer(
+		&self, amount_msat: u64, description: &str,
+	) -> Result<String, TestFailure> {
+		Err(self.make_error("create_offer is not supported on Eclair".to_string()))
+	}
+
 	async fn pay_invoice(&self, invoice: &str) -> Result<String, TestFailure> {
 		let result = self.post("/payinvoice", &[("invoice", invoice)]).await?;
 		let payment_id = result
@@ -220,6 +226,12 @@ impl ExternalNode for TestEclairNode {
 		self.poll_payment_settlement(&payment_id, "payment").await
 	}
 
+	async fn pay_offer(
+		&self, _offer_str: &str, _amount_msat: Option<u64>,
+	) -> Result<String, TestFailure> {
+		Err(self.make_error("pay_offer is not supported on Eclair".to_string()))
+	}
+
 	async fn send_keysend(
 		&self, peer_id: PublicKey, amount_msat: u64,
 	) -> Result<String, TestFailure> {

tests/common/external_node.rs

@@ -87,9 +87,19 @@ pub(crate) trait ExternalNode: Send + Sync {
 		&self, amount_msat: u64, description: &str,
 	) -> Result<String, TestFailure>;
 
+	/// Create a BOLT12 offer for the given amount
+	async fn create_offer(
+		&self, amount_msat: u64, description: &str,
+	) -> Result<String, TestFailure>;
+
 	/// Pay a BOLT11 invoice; returns an implementation-specific payment identifier on success.
 	async fn pay_invoice(&self, invoice: &str) -> Result<String, TestFailure>;
 
+	/// Pay a BOLT12 offer; returns an implementation-specific payment identifier on success.
+	async fn pay_offer(
+		&self, offer_str: &str, amount_msat: Option<u64>,
+	) -> Result<String, TestFailure>;
+
 	/// Send a keysend payment to a peer.
 	async fn send_keysend(
 		&self, peer_id: PublicKey, amount_msat: u64,

tests/common/lnd.rs

@@ -243,6 +243,14 @@ impl ExternalNode for TestLndNode {
 		Ok(response.payment_request)
 	}
 
+	async fn create_offer(
+		&self, amount_msat: u64, description: &str,
+	) -> Result<String, TestFailure> {
+		Err(self.make_error(
+			"create_offer is not supported on LND without LNDK integration".to_string(),
+		))
+	}
+
 	async fn pay_invoice(&self, invoice: &str) -> Result<String, TestFailure> {
 		let mut client = self.client.lock().await;
 		let request = SendPaymentRequest {
@@ -280,6 +288,13 @@ impl ExternalNode for TestLndNode {
 		Err(self.make_error("payment stream ended without terminal status"))
 	}
 
+	async fn pay_offer(
+		&self, _offer_str: &str, _amount_msat: Option<u64>,
+	) -> Result<String, TestFailure> {
+		Err(self
+			.make_error("pay_offer is not supported on LND without LNDK integration".to_string()))
+	}
+
 	async fn send_keysend(
 		&self, peer_id: PublicKey, amount_msat: u64,
 	) -> Result<String, TestFailure> {

tests/common/mod.rs

@@ -216,10 +216,30 @@ macro_rules! expect_payment_received_event {
 			panic!("{} timed out waiting for PaymentReceived event after 60s", $node.node_id())
 		});
 		match event {
-			ref e @ Event::PaymentReceived { payment_id, amount_msat, .. } => {
+			ref e @ Event::PaymentReceived { payment_id, amount_msat: rec_msat, .. } => {
 				println!("{} got event {:?}", $node.node_id(), e);
-				assert_eq!(amount_msat, $amount_msat);
+
 				let payment = $node.payment(&payment_id.unwrap()).unwrap();
+
+				match payment.kind {
+					ldk_node::payment::PaymentKind::Bolt12Offer { .. } => {
+						// BOLT12: Blinded paths can lead to minor overpayments (e.g., routing path fees)
+						assert!(
+							rec_msat >= $amount_msat,
+							"BOLT12: Received amount ({}) is less than expected ({})",
+							rec_msat,
+							$amount_msat
+						);
+					},
+					_ => {
+						assert_eq!(
+							rec_msat, $amount_msat,
+							"BOLT11/Keysend: Received amount ({}) does not match expected ({})",
+							rec_msat, $amount_msat
+						);
+					},
+				}
+
 				if !matches!(payment.kind, ldk_node::payment::PaymentKind::Onchain { .. }) {
 					assert_eq!(payment.fee_paid_msat, None);
 				}

tests/common/scenarios/mod.rs

@@ -151,7 +151,7 @@ pub(crate) async fn run_interop_scenario<N, E, F>(
 }
 
 /// Open a channel, send a BOLT11 payment in each direction, then cooperatively close.
-pub(crate) async fn basic_channel_cycle_scenario<E: ElectrumApi>(
+pub(crate) async fn basic_channel_cycle_bolt11_scenario<E: ElectrumApi>(
 	node: &Node, peer: &(impl ExternalNode + ?Sized), bitcoind: &BitcoindClient, electrs: &E,
 ) {
 	let (user_ch, ext_ch) = channel::open_channel_to_external(
@@ -164,12 +164,32 @@ pub(crate) async fn basic_channel_cycle_scenario<E: ElectrumApi>(
 	)
 	.await;
 
-	payment::send_bolt11_to_peer(node, peer, 10_000_000, "basic-send").await;
+	payment::send_bolt11_to_peer(node, peer, 10_000_000, "basic-send-bolt11").await;
 	payment::receive_bolt11_payment(node, peer, 10_000_000).await;
 
 	channel::cooperative_close(node, peer, bitcoind, electrs, &user_ch, &ext_ch, Side::Ldk).await;
 }
 
+/// Open a channel, send a BOLT12 payment in each direction, then cooperatively close.
+pub(crate) async fn basic_channel_cycle_bolt12_scenario<E: ElectrumApi>(
+	node: &Node, peer: &(impl ExternalNode + ?Sized), bitcoind: &BitcoindClient, electrs: &E,
+) {
+	let (user_ch, ext_ch) = channel::open_channel_to_external(
+		node,
+		peer,
+		bitcoind,
+		electrs,
+		1_000_000,
+		Some(500_000_000),
+	)
+	.await;
+
+	payment::send_bolt12_to_peer(node, peer, 10_000_000, "basic-send-bolt12").await;
+	payment::receive_bolt12_payment(node, peer, 10_000_000).await;
+
+	channel::cooperative_close(node, peer, bitcoind, electrs, &user_ch, &ext_ch, Side::Ldk).await;
+}
+
 /// Open a channel, send keysend in both directions, then cooperatively close.
 pub(crate) async fn keysend_scenario<E: ElectrumApi>(
 	node: &Node, peer: &(impl ExternalNode + ?Sized), bitcoind: &BitcoindClient, electrs: &E,
@@ -188,8 +208,8 @@ pub(crate) async fn keysend_scenario<E: ElectrumApi>(
 	channel::cooperative_close(node, peer, bitcoind, electrs, &user_ch, &ext_ch, Side::Ldk).await;
 }
 
-/// Open a channel, send a payment, then force-close from the LDK side.
-pub(crate) async fn force_close_after_payment_scenario<E: ElectrumApi>(
+/// Open a channel, send a BOLT11 payment, then force-close from the LDK side.
+pub(crate) async fn force_close_after_payment_bolt11_scenario<E: ElectrumApi>(
 	node: &Node, peer: &(impl ExternalNode + ?Sized), bitcoind: &BitcoindClient, electrs: &E,
 ) {
 	let (user_ch, ext_ch) = channel::open_channel_to_external(
@@ -201,7 +221,25 @@ pub(crate) async fn force_close_after_payment_scenario<E: ElectrumApi>(
 		Some(500_000_000),
 	)
 	.await;
-	payment::send_bolt11_to_peer(node, peer, 5_000_000, "force-close").await;
+	payment::send_bolt11_to_peer(node, peer, 5_000_000, "force-close-bolt11").await;
+	wait_for_htlcs_settled(peer, &ext_ch).await;
+	channel::force_close(node, peer, bitcoind, electrs, &user_ch, &ext_ch, Side::Ldk).await;
+}
+
+/// Open a channel, send a BOLT12 payment, then force-close from the LDK side.
+pub(crate) async fn force_close_after_payment_bolt12_scenario<E: ElectrumApi>(
+	node: &Node, peer: &(impl ExternalNode + ?Sized), bitcoind: &BitcoindClient, electrs: &E,
+) {
+	let (user_ch, ext_ch) = channel::open_channel_to_external(
+		node,
+		peer,
+		bitcoind,
+		electrs,
+		1_000_000,
+		Some(500_000_000),
+	)
+	.await;
+	payment::send_bolt12_to_peer(node, peer, 5_000_000, "force-close-bolt12").await;
 	wait_for_htlcs_settled(peer, &ext_ch).await;
 	channel::force_close(node, peer, bitcoind, electrs, &user_ch, &ext_ch, Side::Ldk).await;
 }
@@ -225,8 +263,33 @@ pub(crate) async fn disconnect_during_payment_scenario<E: ElectrumApi>(
 	channel::cooperative_close(node, peer, bitcoind, electrs, &user_ch, &ext_ch, Side::Ldk).await;
 }
 
-/// Open a channel, splice-in additional funds, send a post-splice payment, then close.
-pub(crate) async fn splice_in_scenario<E: ElectrumApi>(
+/// Open a channel, splice-in additional funds, send a post-splice BOLT11 payment, then close.
+pub(crate) async fn splice_in_bolt11_scenario<E: ElectrumApi>(
+	node: &Node, peer: &(impl ExternalNode + ?Sized), bitcoind: &BitcoindClient, electrs: &E,
+) {
+	let (user_ch, ext_ch) = channel::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.splice_in(&user_ch, ext_node_id, 500_000).unwrap();
+	expect_splice_pending_event!(node, ext_node_id);
+	generate_blocks_and_wait(bitcoind, electrs, 6).await;
+	sync_wallets_with_retry(node).await;
+	expect_channel_ready_event!(node, ext_node_id);
+
+	payment::send_bolt11_to_peer(node, peer, 5_000_000, "post-splice-bolt11").await;
+
+	channel::cooperative_close(node, peer, bitcoind, electrs, &user_ch, &ext_ch, Side::Ldk).await;
+}
+
+/// Open a channel, splice-in additional funds, send a post-splice BOLT12 payment, then close.
+pub(crate) async fn splice_in_bolt12_scenario<E: ElectrumApi>(
 	node: &Node, peer: &(impl ExternalNode + ?Sized), bitcoind: &BitcoindClient, electrs: &E,
 ) {
 	let (user_ch, ext_ch) = channel::open_channel_to_external(
@@ -245,7 +308,7 @@ pub(crate) async fn splice_in_scenario<E: ElectrumApi>(
 	sync_wallets_with_retry(node).await;
 	expect_channel_ready_event!(node, ext_node_id);
 
-	payment::send_bolt11_to_peer(node, peer, 5_000_000, "post-splice").await;
+	payment::send_bolt12_to_peer(node, peer, 5_000_000, "post-splice-bolt12").await;
 
 	channel::cooperative_close(node, peer, bitcoind, electrs, &user_ch, &ext_ch, Side::Ldk).await;
 }

tests/common/scenarios/payment.rs

@@ -7,11 +7,11 @@
 
 use std::str::FromStr;
 
-use ldk_node::{Event, Node};
-use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, Description};
-
 use super::super::external_node::ExternalNode;
 use super::retry_until_ok;
+use ldk_node::{Event, Node};
+use lightning::offers::offer::Offer;
+use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, Description};
 
 /// LDK pays the peer via a fresh BOLT11 invoice; asserts `PaymentSuccessful`.
 pub(crate) async fn send_bolt11_to_peer(
@@ -23,6 +23,16 @@ pub(crate) async fn send_bolt11_to_peer(
 	expect_event!(node, PaymentSuccessful);
 }
 
+/// LDK pays the peer via a fresh BOLT12 offer; asserts `PaymentSuccessful`.
+pub(crate) async fn send_bolt12_to_peer(
+	node: &Node, peer: &(impl ExternalNode + ?Sized), amount_msat: u64, label: &str,
+) {
+	let offer_str = peer.create_offer(amount_msat, label).await.unwrap();
+	let parsed_offer = Offer::from_str(&offer_str).unwrap();
+	node.bolt12_payment().send(&parsed_offer, None, None, None).unwrap();
+	expect_event!(node, PaymentSuccessful);
+}
+
 /// External node pays LDK via BOLT11 invoice. Retries to absorb gossip-propagation
 /// delay (peer may not yet know a route to LDK right after channel confirmation).
 pub(crate) async fn receive_bolt11_payment(
@@ -33,7 +43,7 @@ pub(crate) async fn receive_bolt11_payment(
 		.receive(
 			amount_msat,
 			&Bolt11InvoiceDescription::Direct(
-				Description::new("interop-receive-test".to_string()).unwrap(),
+				Description::new("interop-receive-test-bolt11".to_string()).unwrap(),
 			),
 			3600,
 		)
@@ -43,6 +53,21 @@ pub(crate) async fn receive_bolt11_payment(
 	expect_payment_received_event!(node, amount_msat);
 }
 
+/// External node pays LDK via BOLT12 offer. Retries to absorb gossip-propagation
+/// delay (peer may not yet know a route to LDK right after channel confirmation).
+pub(crate) async fn receive_bolt12_payment(
+	node: &Node, peer: &(impl ExternalNode + ?Sized), amount_msat: u64,
+) {
+	let offer = node
+		.bolt12_payment()
+		.receive(amount_msat, "interop-receive-test-bolt12", Some(3600), Some(1))
+		.unwrap();
+	let offer_str = offer.to_string();
+	retry_until_ok(10, "receive_bolt12_payment", || peer.pay_offer(&offer_str, Some(amount_msat)))
+		.await;
+	expect_payment_received_event!(node, amount_msat);
+}
+
 /// LDK keysends to peer; asserts `PaymentSuccessful`.
 pub(crate) async fn send_keysend_to_peer(
 	node: &Node, peer: &(impl ExternalNode + ?Sized), amount_msat: u64,