refactor: Make filter loading range based (#269)

Author: xdustinface

dash-spv/src/storage/disk/state.rs

@@ -600,13 +600,8 @@ impl StorageManager for DiskStorageManager {
         self.filters.write().await.store_items_at_height(&[filter.to_vec()], height, self).await
     }
 
-    async fn load_filter(&self, height: u32) -> StorageResult<Option<Vec<u8>>> {
-        self.filters
-            .write()
-            .await
-            .get_items(height..height + 1)
-            .await
-            .map(|items| items.first().cloned())
+    async fn load_filters(&self, range: std::ops::Range<u32>) -> StorageResult<Vec<Vec<u8>>> {
+        self.filters.write().await.get_items(range).await
     }
 
     async fn store_metadata(&mut self, key: &str, value: &[u8]) -> StorageResult<()> {

dash-spv/src/storage/memory.rs

@@ -201,8 +201,14 @@ impl StorageManager for MemoryStorageManager {
         Ok(())
     }
 
-    async fn load_filter(&self, height: u32) -> StorageResult<Option<Vec<u8>>> {
-        Ok(self.filters.get(&height).cloned())
+    async fn load_filters(&self, range: Range<u32>) -> StorageResult<Vec<Vec<u8>>> {
+        let mut result = Vec::new();
+        for height in range {
+            if let Some(filter) = self.filters.get(&height) {
+                result.push(filter.clone());
+            }
+        }
+        Ok(result)
     }
 
     async fn store_metadata(&mut self, key: &str, value: &[u8]) -> StorageResult<()> {

dash-spv/src/storage/mod.rs

@@ -142,8 +142,8 @@ pub trait StorageManager: Send + Sync {
     /// Store a compact filter at a blockchain height.
     async fn store_filter(&mut self, height: u32, filter: &[u8]) -> StorageResult<()>;
 
-    /// Load a compact filter by blockchain height.
-    async fn load_filter(&self, height: u32) -> StorageResult<Option<Vec<u8>>>;
+    /// Load compact filters in the given blockchain height range.
+    async fn load_filters(&self, range: Range<u32>) -> StorageResult<Vec<Vec<u8>>>;
 
     /// Store metadata.
     async fn store_metadata(&mut self, key: &str, value: &[u8]) -> StorageResult<()>;

dash-spv/tests/segmented_storage_test.rs

@@ -314,11 +314,13 @@ async fn test_mixed_operations() {
     assert_eq!(storage.get_tip_height().await.unwrap(), Some(74_999));
     assert_eq!(storage.get_filter_tip_height().await.unwrap(), Some(74_999));
 
-    assert_eq!(storage.load_filter(1000).await.unwrap().unwrap(), vec![(1000 % 256) as u8; 100]);
-    assert_eq!(
-        storage.load_filter(50_000).await.unwrap().unwrap(),
-        vec![(50_000 % 256) as u8; 100]
-    );
+    let filters = storage.load_filters(1000..1001).await.unwrap();
+    assert_eq!(filters.len(), 1);
+    assert_eq!(filters[0], vec![(1000 % 256) as u8; 100]);
+
+    let filters = storage.load_filters(50_000..50_001).await.unwrap();
+    assert_eq!(filters.len(), 1);
+    assert_eq!(filters[0], vec![(50_000 % 256) as u8; 100]);
 
     assert_eq!(storage.load_metadata("test_key").await.unwrap().unwrap(), b"test_value");
 

dash-spv/tests/storage_test.rs

@@ -124,17 +124,29 @@ async fn test_memory_storage_filter_headers() {
 async fn test_memory_storage_filters() {
     let mut storage = MemoryStorageManager::new().await.expect("Failed to create memory storage");
 
-    // Store some test filters
-    let filter_data = vec![1, 2, 3, 4, 5];
-    storage.store_filter(100, &filter_data).await.expect("Failed to store filter");
-
-    // Retrieve filter
-    let retrieved_filter = storage.load_filter(100).await.unwrap();
-    assert!(retrieved_filter.is_some());
-    assert_eq!(retrieved_filter.unwrap(), filter_data);
-
-    // Test non-existent filter
-    assert!(storage.load_filter(999).await.unwrap().is_none());
+    // Store some test filters at consecutive heights
+    let filter_data_0 = vec![1, 2, 3, 4, 5];
+    let filter_data_1 = vec![6, 7, 8, 9, 10];
+    let filter_data_2 = vec![11, 12, 13, 14, 15];
+    storage.store_filter(100, &filter_data_0).await.expect("Failed to store filter");
+    storage.store_filter(101, &filter_data_1).await.expect("Failed to store filter");
+    storage.store_filter(102, &filter_data_2).await.expect("Failed to store filter");
+
+    // Retrieve single filter via range
+    let retrieved_filters = storage.load_filters(100..101).await.unwrap();
+    assert_eq!(retrieved_filters.len(), 1);
+    assert_eq!(retrieved_filters[0], filter_data_0);
+
+    // Retrieve multiple filters
+    let retrieved_filters = storage.load_filters(100..103).await.unwrap();
+    assert_eq!(retrieved_filters.len(), 3);
+    assert_eq!(retrieved_filters[0], filter_data_0);
+    assert_eq!(retrieved_filters[1], filter_data_1);
+    assert_eq!(retrieved_filters[2], filter_data_2);
+
+    // Test non-existent range returns empty vector
+    let empty_filters = storage.load_filters(999..1000).await.unwrap();
+    assert!(empty_filters.is_empty());
 }
 
 #[tokio::test]
@@ -200,7 +212,7 @@ async fn test_memory_storage_clear() {
     // Verify data exists
     assert_eq!(storage.get_tip_height().await.unwrap(), Some(4));
     assert_eq!(storage.get_filter_tip_height().await.unwrap(), Some(2));
-    assert!(storage.load_filter(1).await.unwrap().is_some());
+    assert!(!storage.load_filters(1..2).await.unwrap().is_empty());
     assert!(storage.load_metadata("test").await.unwrap().is_some());
 
     // Clear storage
@@ -209,7 +221,7 @@ async fn test_memory_storage_clear() {
     // Verify everything is cleared
     assert_eq!(storage.get_tip_height().await.unwrap(), None);
     assert_eq!(storage.get_filter_tip_height().await.unwrap(), None);
-    assert!(storage.load_filter(1).await.unwrap().is_none());
+    assert!(storage.load_filters(1..2).await.unwrap().is_empty());
     assert!(storage.load_metadata("test").await.unwrap().is_none());
     assert!(storage.load_headers(0..5).await.unwrap().is_empty());
 }