Update DefaultMessageRouter to always create compact blinded paths

Reasoning:

This change aligns `DefaultMessageRouter`'s default behavior with the most common
and practical usage: generating compact blinded paths for BOLT12 offers.

While configurability is important, most users won't read all documentation and
will rely on defaults that "just work." In line with this PR's principle—
"One `MessageRouter`, one type of `BlindedPath`"—the previous default would
silently produce full blinded paths, even when a compact one would have been
more appropriate.

In typical setups (e.g., a user connected to a single LSP), the SCID alias
remains stable for the channel's lifetime. Compact paths are not only sufficient
in this case, but also result in smaller, more efficient offers. And if the
alias becomes invalid, a pubkey-based path wouldn't help either—so compact
remains the better default.

In brief: This commit makes the default behavior match what users actually want.

Thanks to [@TheBlueMatt](https://github.com/TheBlueMatt) for the original reasoning.
**Discussion link:** [lightningdevkit#3246 (pull request review)](lightningdevkit#3246 (review))

Author: shaavan

lightning-dns-resolver/src/lib.rs

@@ -456,7 +456,7 @@ mod test {
 	#[tokio::test]
 	async fn end_to_end_test() {
 		let chanmon_cfgs = create_chanmon_cfgs(2);
-		let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+		let node_cfgs = create_node_cfgs_with_node_id_message_router(2, &chanmon_cfgs);
 		let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 		let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 

lightning/src/ln/offers_tests.rs

@@ -149,6 +149,16 @@ fn resolve_introduction_node<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, path: &Blinded
 		.unwrap()
 }
 
+fn check_compact_path_introduction_node<'a, 'b, 'c>(
+    path: &BlindedMessagePath,
+    lookup_node: &Node<'a, 'b, 'c>,
+    expected_introduction_node: PublicKey,
+) -> bool {
+    let introduction_node_id = resolve_introduction_node(lookup_node, path);
+    introduction_node_id == expected_introduction_node
+        && matches!(path.introduction_node(), IntroductionNode::DirectedShortChannelId(..))
+}
+
 fn route_bolt12_payment<'a, 'b, 'c>(
 	node: &Node<'a, 'b, 'c>, path: &[&Node<'a, 'b, 'c>], invoice: &Bolt12Invoice
 ) {
@@ -406,7 +416,7 @@ fn creates_short_lived_offer() {
 #[test]
 fn creates_long_lived_offer() {
 	let chanmon_cfgs = create_chanmon_cfgs(2);
-	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let node_cfgs = create_node_cfgs_with_node_id_message_router(2, &chanmon_cfgs);
 	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
@@ -470,7 +480,7 @@ fn creates_short_lived_refund() {
 #[test]
 fn creates_long_lived_refund() {
 	let chanmon_cfgs = create_chanmon_cfgs(2);
-	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let node_cfgs = create_node_cfgs_with_node_id_message_router(2, &chanmon_cfgs);
 	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
@@ -539,7 +549,7 @@ fn creates_and_pays_for_offer_using_two_hop_blinded_path() {
 	assert_ne!(offer.issuer_signing_pubkey(), Some(alice_id));
 	assert!(!offer.paths().is_empty());
 	for path in offer.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(bob_id));
+		assert!(check_compact_path_introduction_node(&path, alice, bob_id));
 	}
 
 	let payment_id = PaymentId([1; 32]);
@@ -569,7 +579,7 @@ fn creates_and_pays_for_offer_using_two_hop_blinded_path() {
 	});
 	assert_eq!(invoice_request.amount_msats(), Some(10_000_000));
 	assert_ne!(invoice_request.payer_signing_pubkey(), david_id);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(charlie_id));
+	assert!(check_compact_path_introduction_node(&reply_path, bob, charlie_id));
 
 	let onion_message = alice.onion_messenger.next_onion_message_for_peer(charlie_id).unwrap();
 	charlie.onion_messenger.handle_onion_message(alice_id, &onion_message);
@@ -588,10 +598,8 @@ fn creates_and_pays_for_offer_using_two_hop_blinded_path() {
 	// to Alice when she's handling the message. Therefore, either Bob or Charlie could
 	// serve as the introduction node for the reply path back to Alice.
 	assert!(
-		matches!(
-			reply_path.introduction_node(),
-			&IntroductionNode::NodeId(node_id) if node_id == bob_id || node_id == charlie_id,
-		)
+		check_compact_path_introduction_node(&reply_path, david, bob_id) ||
+		check_compact_path_introduction_node(&reply_path, david, charlie_id)
 	);
 
 	route_bolt12_payment(david, &[charlie, bob, alice], &invoice);
@@ -650,7 +658,7 @@ fn creates_and_pays_for_refund_using_two_hop_blinded_path() {
 	assert_ne!(refund.payer_signing_pubkey(), david_id);
 	assert!(!refund.paths().is_empty());
 	for path in refund.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(charlie_id));
+		assert!(check_compact_path_introduction_node(&path, david, charlie_id));
 	}
 	expect_recent_payment!(david, RecentPaymentDetails::AwaitingInvoice, payment_id);
 
@@ -674,8 +682,7 @@ fn creates_and_pays_for_refund_using_two_hop_blinded_path() {
 	for path in invoice.payment_paths() {
 		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(bob_id));
 	}
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(bob_id));
-
+	assert!(check_compact_path_introduction_node(&reply_path, alice, bob_id));
 
 	route_bolt12_payment(david, &[charlie, bob, alice], &invoice);
 	expect_recent_payment!(david, RecentPaymentDetails::Pending, payment_id);
@@ -708,7 +715,7 @@ fn creates_and_pays_for_offer_using_one_hop_blinded_path() {
 	assert_ne!(offer.issuer_signing_pubkey(), Some(alice_id));
 	assert!(!offer.paths().is_empty());
 	for path in offer.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(alice_id));
+		assert!(check_compact_path_introduction_node(&path, bob, alice_id));
 	}
 
 	let payment_id = PaymentId([1; 32]);
