lsps2: Restore offer lease caches

After startup discovery, schedule refills for persisted BOLT12 offer
descriptors. Reuse valid persisted leases and renegotiate only missing
or stale cache entries.

Co-Authored-By: HAL 9000

Author: tnull

src/lib.rs

@@ -827,6 +827,17 @@ impl Node {
 								liquidity_logger,
 								"LSP protocols discovery complete.",
 							);
+							if let Err(error) = liquidity_handler
+								.lsps2_client()
+								.refill_pending_offer_leases(&discovery_cm)
+								.await
+							{
+								log_error!(
+									liquidity_logger,
+									"Failed scheduling LSPS2 offer lease refills: {}",
+									error
+								);
+							}
 						}
 					}
 				}

src/liquidity/client/lsps2/mod.rs

@@ -150,6 +150,31 @@ where
 		Ok(())
 	}
 
+	pub(crate) async fn refill_pending_offer_leases(
+		self: &Arc<Self>, connection_manager: &Arc<ConnectionManager<L>>,
+	) -> Result<(), Error> {
+		self.prune_stale_pending_offers().await?;
+		let pending_offers = self.pending_offer_state.lock().expect("lock").offers();
+		for pending_offer in pending_offers {
+			match pending_offer.amount {
+				PendingOfferAmount::Fixed { amount_msat, max_total_fee_msat } => {
+					self.schedule_fixed_lease_refill(
+						amount_msat,
+						max_total_fee_msat,
+						connection_manager,
+					);
+				},
+				PendingOfferAmount::Variable { max_proportional_fee_ppm_msat } => {
+					self.schedule_variable_lease_refill(
+						max_proportional_fee_ppm_msat,
+						connection_manager,
+					);
+				},
+			}
+		}
+		Ok(())
+	}
+
 	pub(crate) async fn pending_offer(
 		&self, offer_id: PendingOfferId,
 	) -> Result<Option<PendingOffer>, Error> {

src/liquidity/client/lsps2/state.rs

@@ -172,6 +172,10 @@ impl PendingOfferState {
 		self.offers.contains_key(id)
 	}
 
+	pub(crate) fn offers(&self) -> Vec<PendingOffer> {
+		self.offers.values().cloned().collect()
+	}
+
 	pub(crate) fn prune(&mut self, now: u64) -> Vec<PendingOfferId> {
 		let removed = self
 			.offers
@@ -594,6 +598,29 @@ mod tests {
 		assert!(state.contains(&long_lived_id));
 	}
 
+	#[test]
+	fn pending_offer_registry_lists_cached_offers() {
+		let fixed = pending_offer(
+			1,
+			PendingOfferAmount::Fixed { amount_msat: 1_000, max_total_fee_msat: None },
+			None,
+			1,
+		);
+		let variable = pending_offer(
+			2,
+			PendingOfferAmount::Variable { max_proportional_fee_ppm_msat: None },
+			None,
+			2,
+		);
+		let (state, removed) =
+			PendingOfferState::from_offers(vec![fixed.clone(), variable.clone()], 2, 10);
+		assert!(removed.is_empty());
+
+		let mut ids = state.offers().into_iter().map(|offer| offer.id).collect::<Vec<_>>();
+		ids.sort();
+		assert_eq!(ids, vec![fixed.id, variable.id]);
+	}
+
 	#[test]
 	fn invoice_requests_are_serialized_per_offer() {
 		let first_id = PendingOfferId::from(OfferId([1; 32]));