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

@@ -5107,7 +5107,10 @@ where
 	#[cfg(async_payments)]
 	fn check_refresh_async_receive_offers(&self) {
 		let peers = self.get_peers_for_blinded_path();
-		match self.flow.check_refresh_async_receive_offers(peers, &*self.entropy_source) {
+		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,

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,
 };
 
@@ -210,6 +210,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 >= 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

@@ -1116,8 +1116,9 @@ 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.
 	///
 	/// # Usage
 	///
@@ -1126,11 +1127,13 @@ where
 	///
 	/// 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() {
@@ -1157,7 +1160,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(());
@@ -1179,9 +1182,85 @@ where
 			);
 		}
 
+		self.check_refresh_static_invoices(peers, usable_channels, entropy, router);
+
 		Ok(())
 	}
 
+	/// 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 enqueue the onion messages that will
+	/// be used to request invoice refresh, based on the offers provided by the cache.
+	#[cfg(async_payments)]
+	fn check_refresh_static_invoices<ES: Deref, R: Deref>(
+		&self, peers: Vec<MessageForwardNode>, usable_channels: Vec<ChannelDetails>, entropy: ES,
+		router: R,
+	) where
+		ES::Target: EntropySource,
+		R::Target: Router,
+	{
+		let duration_since_epoch = self.duration_since_epoch();
+
+		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,
+					update_static_invoice_path.clone(),
+					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, serve_invoice_path, 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,
+				&[serve_invoice_path.into_reply_path()],
+				reply_paths,
+				&mut self.pending_async_payments_messages.lock().unwrap(),
+			);
+		}
+	}
+
 	/// Handles an incoming [`OfferPaths`] message from the static invoice server, sending out
 	/// [`ServeStaticInvoice`] onion messages in response if we want to use the paths we've received
 	/// to build and cache an async receive offer.

lightning/src/onion_message/messenger.rs

@@ -432,6 +432,12 @@ impl Responder {
 			context: Some(context),
 		}
 	}
+
+	/// Converts a [`Responder`] into its inner [`BlindedMessagePath`].
+	#[cfg(async_payments)]
+	pub(crate) fn into_reply_path(self) -> BlindedMessagePath {
+		self.reply_path
+	}
 }
 
 /// Instructions for how and where to send the response to an onion message.