Refresh served static invoices on each timer tick

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.

We want the static invoice server to always have the freshest possible invoice
available, so on each timer tick for every offer that is either currently in
use or pending confirmation, send them a new invoice.

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -5251,7 +5251,17 @@ where
 	#[cfg(async_payments)]
 	fn check_refresh_async_receive_offer_cache(&self, timer_tick_occurred: bool) {
 		let peers = self.get_peers_for_blinded_path();
-		match self.flow.check_refresh_async_receive_offer_cache(peers, timer_tick_occurred) {
+		let channels = self.list_usable_channels();
+		let entropy = &*self.entropy_source;
+		let router = &*self.router;
+		let refresh_res = self.flow.check_refresh_async_receive_offer_cache(
+			peers,
+			channels,
+			entropy,
+			router,
+			timer_tick_occurred,
+		);
+		match refresh_res {
 			Err(()) => {
 				log_error!(
 					self.logger,

lightning/src/offers/async_receive_offer_cache.rs

@@ -365,6 +365,30 @@ impl AsyncReceiveOfferCache {
 		self.offer_paths_request_attempts = 0;
 	}
 
+	/// Returns an iterator over the list of cached offers where we need to send an updated invoice to
+	/// the static invoice server.
+	pub(super) fn offers_needing_invoice_refresh(
+		&self,
+	) -> impl Iterator<Item = (&Offer, Nonce, u16, &Responder)> {
+		// For any offers which are either in use or pending confirmation by the server, we should send
+		// them a fresh invoice on each timer tick.
+		self.offers_with_idx().filter_map(|(idx, offer)| {
+			let needs_invoice_update =
+				offer.status == OfferStatus::Used || offer.status == OfferStatus::Pending;
+			if needs_invoice_update {
+				let offer_slot = idx.try_into().unwrap_or(u16::MAX);
+				Some((
+					&offer.offer,
+					offer.offer_nonce,
+					offer_slot,
+					&offer.update_static_invoice_path,
+				))
+			} else {
+				None
+			}
+		})
+	}
+
 	/// 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

@@ -1134,8 +1134,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
 	///
@@ -1145,9 +1146,14 @@ 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_offer_cache(
-		&self, peers: Vec<MessageForwardNode>, timer_tick_occurred: bool,
-	) -> Result<(), ()> {
+	pub(crate) fn check_refresh_async_receive_offer_cache<ES: Deref, R: Deref>(
+		&self, peers: Vec<MessageForwardNode>, usable_channels: Vec<ChannelDetails>, entropy: ES,
+		router: R, timer_tick_occurred: bool,
+	) -> 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.lock().unwrap().is_empty() {
 			return Ok(());
@@ -1169,7 +1175,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(());
@@ -1190,9 +1196,88 @@ where
 			);
 		}
 
+		if timer_tick_occurred {
+			self.check_refresh_static_invoices(
+				peers,
+				usable_channels,
+				duration_since_epoch,
+				entropy,
+				router,
+			);
+		}
+
 		Ok(())
 	}
 
+	/// Enqueue onion messages that will used to request invoice refresh from the static invoice
+	/// server, 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>,
+		duration_since_epoch: Duration, entropy: ES, router: R,
+	) where
+		ES::Target: EntropySource,
+		R::Target: Router,
+	{
+		let mut serve_static_invoice_msgs = Vec::new();
+		{
+			let cache = self.async_receive_offer_cache.lock().unwrap();
+			for offer_and_metadata in cache.offers_needing_invoice_refresh() {
+				let (offer, offer_nonce, slot_number, update_static_invoice_path) =
+					offer_and_metadata;
+
+				let (invoice, forward_invreq_path) = match self.create_static_invoice_for_server(
+					offer,
+					offer_nonce,
+					peers.clone(),
+					usable_channels.clone(),
+					&*entropy,
+					&*router,
+				) {
+					Ok((invoice, path)) => (invoice, path),
+					Err(()) => continue,
+				};
+
+				let reply_path_context = {
+					let path_absolute_expiry =
+						duration_since_epoch.saturating_add(TEMP_REPLY_PATH_RELATIVE_EXPIRY);
+					MessageContext::AsyncPayments(AsyncPaymentsContext::StaticInvoicePersisted {
+						path_absolute_expiry,
+						offer_id: offer.id(),
+					})
+				};
+
+				let serve_invoice_message = ServeStaticInvoice {
+					invoice,
+					forward_invoice_request_path: forward_invreq_path,
+					invoice_slot: slot_number,
+				};
+				serve_static_invoice_msgs.push((
+					serve_invoice_message,
+					update_static_invoice_path.clone(),
+					reply_path_context,
+				));
+			}
+		}
+
+		// 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) in serve_static_invoice_msgs {
+			let reply_paths = match self.create_blinded_paths(peers.clone(), reply_path_ctx) {
+				Ok(paths) => paths,
+				Err(()) => continue,
+			};
+
+			let message = AsyncPaymentsMessage::ServeStaticInvoice(serve_invoice_msg);
+			enqueue_onion_message_with_reply_paths(
+				message,
+				&[serve_invoice_path.into_blinded_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've built a new async receive offer and
 	/// need the corresponding [`StaticInvoice`] to be persisted by the static invoice server.

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_blinded_path(self) -> BlindedMessagePath {
+		self.reply_path
+	}
 }
 
 /// Instructions for how and where to send the response to an onion message.