@@ -730,7 +737,7 @@ fn creates_and_pays_for_offer_using_one_hop_blinded_path() {
 	});
 	assert_eq!(invoice_request.amount_msats(), Some(10_000_000));
 	assert_ne!(invoice_request.payer_signing_pubkey(), bob_id);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(bob_id));
+	assert!(check_compact_path_introduction_node(&reply_path, alice, bob_id));
 
 	let onion_message = alice.onion_messenger.next_onion_message_for_peer(bob_id).unwrap();
 	bob.onion_messenger.handle_onion_message(alice_id, &onion_message);
@@ -742,7 +749,7 @@ fn creates_and_pays_for_offer_using_one_hop_blinded_path() {
 	for path in invoice.payment_paths() {
 		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(alice_id));
 	}
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(alice_id));
+	assert!(check_compact_path_introduction_node(&reply_path, bob, alice_id));
 
 	route_bolt12_payment(bob, &[alice], &invoice);
 	expect_recent_payment!(bob, RecentPaymentDetails::Pending, payment_id);
@@ -779,7 +786,7 @@ fn creates_and_pays_for_refund_using_one_hop_blinded_path() {
 	assert_ne!(refund.payer_signing_pubkey(), bob_id);
 	assert!(!refund.paths().is_empty());
 	for path in refund.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(bob_id));
+		assert!(check_compact_path_introduction_node(&path, alice, bob_id));
 	}
 	expect_recent_payment!(bob, RecentPaymentDetails::AwaitingInvoice, payment_id);
 
@@ -798,7 +805,7 @@ fn creates_and_pays_for_refund_using_one_hop_blinded_path() {
 	for path in invoice.payment_paths() {
 		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(alice_id));
 	}
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(alice_id));
+	assert!(check_compact_path_introduction_node(&reply_path, bob, alice_id));
 
 	route_bolt12_payment(bob, &[alice], &invoice);
 	expect_recent_payment!(bob, RecentPaymentDetails::Pending, payment_id);
@@ -956,7 +963,7 @@ fn send_invoice_requests_with_distinct_reply_path() {
 	assert_ne!(offer.issuer_signing_pubkey(), Some(alice_id));
 	assert!(!offer.paths().is_empty());
 	for path in offer.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(bob_id));
+		assert!(check_compact_path_introduction_node(&path, alice, bob_id));
 	}
 
 	let payment_id = PaymentId([1; 32]);
