Cleanup: Remove redundant create_blinded_paths variants

This commit completes the series implementing the principle:
**“One `MessageRouter`, one `BlindedPath` type.”**

As the final step, it removes now-redundant variations of the
blinded path creation functions, streamlining the API and
simplifying the blinded path creation process.

Author: shaavan

lightning/src/ln/channelmanager.rs

@@ -3023,9 +3023,7 @@ const MAX_NO_CHANNEL_PEERS: usize = 250;
 /// short-lived, while anything with a greater expiration is considered long-lived.
 ///
 /// Using [`ChannelManager::create_offer_builder`] or [`ChannelManager::create_refund_builder`],
-/// will included a [`BlindedMessagePath`] created using:
-/// - [`MessageRouter::create_compact_blinded_paths`] when short-lived, and
-/// - [`MessageRouter::create_blinded_paths`] when long-lived.
+/// will include a [`BlindedMessagePath`] created using [`MessageRouter::create_blinded_paths`]
 ///
 /// Using compact [`BlindedMessagePath`]s may provide better privacy as the [`MessageRouter`] could select
 /// more hops. However, since they use short channel ids instead of pubkeys, they are more likely to

lightning/src/offers/flow.rs

@@ -33,7 +33,7 @@ use crate::prelude::*;
 use crate::chain::BestBlock;
 use crate::ln::channel_state::ChannelDetails;
 use crate::ln::channelmanager::{
-	Verification, {PaymentId, CLTV_FAR_FAR_AWAY, MAX_SHORT_LIVED_RELATIVE_EXPIRY},
+	Verification, {PaymentId, CLTV_FAR_FAR_AWAY},
 };
 use crate::ln::inbound_payment;
 use crate::offers::async_receive_offer_cache::AsyncReceiveOfferCache;
@@ -187,6 +187,7 @@ where
 		self.our_network_pubkey
 	}
 
+	#[cfg(async_payments)]
 	fn duration_since_epoch(&self) -> Duration {
 		#[cfg(not(feature = "std"))]
 		let now = Duration::from_secs(self.highest_seen_timestamp.load(Ordering::Acquire) as u64);
@@ -250,26 +251,6 @@ impl<MR: Deref> OffersMessageFlow<MR>
 where
 	MR::Target: MessageRouter,
 {
-	/// Creates a collection of blinded paths by delegating to [`MessageRouter`] based on
-	/// the path's intended lifetime.
-	///
-	/// Whether or not the path is compact depends on whether the path is short-lived or long-lived,
-	/// respectively, based on the given `absolute_expiry` as seconds since the Unix epoch. See
-	/// [`MAX_SHORT_LIVED_RELATIVE_EXPIRY`].
-	fn create_blinded_paths_using_absolute_expiry(
-		&self, context: OffersContext, absolute_expiry: Option<Duration>,
-		peers: Vec<MessageForwardNode>,
-	) -> Result<Vec<BlindedMessagePath>, ()> {
-		let now = self.duration_since_epoch();
-		let max_short_lived_absolute_expiry = now.saturating_add(MAX_SHORT_LIVED_RELATIVE_EXPIRY);
-
-		if absolute_expiry.unwrap_or(Duration::MAX) <= max_short_lived_absolute_expiry {
-			self.create_compact_blinded_paths(peers, context)
-		} else {
-			self.create_blinded_paths(peers, MessageContext::Offers(context))
-		}
-	}
-
 	/// Creates a collection of blinded paths by delegating to
 	/// [`MessageRouter::create_blinded_paths`].
 	///
@@ -285,26 +266,6 @@ where
 			.and_then(|paths| (!paths.is_empty()).then(|| paths).ok_or(()))
 	}
 
-	/// Creates a collection of blinded paths by delegating to
-	/// [`MessageRouter::create_compact_blinded_paths`].
-	///
-	/// Errors if the `MessageRouter` errors.
-	fn create_compact_blinded_paths(
-		&self, peers: Vec<MessageForwardNode>, context: OffersContext,
-	) -> Result<Vec<BlindedMessagePath>, ()> {
-		let recipient = self.get_our_node_id();
-		let secp_ctx = &self.secp_ctx;
-
-		self.message_router
-			.create_compact_blinded_paths(
-				recipient,
-				MessageContext::Offers(context),
-				peers,
-				secp_ctx,
-			)
-			.and_then(|paths| (!paths.is_empty()).then(|| paths).ok_or(()))
-	}
-
 	/// Creates multi-hop blinded payment paths for the given `amount_msats` by delegating to
 	/// [`Router::create_blinded_payment_paths`].
 	fn create_blinded_payment_paths<ES: Deref, R: Deref>(

lightning/src/onion_message/messenger.rs

@@ -504,26 +504,6 @@ pub trait MessageRouter {
 		&self, recipient: PublicKey, context: MessageContext, peers: Vec<MessageForwardNode>,
 		secp_ctx: &Secp256k1<T>,
 	) -> Result<Vec<BlindedMessagePath>, ()>;
-
-	/// Creates compact [`BlindedMessagePath`]s to the `recipient` node. The nodes in `peers` are
-	/// assumed to be direct peers with the `recipient`.
-	///
-	/// Compact blinded paths use short channel ids instead of pubkeys for a smaller serialization,
-	/// which is beneficial when a QR code is used to transport the data. The SCID is passed using
-	/// a [`MessageForwardNode`] but may be `None` for graceful degradation.
-	///
-	/// Implementations using additional intermediate nodes are responsible for using a
-	/// [`MessageForwardNode`] with `Some` short channel id, if possible. Similarly, implementations
-	/// should call [`BlindedMessagePath::use_compact_introduction_node`].
-	///
-	/// The provided implementation simply delegates to [`MessageRouter::create_blinded_paths`],
-	/// ignoring the short channel ids.
-	fn create_compact_blinded_paths<T: secp256k1::Signing + secp256k1::Verification>(
-		&self, recipient: PublicKey, context: MessageContext, peers: Vec<MessageForwardNode>,
-		secp_ctx: &Secp256k1<T>,
-	) -> Result<Vec<BlindedMessagePath>, ()> {
-		self.create_blinded_paths(recipient, context, peers, secp_ctx)
-	}
 }
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
@@ -706,21 +686,6 @@ where
 			true,
 		)
 	}
