Add setter for paths to static invoice server

In future commits, as part of being an async recipient, we will interactively
build offers and static invoices with an always-online node that will serve
static invoices on our behalf.

Here we add a setter for the blinded paths that we as an async recipient will
use to contact the static invoice server to get paths to put in our offers.

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -11055,6 +11055,22 @@ where
 		)
 	}
 
+	/// Sets the [`BlindedMessagePath`]s that we will use as an async recipient to interactively build
+	/// [`Offer`]s with a static invoice server, so the server can serve [`StaticInvoice`]s to payers
+	/// on our behalf when we're offline.
+	///
+	/// This method only needs to be called once when the server first takes on the recipient as a
+	/// client, or when the paths change, e.g. if the paths are set to expire at a particular time.
+	#[cfg(async_payments)]
+	pub fn set_paths_to_static_invoice_server(
+		&self, paths_to_static_invoice_server: Vec<BlindedMessagePath>,
+	) -> Result<(), ()> {
+		self.flow.set_paths_to_static_invoice_server(paths_to_static_invoice_server)?;
+
+		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
+		Ok(())
+	}
+
 	/// Pays for an [`Offer`] using the given parameters by creating an [`InvoiceRequest`] and
 	/// enqueuing it to be sent via an onion message. [`ChannelManager`] will pay the actual
 	/// [`Bolt12Invoice`] once it is received.

lightning/src/offers/async_receive_offer_cache.rs

@@ -23,6 +23,7 @@ use crate::util::ser::{Readable, Writeable, Writer};
 use core::time::Duration;
 
 /// The status of this offer in the cache.
+#[derive(Clone)]
 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.
@@ -42,6 +43,7 @@ enum OfferStatus {
 	Pending,
 }
 
+#[derive(Clone)]
 struct AsyncReceiveOffer {
 	offer: Offer,
 	/// Whether this offer is used, ready for use, or pending invoice persistence with the static
@@ -141,8 +143,35 @@ impl AsyncReceiveOfferCache {
 	pub(super) fn paths_to_static_invoice_server(&self) -> Vec<BlindedMessagePath> {
 		self.paths_to_static_invoice_server.clone()
 	}
+
+	/// Sets the [`BlindedMessagePath`]s that we will use as an async recipient to interactively build
+	/// [`Offer`]s with a static invoice server, so the server can serve [`StaticInvoice`]s to payers
+	/// on our behalf when we're offline.
+	///
+	/// [`StaticInvoice`]: crate::offers::static_invoice::StaticInvoice
+	#[cfg(async_payments)]
+	pub fn set_paths_to_static_invoice_server(
+		&mut self, paths_to_static_invoice_server: Vec<BlindedMessagePath>,
+	) -> Result<(), ()> {
+		if paths_to_static_invoice_server.is_empty() {
+			return Err(());
+		}
+
+		self.paths_to_static_invoice_server = paths_to_static_invoice_server;
+		if self.offers.is_empty() {
+			// See `AsyncReceiveOfferCache::offers`.
+			self.offers = vec![None; MAX_CACHED_OFFERS_TARGET];
+		}
+		Ok(())
+	}
 }
 
+// The target number of offers we want to have cached at any given time, to mitigate too much
+// reuse of the same offer while also limiting the amount of space our offers take up on the
+// server's end.
+#[cfg(async_payments)]
+const MAX_CACHED_OFFERS_TARGET: usize = 10;
+
 impl Writeable for AsyncReceiveOfferCache {
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 		write_tlv_fields!(w, {

lightning/src/offers/flow.rs

@@ -158,6 +158,27 @@ where
 		self
 	}
 
+	/// Sets the [`BlindedMessagePath`]s that we will use as an async recipient to interactively build
+	/// [`Offer`]s with a static invoice server, so the server can serve [`StaticInvoice`]s to payers
+	/// on our behalf when we're offline.
+	///
+	/// This method only needs to be called once when the server first takes on the recipient as a
+	/// client, or when the paths change, e.g. if the paths are set to expire at a particular time.
+	#[cfg(async_payments)]
+	pub(crate) fn set_paths_to_static_invoice_server(
+		&self, paths_to_static_invoice_server: Vec<BlindedMessagePath>,
+	) -> Result<(), ()> {
+		// Store the paths in the async receive cache so they are persisted with the cache, but also
+		// store them in-memory in the `OffersMessageFlow` so the flow has access to them when building
+		// onion messages to send to the static invoice server, without introducing undesirable lock
+		// dependencies with the cache.
+		*self.paths_to_static_invoice_server.lock().unwrap() =
+			paths_to_static_invoice_server.clone();
+
+		let mut cache = self.async_receive_offer_cache.lock().unwrap();
+		cache.set_paths_to_static_invoice_server(paths_to_static_invoice_server)
+	}
+
 	/// Gets the node_id held by this [`OffersMessageFlow`]`
 	fn get_our_node_id(&self) -> PublicKey {
 		self.our_network_pubkey