Introduce create_blinded_paths helpers in OffersMessageFlow

These functions will be used in the following commit to replace closure usage
in Flow trait functions.

Author: shaavan

lightning-background-processor/src/lib.rs

@@ -1584,8 +1584,10 @@ mod tests {
 				network_graph.clone(),
 				Arc::clone(&keys_manager),
 			));
+			let best_block = BestBlock::from_network(network);
+			let params = ChainParameters { network, best_block };
 			let flow = Arc::new(OffersMessageFlow::new(
-				network,
+				params,
 				keys_manager.get_node_id(Recipient::Node).unwrap(),
 				genesis_block.header.time,
 				keys_manager.get_inbound_payment_key(),
@@ -1605,8 +1607,6 @@ mod tests {
 				fee_estimator.clone(),
 				kv_store.clone(),
 			));
-			let best_block = BestBlock::from_network(network);
-			let params = ChainParameters { network, best_block };
 			let manager = Arc::new(ChannelManager::new(
 				fee_estimator.clone(),
 				chain_monitor.clone(),

lightning-liquidity/tests/common/mod.rs

@@ -444,8 +444,12 @@ pub(crate) fn create_liquidity_node(
 	));
 	let msg_router =
 		Arc::new(DefaultMessageRouter::new(Arc::clone(&network_graph), Arc::clone(&keys_manager)));
+
+	let best_block = BestBlock::from_network(network);
+	let chain_params = ChainParameters { network, best_block };
+
 	let flow = Arc::new(OffersMessageFlow::new(
-		network,
+		chain_params,
 		keys_manager.get_node_id(Recipient::Node).unwrap(),
 		genesis_block.header.time,
 		keys_manager.get_inbound_payment_key(),
@@ -463,8 +467,6 @@ pub(crate) fn create_liquidity_node(
 		fee_estimator.clone(),
 		kv_store.clone(),
 	));
-	let best_block = BestBlock::from_network(network);
-	let chain_params = ChainParameters { network, best_block };
 	let channel_manager = Arc::new(ChannelManager::new(
 		fee_estimator.clone(),
 		chain_monitor.clone(),

lightning/src/ln/channelmanager.rs

@@ -2875,7 +2875,7 @@ pub const MIN_CLTV_EXPIRY_DELTA: u16 = 6*7;
 // scale them up to suit its security policy. At the network-level, we shouldn't constrain them too much,
 // while avoiding to introduce a DoS vector. Further, a low CTLV_FAR_FAR_AWAY could be a source of
 // routing failure for any HTLC sender picking up an LDK node among the first hops.
-pub(super) const CLTV_FAR_FAR_AWAY: u32 = 14 * 24 * 6;
+pub(crate) const CLTV_FAR_FAR_AWAY: u32 = 14 * 24 * 6;
 
 /// Minimum CLTV difference between the current block height and received inbound payments.
 /// Invoices generated for payment to us must set their `min_final_cltv_expiry_delta` field to at least

lightning/src/ln/functional_test_utils.rs

@@ -3354,7 +3354,7 @@ pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg<'b>
 			network,
 			best_block: BestBlock::from_network(network),
 		};
-		let flow = Arc::new(TestOffersMessageFlow::new(network, cfgs[i].keys_manager.get_node_id(Recipient::Node).unwrap(), genesis_block.header.time, cfgs[i].keys_manager.get_inbound_payment_key(), cfgs[i].keys_manager, &cfgs[i].message_router, &cfgs[i].router));
+		let flow = Arc::new(TestOffersMessageFlow::new(params, cfgs[i].keys_manager.get_node_id(Recipient::Node).unwrap(), genesis_block.header.time, cfgs[i].keys_manager.get_inbound_payment_key(), cfgs[i].keys_manager, &cfgs[i].message_router, &cfgs[i].router));
 		let node = ChannelManager::new(cfgs[i].fee_estimator, &cfgs[i].chain_monitor, cfgs[i].tx_broadcaster, &cfgs[i].router, &cfgs[i].message_router, flow, cfgs[i].logger, cfgs[i].keys_manager,
 			cfgs[i].keys_manager, cfgs[i].keys_manager, if node_config[i].is_some() { node_config[i].clone().unwrap() } else { test_default_channel_config() }, params, genesis_block.header.time);
 		chanmgrs.push(node);
@@ -3387,7 +3387,12 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeC
 			IgnoringMessageHandler {},
 		);
 
-		let flow = Arc::new(TestOffersMessageFlow::new(network, cfgs[i].keys_manager.get_node_id(Recipient::Node).unwrap(), genesis_block.header.time, cfgs[i].keys_manager.get_inbound_payment_key(), &cfgs[i].keys_manager, &cfgs[i].message_router, &cfgs[i].router));
+		let params = ChainParameters {
+			network,
+			best_block: BestBlock::from_network(network),
+		};
+
+		let flow = Arc::new(TestOffersMessageFlow::new(params, cfgs[i].keys_manager.get_node_id(Recipient::Node).unwrap(), genesis_block.header.time, cfgs[i].keys_manager.get_inbound_payment_key(), &cfgs[i].keys_manager, &cfgs[i].message_router, &cfgs[i].router));
 
 		let gossip_sync = P2PGossipSync::new(cfgs[i].network_graph.as_ref(), None, cfgs[i].logger);
 		let wallet_source = Arc::new(test_utils::TestWalletSource::new(SecretKey::from_slice(&[i as u8 + 1; 32]).unwrap()));

lightning/src/offers/flow.rs

@@ -14,17 +14,19 @@
 use core::ops::Deref;
 use core::time::Duration;
 use core::sync::atomic::{AtomicUsize, Ordering};
+use crate::sync::RwLock;
 
 use bitcoin::block::Header;
 use bitcoin::constants::ChainHash;
 use bitcoin::secp256k1::{self, PublicKey, Secp256k1};
-use bitcoin::network::Network;
 
-use crate::blinded_path::message::{AsyncPaymentsContext, BlindedMessagePath, MessageContext, OffersContext};
-use crate::blinded_path::payment::{BlindedPaymentPath, Bolt12OfferContext, Bolt12RefundContext, PaymentContext};
-use crate::chain;
+use crate::blinded_path::message::{AsyncPaymentsContext, BlindedMessagePath, MessageContext, MessageForwardNode, OffersContext};
+use crate::blinded_path::payment::{BlindedPaymentPath, Bolt12OfferContext, Bolt12RefundContext, PaymentConstraints, PaymentContext, UnauthenticatedReceiveTlvs};
+use crate::chain::{self, BestBlock};
+use crate::chain::channelmonitor::LATENCY_GRACE_PERIOD_BLOCKS;
 use crate::chain::transaction::TransactionData;
-use crate::ln::channelmanager::{PaymentId, Verification, OFFERS_MESSAGE_REQUEST_LIMIT};
+use crate::ln::channel_state::ChannelDetails;
+use crate::ln::channelmanager::{ChainParameters, PaymentId, Verification, CLTV_FAR_FAR_AWAY, MAX_SHORT_LIVED_RELATIVE_EXPIRY, OFFERS_MESSAGE_REQUEST_LIMIT};
 use crate::offers::invoice::{Bolt12Invoice, DerivedSigningPubkey, ExplicitSigningPubkey, InvoiceBuilder, UnsignedBolt12Invoice};
 use crate::offers::invoice_error::InvoiceError;
 use crate::offers::invoice_request::{InvoiceRequest, InvoiceRequestBuilder, VerifiedInvoiceRequest};
@@ -153,6 +155,7 @@ where
 	R::Target: Router,
 {
 	chain_hash: ChainHash,
+	best_block: RwLock<BestBlock>,
 
 	our_network_pubkey: PublicKey,
 	highest_seen_timestamp: AtomicUsize,
@@ -183,15 +186,16 @@ where
 {
 	/// Creates a new [`OffersMessageFlow`]
 	pub fn new(
-		network: Network, our_network_pubkey: PublicKey,
+		params: ChainParameters, our_network_pubkey: PublicKey,
 		current_timestamp: u32, inbound_payment_key: inbound_payment::ExpandedKey,
 		entropy_source: ES, message_router: MR, router: R,
 	) -> Self {
 		let mut secp_ctx = Secp256k1::new();
 		secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
 
 		Self {
-			chain_hash: ChainHash::using_genesis_block(network),
+			chain_hash: ChainHash::using_genesis_block(params.network),
+			best_block: RwLock::new(params.best_block),
 
 			our_network_pubkey,
 			highest_seen_timestamp: AtomicUsize::new(current_timestamp as usize),
@@ -248,6 +252,101 @@ where
 	}
 }
 
+impl<ES: Deref, MR: Deref, R: Deref> OffersMessageFlow<ES, MR, R>
+where
+	ES::Target: EntropySource,
+	MR::Target: MessageRouter,
+	R::Target: Router,
+{
+	/// 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`].
+	///
+	/// Errors if the `MessageRouter` errors.
+	fn create_blinded_paths(&self, peers: Vec<MessageForwardNode>, context: MessageContext) -> Result<Vec<BlindedMessagePath>, ()> {
+		let recipient = self.get_our_node_id();
+		let secp_ctx = &self.secp_ctx;
+
+		let peers = peers
+			.into_iter()
+			.map(|node| node.node_id)
+			.collect();
+
+		self.message_router
+			.create_blinded_paths(recipient, context, peers, secp_ctx)
+			.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;
+
+		let peers = peers;
+
+		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(
+		&self, usable_channels: Vec<ChannelDetails>, amount_msats: Option<u64>, payment_secret: PaymentSecret,
+		payment_context: PaymentContext, relative_expiry_seconds: u32
+	) -> Result<Vec<BlindedPaymentPath>, ()> {
+		let expanded_key = &self.inbound_payment_key;
+		let entropy = &*self.entropy_source;
+		let secp_ctx = &self.secp_ctx;
+
+		let first_hops = usable_channels;
+		let payee_node_id = self.get_our_node_id();
+
+		// Assume shorter than usual block times to avoid spuriously failing payments too early.
+		const SECONDS_PER_BLOCK: u32 = 9 * 60;
+		let relative_expiry_blocks = relative_expiry_seconds / SECONDS_PER_BLOCK;
+		let max_cltv_expiry = core::cmp::max(relative_expiry_blocks, CLTV_FAR_FAR_AWAY)
+			.saturating_add(LATENCY_GRACE_PERIOD_BLOCKS)
+			.saturating_add(self.best_block.read().unwrap().height);
+
+		let payee_tlvs = UnauthenticatedReceiveTlvs {
+			payment_secret,
+			payment_constraints: PaymentConstraints {
+				max_cltv_expiry,
+				htlc_minimum_msat: 1,
+			},
+			payment_context,
+		};
+		let nonce = Nonce::from_entropy_source(entropy);
+		let payee_tlvs = payee_tlvs.authenticate(nonce, expanded_key);
+
+		self.router.create_blinded_payment_paths(
+			payee_node_id, first_hops, payee_tlvs, amount_msats, secp_ctx
+		)
+	}
+}
+
 impl<ES: Deref, MR: Deref, R: Deref> chain::Listen for OffersMessageFlow<ES, MR, R>
 where
 	ES::Target: EntropySource,