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

@@ -1511,11 +1511,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
@@ -1526,6 +1526,34 @@ pub enum Event {
 		/// [`Offer`]: crate::offers::offer::Offer
 		invoice_persisted_paths: Vec<BlindedMessagePath>,
 	},
+	/// 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: BlindedMessagePath,
+	},
 }
 
 impl Writeable for Event {
@@ -1868,6 +1896,14 @@ impl Writeable for Event {
 					(4, invoice_persisted_paths, required),
 				});
 			},
+			#[cfg(async_payments)]
+			&Event::StaticInvoiceRequested { ref recipient_id_nonce, ref reply_path } => {
+				47u8.write(writer)?;
+				write_tlv_fields!(writer, {
+					(0, recipient_id_nonce, required),
+					(2, reply_path, required),
+				});
+			},
 			// 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`.
@@ -2397,6 +2433,20 @@ impl MaybeReadable for Event {
 				};
 				f()
 			},
+			#[cfg(async_payments)]
+			47u8 => {
+				let mut f = || {
+					_init_and_read_len_prefixed_tlv_fields!(reader, {
+						(0, recipient_id_nonce, required),
+						(2, reply_path, required),
+					});
+					Ok(Some(Event::StaticInvoiceRequested {
+						recipient_id_nonce: _init_tlv_based_struct_field!(recipient_id_nonce, required),
+						reply_path: _init_tlv_based_struct_field!(reply_path, required),
+					}))
+				};
+				f()
+			},
 			// 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

@@ -4944,6 +4944,27 @@ 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 send_static_invoice(
+		&self, invoice: StaticInvoice, path: BlindedMessagePath
+	) -> Result<(), ()> {
+		let duration_since_epoch = self.duration_since_epoch();
+		if invoice.is_expired_no_std(duration_since_epoch) { return Err(()) }
+		if invoice.is_offer_expired_no_std(duration_since_epoch) { return Err(()) }
+		let mut pending_offers_messages = self.pending_offers_messages.lock().unwrap();
+
+		let message = OffersMessage::StaticInvoice(invoice);
+		// TODO include reply path for invoice error
+		let instructions = MessageSendInstructions::WithoutReplyPath {
+			destination: Destination::BlindedPath(path),
+		};
+		pending_offers_messages.push((message, instructions));
+
+		Ok(())
+	}
+
 	#[cfg(async_payments)]
 	fn initiate_async_payment(
 		&self, invoice: &StaticInvoice, payment_id: PaymentId
@@ -12533,6 +12554,25 @@ where
 				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 None
+						}
+						if path_absolute_expiry < self.duration_since_epoch() {
+							return None
+						}
+
+						let mut pending_events = self.pending_events.lock().unwrap();
+						pending_events.push_back((Event::StaticInvoiceRequested {
+							recipient_id_nonce, reply_path: responder.reply_path().clone()
+						}, None));
+
+						return None
+					},
 					_ => return None,
 				};
 

lightning/src/offers/signer.rs

@@ -684,3 +684,10 @@ 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(()) }
+}

lightning/src/onion_message/messenger.rs

@@ -428,6 +428,11 @@ impl Responder {
 			context: Some(context),
 		}
 	}
+
+	#[cfg(async_payments)]
+	pub(crate) fn reply_path(&self) -> &BlindedMessagePath {
+		&self.reply_path
+	}
 }
 
 /// Instructions for how and where to send the response to an onion message.