Mark offer as ready on StaticInvoicePersisted onion message

As an async recipient, we need to interactively build a static invoice that an
always-online node will serve on our behalf.

Once this invoice is built and persisted by the static invoice server, they
will send us a confirmation onion message. At this time, mark the corresponding
pending offer as ready to receive async payments.

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -13080,6 +13080,13 @@ where
 	fn handle_static_invoice_persisted(
 		&self, _message: StaticInvoicePersisted, _context: AsyncPaymentsContext,
 	) {
+		#[cfg(async_payments)]
+		{
+			let should_persist = self.flow.handle_static_invoice_persisted(_context);
+			if should_persist {
+				let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
+			}
+		}
 	}
 
 	fn handle_held_htlc_available(

lightning/src/offers/async_receive_offer_cache.rs

@@ -23,7 +23,7 @@ use crate::util::ser::{Readable, Writeable, Writer};
 use core::time::Duration;
 
 /// The status of this offer in the cache.
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 enum OfferStatus {
 	/// This offer has been returned to the user from the cache, so it needs to be stored until it
 	/// expires and its invoice needs to be kept updated.
@@ -363,6 +363,30 @@ impl AsyncReceiveOfferCache {
 	fn reset_offer_paths_request_attempts(&mut self) {
 		self.offer_paths_request_attempts = 0;
 	}
+
+	/// Should be called when we receive a [`StaticInvoicePersisted`] message from the static invoice
+	/// server, which indicates that a new offer was persisted by the server and they are ready to
+	/// serve the corresponding static invoice to payers on our behalf.
+	///
+	/// Returns a bool indicating whether an offer was added/updated and re-persistence of the cache
+	/// is needed.
+	pub(super) fn static_invoice_persisted(
+		&mut self, offer_slot: u8, duration_since_epoch: Duration,
+	) -> bool {
+		if let Some(Some(ref mut offer)) = self.offers.get_mut(offer_slot as usize) {
+			if offer.status == OfferStatus::Used {
+				// We succeeded in updating the invoice for a used offer, no re-persistence of the cache
+				// needed
+				return false;
+			}
+
+			offer.status =
+				OfferStatus::Ready { invoice_confirmed_persisted_at: duration_since_epoch };
+			return true;
+		}
+
+		false
+	}
 }
 
 impl Writeable for AsyncReceiveOfferCache {

lightning/src/offers/flow.rs

@@ -1344,6 +1344,28 @@ where
 		Ok((invoice, forward_invoice_request_path))
 	}
 
+	/// Handles an incoming [`StaticInvoicePersisted`] onion message from the static invoice server.
+	/// Returns a bool indicating whether the async receive offer cache needs to be re-persisted.
+	///
+	/// [`StaticInvoicePersisted`]: crate::onion_message::async_payments::StaticInvoicePersisted
+	#[cfg(async_payments)]
+	pub(crate) fn handle_static_invoice_persisted(&self, context: AsyncPaymentsContext) -> bool {
+		let duration_since_epoch = self.duration_since_epoch();
+
+		let confirmed_offer_slot = match context {
+			AsyncPaymentsContext::StaticInvoicePersisted { path_absolute_expiry, offer_slot } => {
+				if duration_since_epoch > path_absolute_expiry {
+					return false;
+				}
+				offer_slot
+			},
+			_ => return false,
+		};
+
+		let mut cache = self.async_receive_offer_cache.lock().unwrap();
+		cache.static_invoice_persisted(confirmed_offer_slot, duration_since_epoch)
+	}
+
 	/// Get the `AsyncReceiveOfferCache` for persistence.
 	pub(crate) fn writeable_async_receive_offer_cache(&self) -> impl Writeable + '_ {
 		&self.async_receive_offer_cache