Add BoundedMap to limit LSPS5/client pending requests

Replaces HashMap with BoundedMap (HashMap + FIFO eviction) since requests
no longer expire by time. This requires minimal client code changes, provides
HashMap ergonomics with O(1) operations and VecDeque-like capacity limits.

Author: martinsaposnic

lightning-liquidity/src/lsps5/client.rs

@@ -21,6 +21,7 @@ use crate::lsps5::msgs::{
 use crate::message_queue::MessageQueue;
 use crate::prelude::{new_hash_map, HashMap};
 use crate::sync::{Arc, Mutex, RwLock};
+use crate::utils::bounded_map::BoundedMap;
 use crate::utils::generate_request_id;
 
 use super::msgs::{LSPS5AppName, LSPS5Error, LSPS5WebhookUrl};
@@ -40,17 +41,19 @@ use core::ops::Deref;
 pub struct LSPS5ClientConfig {}
 
 struct PeerState {
-	pending_set_webhook_requests: HashMap<LSPSRequestId, (LSPS5AppName, LSPS5WebhookUrl)>,
-	pending_list_webhooks_requests: HashMap<LSPSRequestId, ()>,
-	pending_remove_webhook_requests: HashMap<LSPSRequestId, LSPS5AppName>,
+	pending_set_webhook_requests: BoundedMap<LSPSRequestId, (LSPS5AppName, LSPS5WebhookUrl)>,
+	pending_list_webhooks_requests: BoundedMap<LSPSRequestId, ()>,
+	pending_remove_webhook_requests: BoundedMap<LSPSRequestId, LSPS5AppName>,
 }
 
+const MAX_PENDING_REQUESTS: usize = 5;
+
 impl PeerState {
 	fn new() -> Self {
 		Self {
-			pending_set_webhook_requests: new_hash_map(),
-			pending_list_webhooks_requests: new_hash_map(),
-			pending_remove_webhook_requests: new_hash_map(),
+			pending_set_webhook_requests: BoundedMap::new(MAX_PENDING_REQUESTS),
+			pending_list_webhooks_requests: BoundedMap::new(MAX_PENDING_REQUESTS),
+			pending_remove_webhook_requests: BoundedMap::new(MAX_PENDING_REQUESTS),
 		}
 	}
 }
@@ -364,19 +367,31 @@ where
 mod tests {
 
 	use super::*;
-	use crate::{
-		lsps0::ser::LSPSRequestId, lsps5::msgs::SetWebhookResponse, tests::utils::TestEntropy,
-	};
+	use crate::{lsps0::ser::LSPSRequestId, lsps5::msgs::SetWebhookResponse};
 	use bitcoin::{key::Secp256k1, secp256k1::SecretKey};
+	use core::sync::atomic::{AtomicU64, Ordering};
+
+	struct UniqueTestEntropy {
+		counter: AtomicU64,
+	}
+
+	impl EntropySource for UniqueTestEntropy {
+		fn get_secure_random_bytes(&self) -> [u8; 32] {
+			let counter = self.counter.fetch_add(1, Ordering::SeqCst);
+			let mut bytes = [0u8; 32];
+			bytes[0..8].copy_from_slice(&counter.to_be_bytes());
+			bytes
+		}
+	}
 
 	fn setup_test_client() -> (
-		LSPS5ClientHandler<Arc<TestEntropy>>,
+		LSPS5ClientHandler<Arc<UniqueTestEntropy>>,
 		Arc<MessageQueue>,
 		Arc<EventQueue>,
 		PublicKey,
 		PublicKey,
 	) {
-		let test_entropy_source = Arc::new(TestEntropy {});
+		let test_entropy_source = Arc::new(UniqueTestEntropy { counter: AtomicU64::new(2) });
 		let message_queue = Arc::new(MessageQueue::new());
 		let event_queue = Arc::new(EventQueue::new());
 		let client = LSPS5ClientHandler::new(
@@ -497,4 +512,44 @@ mod tests {
 		let error = result.unwrap_err();
 		assert!(error.err.to_lowercase().contains("unknown request id"));
 	}
+
+	#[test]
+	fn test_pending_request_eviction() {
+		let (client, _, _, peer, _) = setup_test_client();
+
+		let mut request_ids = Vec::new();
+		for i in 0..MAX_PENDING_REQUESTS {
+			let req_id = client
+				.set_webhook(peer, format!("app-{}", i), format!("https://example.com/hook{}", i))
+				.unwrap();
+			request_ids.push(req_id);
+		}
+
+		{
+			let outer_state_lock = client.per_peer_state.read().unwrap();
+			let peer_state = outer_state_lock.get(&peer).unwrap().lock().unwrap();
+			for req_id in &request_ids {
+				assert!(peer_state.pending_set_webhook_requests.contains_key(req_id));
+			}
+			assert_eq!(peer_state.pending_set_webhook_requests.len(), MAX_PENDING_REQUESTS);
+		}
+
+		let new_req_id = client
+			.set_webhook(peer, "app-new".to_string(), "https://example.com/hook-new".to_string())
+			.unwrap();
+
+		{
+			let outer_state_lock = client.per_peer_state.read().unwrap();
+			let peer_state = outer_state_lock.get(&peer).unwrap().lock().unwrap();
+			assert_eq!(peer_state.pending_set_webhook_requests.len(), MAX_PENDING_REQUESTS);
+
+			assert!(!peer_state.pending_set_webhook_requests.contains_key(&request_ids[0]));
+
+			for req_id in &request_ids[1..] {
+				assert!(peer_state.pending_set_webhook_requests.contains_key(req_id));
+			}
+
+			assert!(peer_state.pending_set_webhook_requests.contains_key(&new_req_id));
+		}
+	}
 }