refactor: remove headers from ChainState (#292)

* removed chain storage an related code

* removed headers from ChainState

* tip_height method removed

* removed get_tip_hesh

* replaced header_at_height

* removed unused methods

* init_from_checkpoint sync

* tip_header removed

* removed two methos that where invovled in the same process

* fixed ffi

* test updated to the changes

* chore: removed fork detector and fork structs (#290)

* get_header now checks out of bound to return None instead of panics

* start height was not being updated properly

* fixed other test by correctly storing the headers in the storage

* removed genesis block creation in ChainState creation

* fixed clippy warnings

* dropped unuseed code

* code review suggestions

Author: ZocoLini

dash-spv-ffi/src/types.rs

@@ -181,7 +181,6 @@ impl From<DetailedSyncProgress> for FFIDetailedSyncProgress {
 
 #[repr(C)]
 pub struct FFIChainState {
-    pub header_height: u32,
     pub masternode_height: u32,
     pub last_chainlock_height: u32,
     pub last_chainlock_hash: FFIString,
@@ -191,7 +190,6 @@ pub struct FFIChainState {
 impl From<ChainState> for FFIChainState {
     fn from(state: ChainState) -> Self {
         FFIChainState {
-            header_height: state.headers.len() as u32,
             masternode_height: state.last_masternode_diff_height.unwrap_or(0),
             last_chainlock_height: state.last_chainlock_height.unwrap_or(0),
             last_chainlock_hash: FFIString::new(

dash-spv-ffi/tests/unit/test_type_conversions.rs

@@ -163,7 +163,6 @@ mod tests {
     #[test]
     fn test_chain_state_none_values() {
         let state = dash_spv::ChainState {
-            headers: vec![],
             last_chainlock_height: None,
             last_chainlock_hash: None,
             current_filter_tip: None,
@@ -173,7 +172,7 @@ mod tests {
         };
 
         let ffi_state = FFIChainState::from(state);
-        assert_eq!(ffi_state.header_height, 0);
+
         assert_eq!(ffi_state.masternode_height, 0);
         assert_eq!(ffi_state.last_chainlock_height, 0);
         assert_eq!(ffi_state.current_filter_tip, 0);

dash-spv/src/chain/chainlock_manager.rs

@@ -175,7 +175,11 @@ impl ChainLockManager {
         }
 
         // Verify the block exists in our chain
-        if let Some(header) = chain_state.header_at_height(chain_lock.block_height) {
+        if let Some(header) = storage
+            .get_header(chain_lock.block_height)
+            .await
+            .map_err(ValidationError::StorageError)?
+        {
             let header_hash = header.block_hash();
             if header_hash != chain_lock.block_hash {
                 return Err(ValidationError::InvalidChainLock(format!(

dash-spv/src/client/core.rs

@@ -184,14 +184,17 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
 
     /// Returns the current chain tip hash if available.
     pub async fn tip_hash(&self) -> Option<dashcore::BlockHash> {
-        let state = self.state.read().await;
-        state.tip_hash()
+        let storage = self.storage.lock().await;
+
+        let tip_height = storage.get_tip_height().await?;
+        let header = storage.get_header(tip_height).await.ok()??;
+
+        Some(header.block_hash())
     }
 
     /// Returns the current chain tip height (absolute), accounting for checkpoint base.
     pub async fn tip_height(&self) -> u32 {
-        let state = self.state.read().await;
-        state.tip_height()
+        self.storage.lock().await.get_tip_height().await.unwrap_or(0)
     }
 
     /// Get current chain state (read-only).

dash-spv/src/client/lifecycle.rs

@@ -163,30 +163,12 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
         // This ensures the ChainState has headers loaded for both checkpoint and normal sync
         let tip_height = {
             let storage = self.storage.lock().await;
-            storage.get_tip_height().await.map_err(SpvError::Storage)?.unwrap_or(0)
+            storage.get_tip_height().await.unwrap_or(0)
         };
         if tip_height > 0 {
             tracing::info!("Found {} headers in storage, loading into sync manager...", tip_height);
-            let loaded_count = {
-                let storage = self.storage.lock().await;
-                self.sync_manager.load_headers_from_storage(&storage).await
-            };
-
-            match loaded_count {
-                Ok(loaded_count) => {
-                    tracing::info!("✅ Sync manager loaded {} headers from storage", loaded_count);
-                }
-                Err(e) => {
-                    tracing::error!("Failed to load headers into sync manager: {}", e);
-                    // For checkpoint sync, this is critical
-                    let state = self.state.read().await;
-                    if state.synced_from_checkpoint() {
-                        return Err(SpvError::Sync(e));
-                    }
-                    // For normal sync, we can continue as headers will be re-synced
-                    tracing::warn!("Continuing without pre-loaded headers for normal sync");
-                }
-            }
+            let storage = self.storage.lock().await;
+            self.sync_manager.load_headers_from_storage(&storage).await
         }
 
         // Connect to network
@@ -203,8 +185,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
             // Get initial header count from storage
             let (header_height, filter_height) = {
                 let storage = self.storage.lock().await;
-                let h_height =
-                    storage.get_tip_height().await.map_err(SpvError::Storage)?.unwrap_or(0);
+                let h_height = storage.get_tip_height().await.unwrap_or(0);
                 let f_height =
                     storage.get_filter_tip_height().await.map_err(SpvError::Storage)?.unwrap_or(0);
                 (h_height, f_height)
@@ -265,7 +246,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
         // Check if we already have any headers in storage
         let current_tip = {
             let storage = self.storage.lock().await;
-            storage.get_tip_height().await.map_err(SpvError::Storage)?
+            storage.get_tip_height().await
         };
 
         if current_tip.is_some() {
@@ -338,12 +319,12 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
 
                         // Clone the chain state for storage
                         let chain_state_for_storage = (*chain_state).clone();
-                        let headers_len = chain_state_for_storage.headers.len() as u32;
                         drop(chain_state);
 
                         // Update storage with chain state including sync_base_height
                         {
                             let mut storage = self.storage.lock().await;
+                            storage.store_headers(&[checkpoint_header]).await?;
                             storage
                                 .store_chain_state(&chain_state_for_storage)
                                 .await
@@ -360,7 +341,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
                         );
 
                         // Update the sync manager's cached flags from the checkpoint-initialized state
-                        self.sync_manager.update_chain_state_cache(checkpoint.height, headers_len);
+                        self.sync_manager.update_chain_state_cache(checkpoint.height);
                         tracing::info!(
                             "Updated sync manager with checkpoint-initialized chain state"
                         );
@@ -408,7 +389,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
         // Verify it was stored correctly
         let stored_height = {
             let storage = self.storage.lock().await;
-            storage.get_tip_height().await.map_err(SpvError::Storage)?
+            storage.get_tip_height().await
         };
         tracing::info!(
             "✅ Genesis block initialized at height 0, storage reports tip height: {:?}",

dash-spv/src/client/progress.rs

@@ -33,7 +33,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
         // Get current heights from storage
         {
             let storage = self.storage.lock().await;
-            if let Ok(Some(header_height)) = storage.get_tip_height().await {
+            if let Some(header_height) = storage.get_tip_height().await {
                 stats.header_height = header_height;
             }
 

dash-spv/src/client/status_display.rs

@@ -74,7 +74,7 @@ impl<'a, S: StorageManager, W: WalletInterface> StatusDisplay<'a, S, W> {
         // For genesis sync: sync_base_height = 0, so height = 0 + storage_count
         // For checkpoint sync: height = checkpoint_height + storage_count
         let storage = self.storage.lock().await;
-        if let Ok(Some(storage_tip)) = storage.get_tip_height().await {
+        if let Some(storage_tip) = storage.get_tip_height().await {
             let blockchain_height = storage_tip;
             if with_logging {
                 tracing::debug!(

dash-spv/src/client/sync_coordinator.rs

@@ -37,7 +37,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
         let result = SyncProgress {
             header_height: {
                 let storage = self.storage.lock().await;
-                storage.get_tip_height().await.map_err(SpvError::Storage)?.unwrap_or(0)
+                storage.get_tip_height().await.unwrap_or(0)
             },
             filter_header_height: {
                 let storage = self.storage.lock().await;
@@ -236,7 +236,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
                     // Storage tip now represents the absolute blockchain height.
                     let current_tip_height = {
                         let storage = self.storage.lock().await;
-                        storage.get_tip_height().await.ok().flatten().unwrap_or(0)
+                        storage.get_tip_height().await.unwrap_or(0)
                     };
                     let current_height = current_tip_height;
                     let peer_best = self
@@ -310,7 +310,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
                 // Emit filter headers progress only when heights change
                 let (abs_header_height, filter_header_height) = {
                     let storage = self.storage.lock().await;
-                    let storage_tip = storage.get_tip_height().await.ok().flatten().unwrap_or(0);
+                    let storage_tip = storage.get_tip_height().await.unwrap_or(0);
                     let filter_tip =
                         storage.get_filter_tip_height().await.ok().flatten().unwrap_or(0);
                     (storage_tip, filter_tip)

dash-spv/src/storage/mod.rs

@@ -81,7 +81,11 @@ pub trait StorageManager: Send + Sync + 'static {
     async fn get_header(&self, height: u32) -> StorageResult<Option<BlockHeader>>;
 
     /// Get the current tip blockchain height.
-    async fn get_tip_height(&self) -> StorageResult<Option<u32>>;
+    async fn get_tip_height(&self) -> Option<u32>;
+
+    async fn get_start_height(&self) -> Option<u32>;
+
+    async fn get_stored_headers_len(&self) -> u32;
 
     /// Store filter headers.
     async fn store_filter_headers(&mut self, headers: &[FilterHeader]) -> StorageResult<()>;

dash-spv/src/storage/segments.rs

@@ -75,6 +75,7 @@ pub struct SegmentCache<I: Persistable> {
     segments: HashMap<u32, Segment<I>>,
     evicted: HashMap<u32, Segment<I>>,
     tip_height: Option<u32>,
+    start_height: Option<u32>,
     base_path: PathBuf,
 }
 
@@ -133,12 +134,14 @@ impl<I: Persistable> SegmentCache<I> {
             segments: HashMap::with_capacity(Self::MAX_ACTIVE_SEGMENTS),
             evicted: HashMap::new(),
             tip_height: None,
+            start_height: None,
             base_path,
         };
 
         // Building the metadata
         if let Ok(entries) = fs::read_dir(&items_dir) {
-            let mut max_segment_id = None;
+            let mut max_seg_id = None;
+            let mut min_seg_id = None;
 
             for entry in entries.flatten() {
                 if let Some(name) = entry.file_name().to_str() {
@@ -149,19 +152,27 @@ impl<I: Persistable> SegmentCache<I> {
                         let segment_id_end = segment_id_start + 4;
 
                         if let Ok(id) = name[segment_id_start..segment_id_end].parse::<u32>() {
-                            max_segment_id =
-                                Some(max_segment_id.map_or(id, |max: u32| max.max(id)));
+                            max_seg_id = Some(max_seg_id.map_or(id, |max: u32| max.max(id)));
+                            min_seg_id = Some(min_seg_id.map_or(id, |min: u32| min.min(id)));
                         }
                     }
                 }
             }
 
-            if let Some(segment_id) = max_segment_id {
+            if let Some(segment_id) = max_seg_id {
                 let segment = cache.get_segment(&segment_id).await?;
 
                 cache.tip_height = segment
                     .last_valid_offset()
-                    .map(|offset| segment_id * Segment::<I>::ITEMS_PER_SEGMENT + offset);
+                    .map(|offset| Self::segment_id_to_start_height(segment_id) + offset);
+            }
+
+            if let Some(segment_id) = min_seg_id {
+                let segment = cache.get_segment(&segment_id).await?;
+
+                cache.start_height = segment
+                    .first_valid_offset()
+                    .map(|offset| Self::segment_id_to_start_height(segment_id) + offset);
             }
         }
 
@@ -349,6 +360,11 @@ impl<I: Persistable> SegmentCache<I> {
             None => Some(height - 1),
         };
 
+        self.start_height = match self.start_height {
+            Some(current) => Some(current.min(start_height)),
+            None => Some(start_height),
+        };
+
         Ok(())
     }
 
@@ -377,6 +393,11 @@ impl<I: Persistable> SegmentCache<I> {
         self.tip_height
     }
 
+    #[inline]
+    pub fn start_height(&self) -> Option<u32> {
+        self.start_height
+    }
+
     #[inline]
     pub fn next_height(&self) -> u32 {
         match self.tip_height() {