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

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

@@ -316,6 +316,24 @@ impl AsyncReceiveOfferCache {
 		self.offer_paths_request_attempts = 0;
 		self.last_offer_paths_request_timestamp = Duration::from_secs(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) {
+			offer.status =
+				OfferStatus::Ready { invoice_confirmed_persisted_at: duration_since_epoch };
+			return true;
+		}
+
+		false
+	}
 }
 
 impl Writeable for AsyncReceiveOfferCache {

lightning/src/offers/flow.rs

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