@@ -975,7 +982,7 @@ fn send_invoice_requests_with_distinct_reply_path() {
 	alice.onion_messenger.handle_onion_message(bob_id, &onion_message);
 
 	let (_, reply_path) = extract_invoice_request(alice, &onion_message);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(charlie_id));
+	assert!(check_compact_path_introduction_node(&reply_path, alice, charlie_id));
 
 	// Send, extract and verify the second Invoice Request message
 	let onion_message = david.onion_messenger.next_onion_message_for_peer(bob_id).unwrap();
@@ -985,7 +992,7 @@ fn send_invoice_requests_with_distinct_reply_path() {
 	alice.onion_messenger.handle_onion_message(bob_id, &onion_message);
 
 	let (_, reply_path) = extract_invoice_request(alice, &onion_message);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(nodes[6].node.get_our_node_id()));
+	assert!(check_compact_path_introduction_node(&reply_path, alice, nodes[6].node.get_our_node_id()));
 }
 
 /// This test checks that when multiple potential introduction nodes are available for the payee,
@@ -1040,7 +1047,7 @@ fn send_invoice_for_refund_with_distinct_reply_path() {
 		.build().unwrap();
 	assert_ne!(refund.payer_signing_pubkey(), alice_id);
 	for path in refund.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(bob_id));
+		assert!(check_compact_path_introduction_node(&path, alice, bob_id));
 	}
 	expect_recent_payment!(alice, RecentPaymentDetails::AwaitingInvoice, payment_id);
 
@@ -1056,7 +1063,7 @@ fn send_invoice_for_refund_with_distinct_reply_path() {
 	let onion_message = bob.onion_messenger.next_onion_message_for_peer(alice_id).unwrap();
 
 	let (_, reply_path) = extract_invoice(alice, &onion_message);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(charlie_id));
+	assert!(check_compact_path_introduction_node(&reply_path, alice, charlie_id));
 
 	// Send, extract and verify the second Invoice Request message
 	let onion_message = david.onion_messenger.next_onion_message_for_peer(bob_id).unwrap();
@@ -1065,7 +1072,7 @@ fn send_invoice_for_refund_with_distinct_reply_path() {
 	let onion_message = bob.onion_messenger.next_onion_message_for_peer(alice_id).unwrap();
 
 	let (_, reply_path) = extract_invoice(alice, &onion_message);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(nodes[6].node.get_our_node_id()));
+	assert!(check_compact_path_introduction_node(&reply_path, alice, nodes[6].node.get_our_node_id()));
 }
 
 /// Verifies that the invoice request message can be retried if it fails to reach the
@@ -1091,7 +1098,7 @@ fn creates_and_pays_for_offer_with_retry() {
 	assert_ne!(offer.issuer_signing_pubkey(), Some(alice_id));
 	assert!(!offer.paths().is_empty());
 	for path in offer.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(alice_id));
+		assert!(check_compact_path_introduction_node(&path, bob, alice_id));
 	}
 	let payment_id = PaymentId([1; 32]);
 	bob.node.pay_for_offer(&offer, None, None, None, payment_id, Retry::Attempts(0), RouteParametersConfig::default()).unwrap();
@@ -1119,7 +1126,7 @@ fn creates_and_pays_for_offer_with_retry() {
 	});
 	assert_eq!(invoice_request.amount_msats(), Some(10_000_000));
 	assert_ne!(invoice_request.payer_signing_pubkey(), bob_id);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(bob_id));
+	assert!(check_compact_path_introduction_node(&reply_path, alice, bob_id));
 	let onion_message = alice.onion_messenger.next_onion_message_for_peer(bob_id).unwrap();
 	bob.onion_messenger.handle_onion_message(alice_id, &onion_message);
 
@@ -1391,7 +1398,7 @@ fn fails_authentication_when_handling_invoice_request() {
 	assert_ne!(offer.issuer_signing_pubkey(), Some(alice_id));
 	assert!(!offer.paths().is_empty());
 	for path in offer.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(bob_id));
+		assert!(check_compact_path_introduction_node(&path, alice, bob_id));
 	}
 
 	let invalid_path = alice.node
