feat(dash-spv): startup consistency check and reorg-in-progress sentinel

dash-spv/src/client/lifecycle.rs

@@ -13,8 +13,9 @@ use crate::chain::checkpoints::{mainnet_checkpoints, testnet_checkpoints, Checkp
 use crate::error::{Result, SpvError};
 use crate::network::NetworkManager;
 use crate::storage::{
-    PersistentBlockHeaderStorage, PersistentBlockStorage, PersistentFilterHeaderStorage,
-    PersistentFilterStorage, PersistentMetadataStorage, StorageManager,
+    BlockHeaderStorage, PersistentBlockHeaderStorage, PersistentBlockStorage,
+    PersistentFilterHeaderStorage, PersistentFilterStorage, PersistentMetadataStorage,
+    StorageManager,
 };
 use crate::sync::{
     BlockHeadersManager, BlocksManager, ChainLockManager, FilterHeadersManager, FiltersManager,
@@ -46,6 +47,16 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
         // so they can read the tip from storage during construction.
         Self::initialize_genesis_block(&config, &mut storage).await?;
 
+        // Clamp wallet heights to the (possibly repaired) block-header tip so
+        // a mid-cascade crash recovery cannot leave wallet metadata pointing
+        // above a height the local header chain no longer contains.
+        // Bind the tip into a local so the block-header read guard is dropped
+        // before the wallet write lock is acquired.
+        let tip_after_repair = storage.block_headers().read().await.get_tip_height().await;
+        if let Some(tip) = tip_after_repair {
+            wallet.write().await.clamp_heights_to(tip).await;
+        }
+
         let masternode_engine = {
             if config.enable_masternodes {
                 Some(Arc::new(RwLock::new(MasternodeListEngine::default_for_network(

dash-spv/src/storage/block_headers.rs

@@ -263,6 +263,49 @@ impl BlockHeaderStorage for PersistentBlockHeaderStorage {
     }
 }
 
+impl PersistentBlockHeaderStorage {
+    /// Highest height `h` for which the immediate parent link
+    /// (`header_hash_index[prev_blockhash_of(h)] == h - 1`) is found in the
+    /// index and the header at `h` is present in storage. Walks backward from
+    /// the current tip, returning the first height that satisfies these two
+    /// conditions. Returns `None` when the storage is empty. Mid-chain gaps
+    /// are not detected; callers must not assume that `[start, result]` is
+    /// fully contiguous. Used by the startup consistency check to recover a
+    /// safe tip after a crash mid-cascade.
+    pub(crate) async fn highest_valid_tip(&mut self) -> Option<u32> {
+        let mut headers = self.block_headers.write().await;
+        let tip = headers.tip_height()?;
+        let start = headers.start_height()?;
+
+        let mut height = tip;
+        loop {
+            if height == start {
+                return Some(start);
+            }
+
+            let parent_height = height - 1;
+            let current = headers.get_item(height).await.ok().flatten();
+            let Some(current) = current else {
+                if height == 0 {
+                    return None;
+                }
+                height -= 1;
+                continue;
+            };
+
+            match self.header_hash_index.get(&current.header().prev_blockhash) {
+                Some(&indexed) if indexed == parent_height => return Some(height),
+                _ => {
+                    if height == 0 {
+                        return None;
+                    }
+                    height -= 1;
+                }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;