f always have new offer ready

Author: valentinewallace

lightning/src/offers/async_receive_offer_cache.rs

@@ -142,24 +142,21 @@ impl AsyncReceiveOfferCache {
 // The target number of offers we want to have cached at any given time, to mitigate too much
 // reuse of the same offer.
 #[cfg(async_payments)]
-const NUM_CACHED_OFFERS_TARGET: usize = 3;
+const MAX_CACHED_OFFERS_TARGET: usize = 10;
+
+///
+#[cfg(async_payments)]
+const UNUSED_OFFERS_TARGET: u8 = 3;
 
 // The max number of times we'll attempt to request offer paths or attempt to refresh a static
 // invoice before giving up.
 #[cfg(async_payments)]
 const MAX_UPDATE_ATTEMPTS: u8 = 3;
 
-// If we run out of attempts to request offer paths from the static invoice server, we'll stop
-// sending requests for some time. After this amount of time has passed, more requests are allowed
-// to be sent out.
-#[cfg(async_payments)]
-const PATHS_REQUESTS_RESET_INTERVAL: Duration = Duration::from_secs(3 * 60 * 60);
-
-// If an offer is 90% of the way through its lifespan, it's expiring soon. This allows us to be
-// flexible for various offer lifespans, i.e. an offer that lasts 10 days expires soon after 9 days
-// and an offer that lasts 10 years expires soon after 9 years.
+// If an offer is more than 2 hours old, go ahead and refresh it because we always want to have the
+// freshest offer possible when a user goes to retrieve a cached offer.
 #[cfg(async_payments)]
-const OFFER_EXPIRES_SOON_THRESHOLD_PERCENT: u64 = 90;
+const OFFER_REFRESH_THRESHOLD: Duration = Duration::from_secs(2 * 60 * 60);
 
 #[cfg(async_payments)]
 impl AsyncReceiveOfferCache {
@@ -190,25 +187,26 @@ impl AsyncReceiveOfferCache {
 
 	/// Returns a bool indicating whether new offers are needed in the cache.
 	fn needs_new_offers(&self, duration_since_epoch: Duration) -> bool {
-		// If we have fewer than NUM_CACHED_OFFERS_TARGET offers that aren't expiring soon, indicate
-		// that new offers should be interactively built.
-		let num_unexpiring_offers = self
+		// We always want to have the freshest offer possible when a user goes to retrieve a cached
+		// offer, so if we either don't have enough offers or we have a replaceable offer that is at
+		// least a few hours old, then attempt to build a new one.
+		let cached_offers_target =
+			core::cmp::min(self.max_invoices_stored_by_server, MAX_CACHED_OFFERS_TARGET);
+		if self.offers.len() < cached_offers_target {
+			return true;
+		}
+
+		let num_unused_offers_needing_replacement = self
 			.offers
 			.iter()
+			.filter(|offer| !matches!(offer.status, OfferStatus::Used))
+			.filter(|offer| !matches!(offer.status, OfferStatus::PendingInvoicePersist))
 			.filter(|offer| {
-				let offer_absolute_expiry = offer.offer.absolute_expiry().unwrap_or(Duration::MAX);
-				let offer_created_at = offer.offer_created_at;
-				let offer_lifespan =
-					offer_absolute_expiry.saturating_sub(offer_created_at).as_secs();
-				let elapsed = duration_since_epoch.saturating_sub(offer_created_at).as_secs();
-
-				// If an offer is in the last 10% of its lifespan, it's expiring soon.
-				elapsed.saturating_mul(100)
-					< offer_lifespan.saturating_mul(OFFER_EXPIRES_SOON_THRESHOLD_PERCENT)
+				offer.offer_created_at
+					< duration_since_epoch.saturating_sub(OFFER_REFRESH_THRESHOLD)
 			})
 			.count();
-
-		num_unexpiring_offers < NUM_CACHED_OFFERS_TARGET
+		num_unused_offers_needing_replacement < UNUSED_OFFERS_TARGET
 	}
 
 	// Indicates that onion messages requesting new offer paths have been sent to the static invoice