-
-	fn create_compact_blinded_paths<T: secp256k1::Signing + secp256k1::Verification>(
-		&self, recipient: PublicKey, context: MessageContext, peers: Vec<MessageForwardNode>,
-		secp_ctx: &Secp256k1<T>,
-	) -> Result<Vec<BlindedMessagePath>, ()> {
-		Self::create_blinded_paths_from_iter(
-			&self.network_graph,
-			recipient,
-			context,
-			peers.into_iter(),
-			&self.entropy_source,
-			secp_ctx,
-			true,
-		)
-	}
 }
 
 /// This message router is similar to [`DefaultMessageRouter`], but it always creates
@@ -780,21 +745,6 @@ where
 			false,
 		)
 	}
-
-	fn create_compact_blinded_paths<T: secp256k1::Signing + secp256k1::Verification>(
-		&self, recipient: PublicKey, context: MessageContext, peers: Vec<MessageForwardNode>,
-		secp_ctx: &Secp256k1<T>,
-	) -> Result<Vec<BlindedMessagePath>, ()> {
-		DefaultMessageRouter::create_blinded_paths_from_iter(
-			&self.network_graph,
-			recipient,
-			context,
-			peers.into_iter(),
-			&self.entropy_source,
-			secp_ctx,
-			false,
-		)
-	}
 }
 
 /// A special [`MessageRouter`] that performs no routing and does not create blinded paths.
@@ -828,13 +778,6 @@ impl MessageRouter for NullMessageRouter {
 	) -> Result<Vec<BlindedMessagePath>, ()> {
 		Ok(vec![])
 	}
-
-	fn create_compact_blinded_paths<T: secp256k1::Signing + secp256k1::Verification>(
-		&self, _recipient: PublicKey, _context: MessageContext, _peers: Vec<MessageForwardNode>,
-		_secp_ctx: &Secp256k1<T>,
-	) -> Result<Vec<BlindedMessagePath>, ()> {
-		Ok(vec![])
-	}
 }
 
 /// A path for sending an [`OnionMessage`].

lightning/src/util/test_utils.rs

@@ -361,20 +361,6 @@ impl<'a> MessageRouter for TestMessageRouter<'a> {
 			Self::NodeId(inner) => inner.create_blinded_paths(recipient, context, peers, secp_ctx),
 		}
 	}
-
-	fn create_compact_blinded_paths<T: secp256k1::Signing + secp256k1::Verification>(
-		&self, recipient: PublicKey, context: MessageContext, peers: Vec<MessageForwardNode>,
-		secp_ctx: &Secp256k1<T>,
-	) -> Result<Vec<BlindedMessagePath>, ()> {
-		match self {
-			Self::Default(inner) => {
-				inner.create_compact_blinded_paths(recipient, context, peers, secp_ctx)
-			},
-			Self::NodeId(inner) => {
-				inner.create_compact_blinded_paths(recipient, context, peers, secp_ctx)
-			},
-		}
-	}
 }
 
 pub struct OnlyReadsKeysInterface {}