f just send paths requests bursts once per minute

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -5140,9 +5140,9 @@ where
 	}
 
 	#[cfg(async_payments)]
-	fn check_refresh_async_receive_offers(&self) {
+	fn check_refresh_async_receive_offers(&self, timer_tick_occurred: bool) {
 		let peers = self.get_peers_for_blinded_path();
-		match self.flow.check_refresh_async_receive_offers(peers) {
+		match self.flow.check_refresh_async_receive_offers(peers, timer_tick_occurred) {
 			Err(()) => {
 				log_error!(
 					self.logger,
@@ -7148,7 +7148,7 @@ where
 			);
 
 			#[cfg(async_payments)]
-			self.check_refresh_async_receive_offers();
+			self.check_refresh_async_receive_offers(true);
 
 			// Technically we don't need to do this here, but if we have holding cell entries in a
 			// channel that need freeing, it's better to do that here and block a background task
@@ -11688,7 +11688,7 @@ where
 		// until we have some peer connection(s) to send onion messages over, so as a minor optimization
 		// refresh the cache when a peer connects.
 		#[cfg(async_payments)]
-		self.check_refresh_async_receive_offers();
+		self.check_refresh_async_receive_offers(false);
 		res
 	}
 

lightning/src/offers/async_receive_offer_cache.rs

@@ -161,7 +161,14 @@ const OFFER_REFRESH_THRESHOLD: Duration = Duration::from_secs(2 * 60 * 60);
 #[cfg(async_payments)]
 impl AsyncReceiveOfferCache {
 	/// Remove expired offers from the cache, returning whether new offers are needed.
-	pub(super) fn prune_expired_offers(&mut self, duration_since_epoch: Duration) -> bool {
+	pub(super) fn prune_expired_offers(
+		&mut self, duration_since_epoch: Duration, timer_tick_occurred: bool,
+	) -> bool {
+		// Allow more offer paths requests to be sent out in a burst roughly once per minute.
+		if timer_tick_occurred {
+			self.reset_offer_paths_request_attempts();
+		}
+
 		// Remove expired offers from the cache.
 		let mut offer_was_removed = false;
 		self.offers.retain(|offer| {
@@ -172,15 +179,6 @@ impl AsyncReceiveOfferCache {
 			true
 		});
 
-		// If we just removed a newly expired offer, force allowing more paths request attempts.
-		if offer_was_removed {
-			self.reset_offer_paths_request_attempts();
-		} else {
-			// If we haven't attempted to request new paths in a long time, allow more requests to go out
-			// if/when needed.
-			self.check_reset_offer_paths_request_attempts(duration_since_epoch);
-		}
-
 		self.needs_new_offers(duration_since_epoch)
 			&& self.offer_paths_request_attempts < MAX_UPDATE_ATTEMPTS
 	}
@@ -217,17 +215,8 @@ impl AsyncReceiveOfferCache {
 		self.last_offer_paths_request_timestamp = duration_since_epoch;
 	}
 
-	/// If we haven't sent an offer paths request in a long time, reset the limit to allow more
-	/// requests to be sent out if/when needed.
-	fn check_reset_offer_paths_request_attempts(&mut self, duration_since_epoch: Duration) {
-		let should_reset =
-			self.last_offer_paths_request_timestamp.saturating_add(PATHS_REQUESTS_RESET_INTERVAL)
-				< duration_since_epoch;
-		if should_reset {
-			self.reset_offer_paths_request_attempts();
-		}
-	}
-
+	/// Called on timer tick (roughly once per minute) to allow another MAX_UPDATE_ATTEMPTS offer
+	/// paths requests to go out.
 	fn reset_offer_paths_request_attempts(&mut self) {
 		self.offer_paths_request_attempts = 0;
 		self.last_offer_paths_request_timestamp = Duration::from_secs(0);

lightning/src/offers/flow.rs

@@ -1127,13 +1127,16 @@ where
 	///
 	/// # Usage
 	///
-	/// This method should be called on peer connection and every few minutes or so, to keep the
-	/// offers cache updated.
+	/// This method should be called on peer connection and once per minute or so, to keep the offers
+	/// cache updated.
+	///
+	/// SHOULD NOT be called much more than once per minute or too many messages may be sent to the
+	/// server node.
 	///
 	/// 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(
-		&self, peers: Vec<MessageForwardNode>,
+		&self, peers: Vec<MessageForwardNode>, timer_tick_occurred: bool,
 	) -> Result<(), ()> {
 		// Terminate early if this node does not intend to receive async payments.
 		if self.paths_to_static_invoice_server.is_empty() {
@@ -1148,7 +1151,7 @@ where
 			.async_receive_offer_cache
 			.lock()
 			.unwrap()
-			.prune_expired_offers(duration_since_epoch);
+			.prune_expired_offers(duration_since_epoch, timer_tick_occurred);
 
 		// If we need new offers, send out offer paths request messages to the static invoice server.
 		if needs_new_offers {