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

@@ -1586,11 +1586,11 @@ 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,
 		/// An identifier for the recipient, originally surfaced in
 		/// [`ChannelManager::blinded_paths_for_async_recipient`]. When an
-		/// `Event::StaticInvoiceRequested` comes in for this invoice, this id will be surfaced so the
+		/// [`Event::StaticInvoiceRequested`] comes in for this invoice, this id will be surfaced so the
 		/// persisted invoice can be retrieved from the database.
 		recipient_id_nonce: Nonce,
 		/// Once the [`StaticInvoice`] is persisted, [`ChannelManager::static_invoice_persisted`] should
@@ -1601,6 +1601,34 @@ 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 configured the recipient with them
+	/// via [`UserConfig::paths_to_static_invoice_server`].
+	///
+	/// If we previously persisted a [`StaticInvoice`] from an [`Event::PersistStaticInvoice`] that
+	/// matches the contained [`Event::StaticInvoiceRequested::recipient_id_nonce`], 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
+	/// [`UserConfig::paths_to_static_invoice_server`]: crate::util::config::UserConfig::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_nonce`]. Useful to retrieve the [`StaticInvoice`]
+		/// requested by the payer.
+		recipient_id_nonce: Nonce,
+		/// 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 {
@@ -2031,6 +2059,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`.
@@ -2598,6 +2631,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

@@ -86,7 +86,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,
 };
@@ -5128,6 +5128,15 @@ where
 		self.flow.serving_static_invoice(invoice_persisted_path);
 	}
 
+	/// Forwards a [`StaticInvoice`] that was previously persisted by us from an
+	/// [`Event::PersistStaticInvoice`], 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)
+	}
+
 	#[rustfmt::skip]
 	#[cfg(async_payments)]
 	fn initiate_async_payment(
@@ -12760,7 +12769,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_nonce: _recipient_id_nonce
+					}) => {
+						#[cfg(async_payments)]
+						self.pending_events.lock().unwrap().push_back((Event::StaticInvoiceRequested {
+							recipient_id_nonce: _recipient_id_nonce, reply_path: responder
+						}, None));
+
+						return None
+					},
 					Err(_) => return None,
 				};
 

lightning/src/offers/flow.rs

@@ -420,6 +420,23 @@ 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_nonce` and calling
+	/// `OffersMessageFlow::enqueue_static_invoice`.
+	///
+	/// TODO: if the server stores multiple invoices on behalf of the recipient, how to narrow down
+	/// which one is being requested?
+	SendStaticInvoice {
+		/// An identifier for the async recipient for whom we are serving [`StaticInvoice`]s.
+		recipient_id_nonce: Nonce,
+	},
+}
+
 impl<MR: Deref> OffersMessageFlow<MR>
 where
 	MR::Target: MessageRouter,
@@ -437,13 +454,31 @@ 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_nonce,
+				nonce,
+				hmac,
+				path_absolute_expiry,
+			}) => {
+				// TODO: vet invreq more?
+				if signer::verify_async_recipient_invreq_context(nonce, hmac, expanded_key).is_err()
+				{
+					return Err(());
+				}
+				if path_absolute_expiry < self.duration_since_epoch() {
+					return Err(());
+				}
+
+				return Ok(InvreqResponseInstructions::SendStaticInvoice { recipient_id_nonce });
+			},
 			_ => return Err(()),
 		};
 
@@ -454,7 +489,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,
@@ -1064,6 +1099,28 @@ where
 		Ok(())
 	}
 
+	/// Forwards a [`StaticInvoice`] that was previously persisted by us from an
+	/// [`Event::PersistStaticInvoice`], in response to an [`Event::StaticInvoiceRequested`].
+	#[cfg(async_payments)]
+	pub 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);
+		// TODO include reply path for invoice error
+		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`].
 	///

lightning/src/offers/signer.rs

@@ -704,3 +704,14 @@ pub(crate) fn hmac_for_async_recipient_invreq_context(
 
 	Hmac::from_engine(hmac)
 }
+
+#[cfg(async_payments)]
+pub(crate) fn verify_async_recipient_invreq_context(
+	nonce: Nonce, hmac: Hmac<Sha256>, expanded_key: &ExpandedKey,
+) -> Result<(), ()> {
+	if hmac_for_async_recipient_invreq_context(nonce, expanded_key) == hmac {
+		Ok(())
+	} else {
+		Err(())
+	}
+}