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

@@ -13465,6 +13465,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

@@ -22,8 +22,11 @@ use crate::prelude::*;
 use crate::util::ser::{Readable, Writeable, Writer};
 use core::time::Duration;
 
+#[cfg(async_payments)]
+use crate::blinded_path::message::AsyncPaymentsContext;
+
 /// 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.
@@ -361,6 +364,44 @@ 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.
+	///
+	/// [`StaticInvoicePersisted`]: crate::onion_message::async_payments::StaticInvoicePersisted
+	pub(super) fn static_invoice_persisted(
+		&mut self, context: AsyncPaymentsContext, duration_since_epoch: Duration,
+	) -> bool {
+		let offer_id = match context {
+			AsyncPaymentsContext::StaticInvoicePersisted { path_absolute_expiry, offer_id } => {
+				if duration_since_epoch > path_absolute_expiry {
+					return false;
+				}
+				offer_id
+			},
+			_ => return false,
+		};
+
+		let mut offers = self.offers.iter_mut();
+		let offer_entry = offers.find(|o| o.as_ref().map_or(false, |o| o.offer.id() == offer_id));
+		if let Some(Some(ref mut offer)) = offer_entry {
+			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

@@ -1343,6 +1343,16 @@ 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 mut cache = self.async_receive_offer_cache.lock().unwrap();
+		cache.static_invoice_persisted(context, self.duration_since_epoch())
+	}
+
 	/// Get the `AsyncReceiveOfferCache` for persistence.
 	pub(crate) fn writeable_async_receive_offer_cache(&self) -> impl Writeable + '_ {
 		&self.async_receive_offer_cache