Static invoice server: forward static invoices to payers

Here we implement serving static invoices to payers on behalf of often-offline
recipients. These recipients previously encoded blinded paths terminating at
our node in their offer, so we receive invoice requests on their behalf.

Handle those inbound invreqs by retrieving a static invoice we previously
persisted on behalf of the payee, and forward it to the payer as a reply to
their invreq.

Author: valentinewallace

lightning/src/events/mod.rs

@@ -1593,7 +1593,7 @@ pub enum Event {
 	#[cfg(async_payments)]
 	PersistStaticInvoice {
 		/// The invoice that should be persisted and later provided to payers when handling a future
-		/// `Event::StaticInvoiceRequested`.
+		/// [`Event::StaticInvoiceRequested`].
 		invoice: StaticInvoice,
 		/// Useful for the recipient to replace a specific invoice stored by us as the static invoice
 		/// server.
@@ -1605,10 +1605,10 @@ pub enum Event {
 		/// An identifier for the recipient, originally provided to
 		/// [`ChannelManager::blinded_paths_for_async_recipient`].
 		///
-		/// When an `Event::StaticInvoiceRequested` comes in for the invoice, this id will be surfaced
+		/// When an [`Event::StaticInvoiceRequested`] comes in for the invoice, this id will be surfaced
 		/// and can be used alongside the `invoice_id` to retrieve the invoice from the database.
 		recipient_id: Vec<u8>,
-		/// A unique identifier for the invoice. When an `Event::StaticInvoiceRequested` comes in for
+		/// A unique identifier for the invoice. When an [`Event::StaticInvoiceRequested`] comes in for
 		/// the invoice, this id will be surfaced and can be used alongside the `recipient_id` to
 		/// retrieve the invoice from the database.
 		invoice_id: u128,
@@ -1620,6 +1620,37 @@ pub enum Event {
 		/// [`Offer`]: crate::offers::offer::Offer
 		invoice_persisted_path: Responder,
 	},
+	/// As a static invoice server, we received an [`InvoiceRequest`] on behalf of an often-offline
+	/// recipient for whom we are serving [`StaticInvoice`]s.
+	///
+	/// This event will only be generated if we previously created paths using
+	/// [`ChannelManager::blinded_paths_for_async_recipient`] and the recipient was configured with
+	/// them via [`ChannelManager::set_paths_to_static_invoice_server`].
+	///
+	/// If we previously persisted a [`StaticInvoice`] from an [`Event::PersistStaticInvoice`] that
+	/// matches the below `recipient_id` and `invoice_id`, that invoice should be retrieved now
+	/// and forwarded to the payer via [`ChannelManager::send_static_invoice`].
+	///
+	/// [`ChannelManager::blinded_paths_for_async_recipient`]: crate::ln::channelmanager::ChannelManager::blinded_paths_for_async_recipient
+	/// [`ChannelManager::set_paths_to_static_invoice_server`]: crate::ln::channelmanager::ChannelManager::set_paths_to_static_invoice_server
+	/// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
+	/// [`ChannelManager::send_static_invoice`]: crate::ln::channelmanager::ChannelManager::send_static_invoice
+	#[cfg(async_payments)]
+	StaticInvoiceRequested {
+		/// An identifier for the recipient previously surfaced in
+		/// [`Event::PersistStaticInvoice::recipient_id`]. Useful when paired with the `invoice_id` to
+		/// retrieve the [`StaticInvoice`] requested by the payer.
+		recipient_id: Vec<u8>,
+		/// A random unique identifier for the invoice being requested, previously surfaced in
+		/// [`Event::PersistStaticInvoice::invoice_id`]. Useful when paired with the `recipient_id` to
+		/// retrieve the [`StaticInvoice`] requested by the payer.
+		invoice_id: u128,
+		/// The path over which the [`StaticInvoice`] will be sent to the payer, which should be
+		/// provided to [`ChannelManager::send_static_invoice`] along with the invoice.
+		///
+		/// [`ChannelManager::send_static_invoice`]: crate::ln::channelmanager::ChannelManager::send_static_invoice
+		reply_path: Responder,
+	},
 }
 
 impl Writeable for Event {
@@ -2056,6 +2087,11 @@ impl Writeable for Event {
 				// No need to write these events because we can just restart the static invoice negotiation
 				// on startup.
 			},
+			#[cfg(async_payments)]
+			&Event::StaticInvoiceRequested { .. } => {
+				47u8.write(writer)?;
+				// Never write StaticInvoiceRequested events as buffered onion messages aren't serialized.
+			},
 			// Note that, going forward, all new events must only write data inside of
 			// `write_tlv_fields`. Versions 0.0.101+ will ignore odd-numbered events that write
 			// data via `write_tlv_fields`.
@@ -2630,6 +2666,9 @@ impl MaybeReadable for Event {
 			// Note that we do not write a length-prefixed TLV for PersistStaticInvoice events.
 			#[cfg(async_payments)]
 			45u8 => Ok(None),
+			// Note that we do not write a length-prefixed TLV for StaticInvoiceRequested events.
+			#[cfg(async_payments)]
+			47u8 => Ok(None),
 			// Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
 			// Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt
 			// reads.

lightning/src/ln/channelmanager.rs

@@ -87,7 +87,7 @@ use crate::ln::outbound_payment::{
 };
 use crate::ln::types::ChannelId;
 use crate::offers::async_receive_offer_cache::AsyncReceiveOfferCache;
-use crate::offers::flow::OffersMessageFlow;
+use crate::offers::flow::{InvreqResponseInstructions, OffersMessageFlow};
 use crate::offers::invoice::{
 	Bolt12Invoice, DerivedSigningPubkey, InvoiceBuilder, DEFAULT_RELATIVE_EXPIRY,
 };
@@ -5279,6 +5279,14 @@ where
 		self.flow.static_invoice_persisted(invoice_persisted_path);
 	}
 
+	/// Forwards a [`StaticInvoice`] in response to an [`Event::StaticInvoiceRequested`].
+	#[cfg(async_payments)]
+	pub fn send_static_invoice(
+		&self, invoice: StaticInvoice, responder: Responder,
+	) -> Result<(), Bolt12SemanticError> {
+		self.flow.enqueue_static_invoice(invoice, responder)
+	}
+
 	#[cfg(async_payments)]
 	fn initiate_async_payment(
 		&self, invoice: &StaticInvoice, payment_id: PaymentId,
@@ -13355,7 +13363,17 @@ where
 				};
 
 				let invoice_request = match self.flow.verify_invoice_request(invoice_request, context) {
-					Ok(invoice_request) => invoice_request,
+					Ok(InvreqResponseInstructions::SendInvoice(invoice_request)) => invoice_request,
+					Ok(InvreqResponseInstructions::SendStaticInvoice {
+						recipient_id: _recipient_id, invoice_id: _invoice_id
+					}) => {
+						#[cfg(async_payments)]
+						self.pending_events.lock().unwrap().push_back((Event::StaticInvoiceRequested {
+							recipient_id: _recipient_id, invoice_id: _invoice_id, reply_path: responder
+						}, None));
+
+						return None
+					},
 					Err(_) => return None,
 				};
 

lightning/src/offers/flow.rs

@@ -415,6 +415,26 @@ fn enqueue_onion_message_with_reply_paths<T: OnionMessageContents + Clone>(
 		});
 }
 
+/// Instructions for how to respond to an `InvoiceRequest`.
+pub enum InvreqResponseInstructions {
+	/// We are the recipient of this payment, and a [`Bolt12Invoice`] should be sent in response to
+	/// the invoice request since it is now verified.
+	SendInvoice(VerifiedInvoiceRequest),
+	/// We are a static invoice server and should respond to this invoice request by retrieving the
+	/// [`StaticInvoice`] corresponding to the `recipient_id` and `invoice_id` and calling
+	/// `OffersMessageFlow::enqueue_static_invoice`.
+	///
+	/// [`StaticInvoice`]: crate::offers::static_invoice::StaticInvoice
+	SendStaticInvoice {
+		/// An identifier for the async recipient for whom we are serving [`StaticInvoice`]s.
+		///
+		/// [`StaticInvoice`]: crate::offers::static_invoice::StaticInvoice
+		recipient_id: Vec<u8>,
+		/// An identifier for the specific invoice being requested by the payer.
+		invoice_id: u128,
+	},
+}
+
 impl<MR: Deref> OffersMessageFlow<MR>
 where
 	MR::Target: MessageRouter,
@@ -432,13 +452,28 @@ where
 	/// - The verification process (via recipient context data or metadata) fails.
 	pub fn verify_invoice_request(
 		&self, invoice_request: InvoiceRequest, context: Option<OffersContext>,
-	) -> Result<VerifiedInvoiceRequest, ()> {
+	) -> Result<InvreqResponseInstructions, ()> {
 		let secp_ctx = &self.secp_ctx;
 		let expanded_key = &self.inbound_payment_key;
 
 		let nonce = match context {
 			None if invoice_request.metadata().is_some() => None,
 			Some(OffersContext::InvoiceRequest { nonce }) => Some(nonce),
+			#[cfg(async_payments)]
+			Some(OffersContext::StaticInvoiceRequested {
+				recipient_id,
+				invoice_id,
+				path_absolute_expiry,
+			}) => {
+				if path_absolute_expiry < self.duration_since_epoch() {
+					return Err(());
+				}
+
+				return Ok(InvreqResponseInstructions::SendStaticInvoice {
+					recipient_id,
+					invoice_id,
+				});
+			},
 			_ => return Err(()),
 		};
 
@@ -449,7 +484,7 @@ where
 			None => invoice_request.verify_using_metadata(expanded_key, secp_ctx),
 		}?;
 
-		Ok(invoice_request)
+		Ok(InvreqResponseInstructions::SendInvoice(invoice_request))
 	}
 
 	/// Verifies a [`Bolt12Invoice`] using the provided [`OffersContext`] or the invoice's payer metadata,
@@ -1059,6 +1094,26 @@ where
 		Ok(())
 	}
 
+	/// Forwards a [`StaticInvoice`] over the provided `responder`.
+	#[cfg(async_payments)]
+	pub(crate) fn enqueue_static_invoice(
+		&self, invoice: StaticInvoice, responder: Responder,
+	) -> Result<(), Bolt12SemanticError> {
+		let duration_since_epoch = self.duration_since_epoch();
+		if invoice.is_expired_no_std(duration_since_epoch) {
+			return Err(Bolt12SemanticError::AlreadyExpired);
+		}
+		if invoice.is_offer_expired_no_std(duration_since_epoch) {
+			return Err(Bolt12SemanticError::AlreadyExpired);
+		}
+
+		let mut pending_offers_messages = self.pending_offers_messages.lock().unwrap();
+		let message = OffersMessage::StaticInvoice(invoice);
+		pending_offers_messages.push((message, responder.respond().into_instructions()));
+
+		Ok(())
+	}
+
 	/// Enqueues `held_htlc_available` onion messages to be sent to the payee via the reply paths
 	/// contained within the provided [`StaticInvoice`].
 	///