Add AsyncBolt12Offer support to LSPS2 BOLT12 router

Expand `LSPS2BOLT12Router` to also handle `PaymentContext::AsyncBolt12Offer`
contexts in addition to `Bolt12Offer`. Since `AsyncBolt12OfferContext` uses an
`offer_nonce` (rather than an `OfferId`), add a parallel nonce-keyed map with
`register_offer_nonce` / `unregister_offer_nonce` methods.

The `MessageRouter` implementation's SCID injection also checks the nonce map
so that async offers benefit from compact message blinded paths.

Co-Authored-By: HAL 9000

Author: tnull

lightning-liquidity/src/lsps2/router.rs

@@ -20,11 +20,12 @@ use lightning::blinded_path::message::{
 	BlindedMessagePath, MessageContext, MessageForwardNode, OffersContext,
 };
 use lightning::blinded_path::payment::{
-	BlindedPaymentPath, Bolt12OfferContext, ForwardTlvs, PaymentConstraints, PaymentContext,
-	PaymentForwardNode, PaymentRelay, ReceiveTlvs,
+	AsyncBolt12OfferContext, BlindedPaymentPath, Bolt12OfferContext, ForwardTlvs,
+	PaymentConstraints, PaymentContext, PaymentForwardNode, PaymentRelay, ReceiveTlvs,
 };
 use lightning::ln::channel_state::ChannelDetails;
 use lightning::ln::channelmanager::{PaymentId, MIN_FINAL_CLTV_EXPIRY_DELTA};
+use lightning::offers::nonce::Nonce;
 use lightning::offers::offer::OfferId;
 use lightning::onion_message::messenger::{Destination, MessageRouter, OnionMessagePath};
 use lightning::routing::router::{InFlightHtlcs, Route, RouteParameters, Router};
@@ -61,6 +62,7 @@ pub struct LSPS2BOLT12Router<R: Router, MR: MessageRouter, ES: EntropySource + S
 	inner_message_router: MR,
 	entropy_source: ES,
 	offer_to_invoice_params: Mutex<HashMap<[u8; 32], LSPS2Bolt12InvoiceParameters>>,
+	nonce_to_invoice_params: Mutex<HashMap<[u8; Nonce::LENGTH], LSPS2Bolt12InvoiceParameters>>,
 }
 
 impl<R: Router, MR: MessageRouter, ES: EntropySource + Send + Sync> LSPS2BOLT12Router<R, MR, ES> {
@@ -71,6 +73,7 @@ impl<R: Router, MR: MessageRouter, ES: EntropySource + Send + Sync> LSPS2BOLT12R
 			inner_message_router,
 			entropy_source,
 			offer_to_invoice_params: Mutex::new(new_hash_map()),
+			nonce_to_invoice_params: Mutex::new(new_hash_map()),
 		}
 	}
 
@@ -86,22 +89,50 @@ impl<R: Router, MR: MessageRouter, ES: EntropySource + Send + Sync> LSPS2BOLT12R
 		self.offer_to_invoice_params.lock().unwrap().remove(&offer_id.0)
 	}
 
-	/// Clears all LSPS2 parameters previously registered via [`Self::register_offer`].
+	/// Registers LSPS2 parameters to be used when generating blinded payment paths for an async
+	/// BOLT12 offer identified by its `offer_nonce`.
+	///
+	/// This is the async-offer counterpart to [`Self::register_offer`], used for
+	/// [`PaymentContext::AsyncBolt12Offer`] contexts where the offer is identified by its nonce
+	/// rather than its [`OfferId`].
+	pub fn register_offer_nonce(
+		&self, offer_nonce: Nonce, invoice_params: LSPS2Bolt12InvoiceParameters,
+	) -> Option<LSPS2Bolt12InvoiceParameters> {
+		let mut key = [0u8; Nonce::LENGTH];
+		key.copy_from_slice(offer_nonce.as_slice());
+		self.nonce_to_invoice_params.lock().unwrap().insert(key, invoice_params)
+	}
+
+	/// Removes any previously registered LSPS2 parameters for `offer_nonce`.
+	pub fn unregister_offer_nonce(
+		&self, offer_nonce: &Nonce,
+	) -> Option<LSPS2Bolt12InvoiceParameters> {
+		let mut key = [0u8; Nonce::LENGTH];
+		key.copy_from_slice(offer_nonce.as_slice());
+		self.nonce_to_invoice_params.lock().unwrap().remove(&key)
+	}
+
+	/// Clears all LSPS2 parameters previously registered via [`Self::register_offer`] and
+	/// [`Self::register_offer_nonce`].
 	pub fn clear_registered_offers(&self) {
 		self.offer_to_invoice_params.lock().unwrap().clear();
+		self.nonce_to_invoice_params.lock().unwrap().clear();
 	}
 
 	fn registered_lsps2_params(
 		&self, payment_context: &PaymentContext,
 	) -> Option<LSPS2Bolt12InvoiceParameters> {
-		// We intentionally only match `Bolt12Offer` here and not `AsyncBolt12Offer`, as LSPS2
-		// JIT channels are not applicable to async (always-online) BOLT12 offer flows.
-		let Bolt12OfferContext { offer_id, .. } = match payment_context {
-			PaymentContext::Bolt12Offer(context) => context,
-			_ => return None,
-		};
-
-		self.offer_to_invoice_params.lock().unwrap().get(&offer_id.0).copied()
+		match payment_context {
+			PaymentContext::Bolt12Offer(Bolt12OfferContext { offer_id, .. }) => {
+				self.offer_to_invoice_params.lock().unwrap().get(&offer_id.0).copied()
+			},
+			PaymentContext::AsyncBolt12Offer(AsyncBolt12OfferContext { offer_nonce }) => {
+				let mut key = [0u8; Nonce::LENGTH];
+				key.copy_from_slice(offer_nonce.as_slice());
+				self.nonce_to_invoice_params.lock().unwrap().get(&key).copied()
+			},
+			_ => None,
+		}
 	}
 }
 
@@ -212,14 +243,18 @@ impl<R: Router, MR: MessageRouter, ES: EntropySource + Send + Sync> MessageRoute
 		// is only used for routing InvoiceRequests, not for payment interception.
 		let peers = match &context {
 			MessageContext::Offers(OffersContext::InvoiceRequest { .. }) => {
-				let params = self.offer_to_invoice_params.lock().unwrap();
+				let offer_params = self.offer_to_invoice_params.lock().unwrap();
+				let nonce_params = self.nonce_to_invoice_params.lock().unwrap();
 				peers
 					.into_iter()
 					.map(|mut peer| {
-						if let Some(p) =
-							params.values().find(|p| p.counterparty_node_id == peer.node_id)
-						{
-							peer.short_channel_id = Some(p.intercept_scid);
+						let scid = offer_params
+							.values()
+							.chain(nonce_params.values())
+							.find(|p| p.counterparty_node_id == peer.node_id)
+							.map(|p| p.intercept_scid);
+						if let Some(scid) = scid {
+							peer.short_channel_id = Some(scid);
 						}
 						peer
 					})