@@ -1400,7 +1407,7 @@ fn fails_authentication_when_handling_invoice_request() {
 		.build().unwrap()
 		.paths().first().unwrap()
 		.clone();
-	assert_eq!(invalid_path.introduction_node(), &IntroductionNode::NodeId(bob_id));
+	assert!(check_compact_path_introduction_node(&invalid_path, alice, bob_id));
 
 	// Send the invoice request directly to Alice instead of using a blinded path.
 	let payment_id = PaymentId([1; 32]);
@@ -1421,7 +1428,7 @@ fn fails_authentication_when_handling_invoice_request() {
 	let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message);
 	assert_eq!(invoice_request.amount_msats(), Some(10_000_000));
 	assert_ne!(invoice_request.payer_signing_pubkey(), david_id);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(charlie_id));
+	assert!(check_compact_path_introduction_node(&reply_path, david, charlie_id));
 
 	assert_eq!(alice.onion_messenger.next_onion_message_for_peer(charlie_id), None);
 
@@ -1451,7 +1458,7 @@ fn fails_authentication_when_handling_invoice_request() {
 	let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message);
 	assert_eq!(invoice_request.amount_msats(), Some(10_000_000));
 	assert_ne!(invoice_request.payer_signing_pubkey(), david_id);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(charlie_id));
+	assert!(check_compact_path_introduction_node(&reply_path, david, charlie_id));
 
 	assert_eq!(alice.onion_messenger.next_onion_message_for_peer(charlie_id), None);
 }
@@ -1502,7 +1509,7 @@ fn fails_authentication_when_handling_invoice_for_offer() {
 	assert_ne!(offer.issuer_signing_pubkey(), Some(alice_id));
 	assert!(!offer.paths().is_empty());
 	for path in offer.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(bob_id));
+		assert!(check_compact_path_introduction_node(&path, alice, bob_id));
 	}
 
 	// Initiate an invoice request, but abandon tracking it.
@@ -1553,7 +1560,7 @@ fn fails_authentication_when_handling_invoice_for_offer() {
 	let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message);
 	assert_eq!(invoice_request.amount_msats(), Some(10_000_000));
 	assert_ne!(invoice_request.payer_signing_pubkey(), david_id);
-	assert_eq!(reply_path.introduction_node(), &IntroductionNode::NodeId(charlie_id));
+	assert!(check_compact_path_introduction_node(&reply_path, david, charlie_id));
 
 	let onion_message = alice.onion_messenger.next_onion_message_for_peer(charlie_id).unwrap();
 	charlie.onion_messenger.handle_onion_message(alice_id, &onion_message);
@@ -1610,7 +1617,7 @@ fn fails_authentication_when_handling_invoice_for_refund() {
 	assert_ne!(refund.payer_signing_pubkey(), david_id);
 	assert!(!refund.paths().is_empty());
 	for path in refund.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(charlie_id));
+		assert!(check_compact_path_introduction_node(&path, david, charlie_id));
 	}
 	expect_recent_payment!(david, RecentPaymentDetails::AwaitingInvoice, payment_id);
 
@@ -1644,7 +1651,7 @@ fn fails_authentication_when_handling_invoice_for_refund() {
 	assert_ne!(refund.payer_signing_pubkey(), david_id);
 	assert!(!refund.paths().is_empty());
 	for path in refund.paths() {
-		assert_eq!(path.introduction_node(), &IntroductionNode::NodeId(charlie_id));
+		assert!(check_compact_path_introduction_node(&path, david, charlie_id));
 	}
 
 	let expected_invoice = alice.node.request_refund_payment(&refund).unwrap();

lightning/src/onion_message/messenger.rs

@@ -521,6 +521,17 @@ pub trait MessageRouter {
 }
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
+/// 
+/// [`DefaultMessageRouter`] constructs compact [`BlindedMessagePath`]s on a best-effort basis.
+/// That is, if appropriate SCID information is available for the intermediate peers, it will
+/// default to creating compact paths.
+///
+/// # Compact Blinded Paths
+///
+/// Compact blinded paths use short channel IDs (SCIDs) instead of pubkeys, resulting in smaller
+/// serialization. This is particularly useful when encoding data into space-constrained formats
+/// such as QR codes. The SCID is communicated via a [`MessageForwardNode`], but may be `None`
+/// to allow for graceful degradation.
 ///
 /// # Privacy
 ///
@@ -686,7 +697,7 @@ where
 			peers.into_iter(),
 			&self.entropy_source,
 			secp_ctx,
-			false,
+			true,
 		)
 	}