Static invoice server: persist invoices once built

As part of serving static invoices to payers on behalf of often-offline
recipients, the recipient will send us the final static invoice once it's done
being interactively built. We will then persist this invoice and confirm to
them that the corresponding offer is ready to be used for async payments.

Surface an event once the invoice is received and expose an API to tell the
recipient that it's ready for payments.

Author: valentinewallace

lightning/src/events/mod.rs

@@ -46,6 +46,12 @@ use core::time::Duration;
 use core::ops::Deref;
 use crate::sync::Arc;
 
+#[cfg(async_payments)] use {
+	crate::blinded_path::message::BlindedMessagePath,
+	crate::offers::nonce::Nonce,
+	crate::offers::static_invoice::StaticInvoice,
+};
+
 #[allow(unused_imports)]
 use crate::prelude::*;
 
@@ -1494,7 +1500,32 @@ pub enum Event {
 		/// The node id of the peer we just connected to, who advertises support for
 		/// onion messages.
 		peer_node_id: PublicKey,
-	}
+	},
+	/// We received a [`StaticInvoice`] from an async recipient that wants us to serve the invoice to
+	/// payers on their behalf when they are offline. 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`].
+	///
+	/// [`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
+	#[cfg(async_payments)]
+	PersistStaticInvoice {
+		/// The invoice that should be persisted and later provided to payers when handling a future
+		/// `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
+		/// persisted invoice can be retrieved from the database.
+		recipient_id_nonce: Nonce,
+		/// Once the [`StaticInvoice`] is persisted, [`ChannelManager::static_invoice_persisted`] should
+		/// be called with these paths to confirm to the recipient that their [`Offer`] is ready to be used
+		/// for async payments.
+		///
+		/// [`ChannelManager::static_invoice_persisted`]: crate::ln::channelmanager::ChannelManager::static_invoice_persisted
+		/// [`Offer`]: crate::offers::offer::Offer
+		invoice_persisted_paths: Vec<BlindedMessagePath>,
+	},
 }
 
 impl Writeable for Event {
@@ -1828,6 +1859,15 @@ impl Writeable for Event {
 					(8, former_temporary_channel_id, required),
 				});
 			},
+			#[cfg(async_payments)]
+			&Event::PersistStaticInvoice { ref invoice, ref recipient_id_nonce, ref invoice_persisted_paths } => {
+				45u8.write(writer)?;
+				write_tlv_fields!(writer, {
+					(0, invoice, required),
+					(2, recipient_id_nonce, required),
+					(4, invoice_persisted_paths, 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`.
@@ -2341,6 +2381,22 @@ impl MaybeReadable for Event {
 					former_temporary_channel_id: former_temporary_channel_id.0.unwrap(),
 				}))
 			},
+			#[cfg(async_payments)]
+			45u8 => {
+				let mut f = || {
+					_init_and_read_len_prefixed_tlv_fields!(reader, {
+						(0, invoice, required),
+						(2, recipient_id_nonce, required),
+						(4, invoice_persisted_paths, required),
+					});
+					Ok(Some(Event::PersistStaticInvoice {
+						invoice: _init_tlv_based_struct_field!(invoice, required),
+						recipient_id_nonce: _init_tlv_based_struct_field!(recipient_id_nonce, required),
+						invoice_persisted_paths: _init_tlv_based_struct_field!(invoice_persisted_paths, 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

@@ -4928,6 +4928,22 @@ where
 		);
 	}
 
+	///
+	#[cfg(async_payments)]
+	pub fn static_invoice_persisted(&self, message_paths: Vec<BlindedMessagePath>) -> Result<(), ()> {
+		let mut pending_async_payments_messages = self.pending_async_payments_messages.lock().unwrap();
+
+		let message = AsyncPaymentsMessage::StaticInvoicePersisted(StaticInvoicePersisted {});
+		for path in message_paths.into_iter().take(OFFERS_MESSAGE_REQUEST_LIMIT) {
+			let instructions = MessageSendInstructions::WithoutReplyPath {
+				destination: Destination::BlindedPath(path),
+			};
+			pending_async_payments_messages.push((message.clone(), instructions));
+		}
+
+		Ok(())
+	}
+
 	#[cfg(async_payments)]
 	fn initiate_async_payment(
 		&self, invoice: &StaticInvoice, payment_id: PaymentId
@@ -12856,7 +12872,31 @@ where
 
 	fn handle_serve_static_invoice(
 		&self, _message: ServeStaticInvoice, _context: AsyncPaymentsContext,
-	) {}
+	) {
+		#[cfg(async_payments)] {
+			let expanded_key = &self.inbound_payment_key;
+			let recipient_id_nonce = match _context {
+				AsyncPaymentsContext::ServeStaticInvoice {
+					recipient_id_nonce, nonce, hmac, path_absolute_expiry
+				} => {
+					if let Err(()) = signer::verify_serve_static_invoice_context(nonce, hmac, expanded_key) {
+						return
+					}
+					if self.duration_since_epoch() > path_absolute_expiry { return }
+					recipient_id_nonce
+				},
+				_ => return
+			};
+
+			PersistenceNotifierGuard::notify_on_drop(self);
+			let mut pending_events = self.pending_events.lock().unwrap();
+			pending_events.push_back((Event::PersistStaticInvoice {
+				invoice: _message.invoice,
+				recipient_id_nonce,
+				invoice_persisted_paths: _message.invoice_persisted_paths
+			}, None));
+		}
+	}
 
 	fn handle_static_invoice_persisted(
 		&self, _message: StaticInvoicePersisted, _context: AsyncPaymentsContext,

lightning/src/offers/signer.rs

@@ -637,6 +637,17 @@ pub(crate) fn hmac_for_serve_static_invoice_context(
 	Hmac::from_engine(hmac)
 }
 
+#[cfg(async_payments)]
+pub(crate) fn verify_serve_static_invoice_context(
+	nonce: Nonce, hmac: Hmac<Sha256>, expanded_key: &ExpandedKey,
+) -> Result<(), ()> {
+	if hmac_for_serve_static_invoice_context(nonce, expanded_key) == hmac {
+		Ok(())
+	} else {
+		Err(())
+	}
+}
+
 #[cfg(async_payments)]
 pub(crate) fn hmac_for_static_invoice_persisted_context(
 	nonce: Nonce, expanded_key: &ExpandedKey,

lightning/src/offers/static_invoice.rs

@@ -177,6 +177,14 @@ impl<'a> StaticInvoiceBuilder<'a> {
 	invoice_builder_methods_test_common!(self, Self, self.invoice, Self, self, mut);
 }
 
+impl PartialEq for StaticInvoice {
+	fn eq(&self, other: &Self) -> bool {
+		self.bytes.eq(&other.bytes)
+	}
+}
+
+impl Eq for StaticInvoice {}
+
 /// A semantically valid [`StaticInvoice`] that hasn't been signed.
 pub struct UnsignedStaticInvoice {
 	bytes: Vec<u8>,