Check and refresh served static invoices

As an async recipient, we need to interactively build offers and corresponding
static invoices, the latter of which an always-online node will serve to payers
on our behalf.

Offers may be very long-lived and have a longer expiration than their
corresponding static invoice. Therefore, persist a fresh invoice with the
static invoice server when the current invoice gets close to expiration.

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -4953,9 +4953,11 @@ where
 
 	#[cfg(async_payments)]
 	fn check_refresh_async_receive_offers(&self) {
-		match self.flow.check_refresh_async_receive_offers(
-			self.get_peers_for_blinded_path(), &*self.entropy_source
-		) {
+		let peers = self.get_peers_for_blinded_path();
+		let channels = self.list_usable_channels();
+		let entropy = &*self.entropy_source;
+		let router = &*self.router;
+		match self.flow.check_refresh_async_receive_offers(peers, channels, entropy, router) {
 			Err(()) => {
 				log_error!(self.logger, "Failed to create blinded paths when requesting async receive offer paths");
 			},

lightning/src/offers/async_receive_offer_cache.rs

@@ -22,7 +22,7 @@ use crate::util::ser::{Readable, Writeable, Writer};
 use core::time::Duration;
 #[cfg(async_payments)]
 use {
-	crate::blinded_path::message::AsyncPaymentsContext,
+	crate::blinded_path::message::AsyncPaymentsContext, crate::offers::offer::OfferId,
 	crate::onion_message::async_payments::OfferPaths,
 };
 
@@ -190,6 +190,63 @@ impl AsyncReceiveOfferCache {
 		self.last_offer_paths_request_timestamp = Duration::from_secs(0);
 	}
 
+	/// Returns an iterator over the list of cached offers where the invoice is expiring soon and we
+	/// need to send an updated one to the static invoice server.
+	pub(super) fn offers_needing_invoice_refresh(
+		&self, duration_since_epoch: Duration,
+	) -> impl Iterator<Item = (&Offer, Nonce, Duration, &Responder)> {
+		self.offers.iter().filter_map(move |offer| {
+			const ONE_DAY: Duration = Duration::from_secs(24 * 60 * 60);
+
+			if offer.offer.is_expired_no_std(duration_since_epoch) {
+				return None;
+			}
+			if offer.invoice_update_attempts >= Self::MAX_UPDATE_ATTEMPTS {
+				return None;
+			}
+
+			let time_until_invoice_expiry =
+				offer.static_invoice_absolute_expiry.saturating_sub(duration_since_epoch);
+			let time_until_offer_expiry = offer
+				.offer
+				.absolute_expiry()
+				.unwrap_or_else(|| Duration::from_secs(u64::MAX))
+				.saturating_sub(duration_since_epoch);
+
+			// Update the invoice if it expires in less than a day, as long as the offer has a longer
+			// expiry than that.
+			let needs_update = time_until_invoice_expiry < ONE_DAY
+				&& time_until_offer_expiry > time_until_invoice_expiry;
+			if needs_update {
+				Some((
+					&offer.offer,
+					offer.offer_nonce,
+					offer.offer_created_at,
+					&offer.update_static_invoice_path,
+				))
+			} else {
+				None
+			}
+		})
+	}
+
+	/// Indicates that we've sent onion messages attempting to update the static invoice corresponding
+	/// to the provided offer_id. Calling this method allows the cache to self-limit how many invoice
+	/// update requests are sent.
+	///
+	/// Errors if the offer corresponding to the provided offer_id could not be found.
+	pub(super) fn increment_invoice_update_attempts(
+		&mut self, offer_id: OfferId,
+	) -> Result<(), ()> {
+		match self.offers.iter_mut().find(|offer| offer.offer.id() == offer_id) {
+			Some(offer) => {
+				offer.invoice_update_attempts += 1;
+				Ok(())
+			},
+			None => return Err(()),
+		}
+	}
+
 	/// 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.

lightning/src/offers/flow.rs

@@ -1141,16 +1141,19 @@ where
 		core::mem::take(&mut self.pending_dns_onion_messages.lock().unwrap())
 	}
 
-	/// Sends out [`OfferPathsRequest`] onion messages if we are an often-offline recipient and are
-	/// configured to interactively build offers and static invoices with a static invoice server.
+	/// Sends out [`OfferPathsRequest`] and [`ServeStaticInvoice`] onion messages if we are an
+	/// often-offline recipient and are configured to interactively build offers and static invoices
+	/// with a static invoice server.
 	///
 	/// Errors if we failed to create blinded reply paths when sending an [`OfferPathsRequest`] message.
 	#[cfg(async_payments)]
-	pub(crate) fn check_refresh_async_receive_offers<ES: Deref>(
-		&self, peers: Vec<MessageForwardNode>, entropy: ES,
+	pub(crate) fn check_refresh_async_receive_offers<ES: Deref, R: Deref>(
+		&self, peers: Vec<MessageForwardNode>, usable_channels: Vec<ChannelDetails>, entropy: ES,
+		router: R,
 	) -> Result<(), ()>
 	where
 		ES::Target: EntropySource,
+		R::Target: Router,
 	{
 		// Terminate early if this node does not intend to receive async payments.
 		if self.paths_to_static_invoice_server.is_empty() {
@@ -1176,7 +1179,7 @@ where
 				path_absolute_expiry: duration_since_epoch
 					.saturating_add(TEMP_REPLY_PATH_RELATIVE_EXPIRY),
 			});
-			let reply_paths = match self.create_blinded_paths(peers, context) {
+			let reply_paths = match self.create_blinded_paths(peers.clone(), context) {
 				Ok(paths) => paths,
 				Err(()) => {
 					return Err(());
@@ -1196,6 +1199,62 @@ where
 			);
 		}
 
+		// If a static invoice server has persisted an offer for us but the corresponding invoice is
+		// expiring soon, we need to refresh that invoice. Here we create the onion messages that will
+		// be used to request invoice refresh, based on the offers provided by the cache.
+		let mut serve_static_invoice_messages = Vec::new();
+		{
+			let cache = self.async_receive_offer_cache.lock().unwrap();
+			for offer_and_metadata in cache.offers_needing_invoice_refresh(duration_since_epoch) {
+				let (offer, offer_nonce, offer_created_at, update_static_invoice_path) =
+					offer_and_metadata;
+				let offer_id = offer.id();
+
+				let (serve_invoice_msg, reply_path_ctx) = match self
+					.create_serve_static_invoice_message(
+						offer.clone(),
+						offer_nonce,
+						offer_created_at,
+						peers.clone(),
+						usable_channels.clone(),
+						update_static_invoice_path.clone(),
+						&*entropy,
+						&*router,
+					) {
+					Ok((msg, ctx)) => (msg, ctx),
+					Err(()) => continue,
+				};
+				serve_static_invoice_messages.push((serve_invoice_msg, reply_path_ctx, offer_id));
+			}
+		}
+
+		// Enqueue the new serve_static_invoice messages in a separate loop to avoid holding the offer
+		// cache lock and the pending_async_payments_messages lock at the same time.
+		for (serve_invoice_msg, reply_path_ctx, offer_id) in serve_static_invoice_messages {
+			let context = MessageContext::AsyncPayments(reply_path_ctx);
+			let reply_paths = match self.create_blinded_paths(peers.clone(), context) {
+				Ok(paths) => paths,
+				Err(()) => continue,
+			};
+
+			{
+				// We can't fail past this point, so indicate to the cache that we've requested an invoice
+				// update.
+				let mut cache = self.async_receive_offer_cache.lock().unwrap();
+				if cache.increment_invoice_update_attempts(offer_id).is_err() {
+					continue;
+				}
+			}
+
+			let message = AsyncPaymentsMessage::ServeStaticInvoice(serve_invoice_msg);
+			enqueue_onion_message_with_reply_paths(
+				message,
+				&self.paths_to_static_invoice_server,
+				reply_paths,
+				&mut self.pending_async_payments_messages.lock().unwrap(),
+			);
+		}
+
 		Ok(())
 	}