Remove now-unused ServeStaticInv::inv_slot from OM

In the initially-merged version of the static invoice server protocol, the
static invoice server would sometimes have to find a specific static invoice
based on (recipient_id, invoice_slot) and sometime based on (recipient_id,
invoice_id). This made the API harder to use in terms of how the server would
index into the KVStore.

We'd like to transition to the server always finding a specific invoice based on
(recipient_id, invoice_slot) and get rid of the invoice_id concept.

In the previous commit the server began including the invoice_slot in the
ServeStaticInvoice blinded path context that gets provided back to themselves.
Therefore there is no need for the recipient to redundantly include it in the
ServeStaticInvoice onion message itself.

Author: valentinewallace

lightning/src/offers/async_receive_offer_cache.rs

@@ -337,12 +337,13 @@ impl AsyncReceiveOfferCache {
 
 	/// If we have any empty slots in the cache or offers that can and should be replaced with a fresh
 	/// offer, here we return the index of the slot that needs a new offer. The index is used for
-	/// setting [`ServeStaticInvoice::invoice_slot`] when sending the corresponding new static invoice
-	/// to the server, so the server knows which existing persisted invoice is being replaced, if any.
+	/// setting [`OfferPathsRequest::invoice_slot`] when requesting offer paths from the server, so
+	/// the server can include the slot in the offer paths and reply paths that they create in
+	/// response.
 	///
 	/// Returns `None` if the cache is full and no offers can currently be replaced.
 	///
-	/// [`ServeStaticInvoice::invoice_slot`]: crate::onion_message::async_payments::ServeStaticInvoice::invoice_slot
+	/// [`OfferPathsRequest::invoice_slot`]: crate::onion_message::async_payments::OfferPathsRequest::invoice_slot
 	fn needs_new_offer_idx(&self, duration_since_epoch: Duration) -> Option<usize> {
 		// If we have any empty offer slots, return the first one we find
 		let empty_slot_idx_opt = self.offers.iter().position(|offer_opt| offer_opt.is_none());
@@ -411,10 +412,10 @@ impl AsyncReceiveOfferCache {
 	/// the static invoice server.
 	pub(super) fn offers_needing_invoice_refresh(
 		&self, duration_since_epoch: Duration,
-	) -> impl Iterator<Item = (&Offer, Nonce, u16, &Responder)> {
+	) -> impl Iterator<Item = (&Offer, Nonce, &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(move |(idx, offer)| {
+		self.offers_with_idx().filter_map(move |(_, offer)| {
 			let needs_invoice_update = match offer.status {
 				OfferStatus::Used { invoice_created_at } => {
 					invoice_created_at.saturating_add(INVOICE_REFRESH_THRESHOLD)
@@ -426,13 +427,7 @@ impl AsyncReceiveOfferCache {
 				OfferStatus::Ready { .. } => false,
 			};
 			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,
-				))
+				Some((&offer.offer, offer.offer_nonce, &offer.update_static_invoice_path))
 			} else {
 				None
 			}

lightning/src/offers/flow.rs

@@ -1317,8 +1317,7 @@ where
 			let duration_since_epoch = self.duration_since_epoch();
 			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, slot_number, update_static_invoice_path) =
-					offer_and_metadata;
+				let (offer, offer_nonce, update_static_invoice_path) = offer_and_metadata;
 
 				let (invoice, forward_invreq_path) = match self.create_static_invoice_for_server(
 					offer,
@@ -1342,7 +1341,6 @@ where
 				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,
@@ -1517,8 +1515,7 @@ where
 			})
 		};
 
-		let serve_invoice_message =
-			ServeStaticInvoice { invoice, forward_invoice_request_path, invoice_slot };
+		let serve_invoice_message = ServeStaticInvoice { invoice, forward_invoice_request_path };
 		Some((serve_invoice_message, reply_path_context))
 	}
 

lightning/src/onion_message/async_payments.rs

@@ -172,11 +172,6 @@ pub struct ServeStaticInvoice {
 	/// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
 	/// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
 	pub forward_invoice_request_path: BlindedMessagePath,
-	/// The "slot" in the static invoice server's database that this invoice should go into. This
-	/// allows recipients to replace a specific invoice that is stored by the server, which is useful
-	/// for limiting the number of invoices stored by the server while also keeping all the invoices
-	/// persisted with the server fresh.
-	pub invoice_slot: u16,
 }
 
 /// Confirmation from a static invoice server  that a [`StaticInvoice`] was persisted and the
@@ -251,7 +246,6 @@ impl_writeable_tlv_based!(OfferPaths, {
 impl_writeable_tlv_based!(ServeStaticInvoice, {
 	(0, invoice, required),
 	(2, forward_invoice_request_path, required),
-	(4, invoice_slot, required),
 });
 
 impl_writeable_tlv_based!(StaticInvoicePersisted, {});