introduce BlockHeaderStorage.get_tip helper

Introduces `get_tip() -> Option<BlockHeaderTip>` in `BlockHeaderStorage`. This consolidates two-step pattern of `get_tip_height()` followed by `get_header(tip_height)` into a single `get_tip()` call. I didn't adjust any of the other places (except for one) where it's currently possible to be used since they are in the "old" sync code and this PR here is more like a preparation to be used by the sync rewrite.

Author: xdustinface

dash-spv/src/client/core.rs

@@ -184,11 +184,7 @@ 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 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())
+        storage.get_tip().await.map(|tip| *tip.hash())
     }
 
     /// Returns the current chain tip height (absolute), accounting for checkpoint base.

dash-spv/src/storage/blocks.rs

@@ -4,15 +4,41 @@ use std::collections::HashMap;
 use std::ops::Range;
 use std::path::PathBuf;
 
+use crate::error::StorageResult;
+use crate::storage::segments::SegmentCache;
+use crate::storage::PersistentStorage;
+use crate::types::HashedBlockHeader;
 use async_trait::async_trait;
 use dashcore::block::Header as BlockHeader;
+use dashcore::prelude::CoreBlockHeight;
 use dashcore::BlockHash;
 use tokio::sync::RwLock;
 
-use crate::error::StorageResult;
-use crate::storage::segments::SegmentCache;
-use crate::storage::PersistentStorage;
-use crate::types::HashedBlockHeader;
+#[derive(Debug, PartialEq)]
+pub struct BlockHeaderTip {
+    height: CoreBlockHeight,
+    header: BlockHeader,
+    hash: BlockHash,
+}
+
+impl BlockHeaderTip {
+    pub fn new(height: CoreBlockHeight, hashed_block_header: HashedBlockHeader) -> Self {
+        Self {
+            height,
+            header: *hashed_block_header.header(),
+            hash: *hashed_block_header.hash(),
+        }
+    }
+    pub fn height(&self) -> CoreBlockHeight {
+        self.height
+    }
+    pub fn header(&self) -> &BlockHeader {
+        &self.header
+    }
+    pub fn hash(&self) -> &BlockHash {
+        &self.hash
+    }
+}
 
 #[async_trait]
 pub trait BlockHeaderStorage {
@@ -48,6 +74,8 @@ pub trait BlockHeaderStorage {
 
     async fn get_tip_height(&self) -> Option<u32>;
 
+    async fn get_tip(&self) -> Option<BlockHeaderTip>;
+
     async fn get_start_height(&self) -> Option<u32>;
 
     async fn get_stored_headers_len(&self) -> u32;
@@ -146,6 +174,14 @@ impl BlockHeaderStorage for PersistentBlockHeaderStorage {
         self.block_headers.read().await.tip_height()
     }
 
+    async fn get_tip(&self) -> Option<BlockHeaderTip> {
+        let mut block_headers = self.block_headers.write().await;
+        let tip_height = block_headers.tip_height()?;
+        let hashed_header =
+            block_headers.get_items(tip_height..tip_height + 1).await.ok()?.into_iter().next()?;
+        Some(BlockHeaderTip::new(tip_height, hashed_header))
+    }
+
     async fn get_start_height(&self) -> Option<u32> {
         self.block_headers.read().await.start_height()
     }
@@ -175,3 +211,30 @@ impl BlockHeaderStorage for PersistentBlockHeaderStorage {
         Ok(self.header_hash_index.get(hash).copied())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[tokio::test]
+    async fn test_get_tip() {
+        let headers = BlockHeader::dummy_batch(0..5);
+        let tmp_dir = TempDir::new().unwrap();
+        let mut storage = PersistentBlockHeaderStorage::open(tmp_dir.path()).await.unwrap();
+        // Tip should be none before storing headers
+        assert!(storage.get_tip().await.is_none());
+        // Add one header and validate tip
+        storage.store_headers(&headers[0..1]).await.unwrap();
+        let tip = storage.get_tip().await.unwrap();
+        let expected_tip = BlockHeaderTip::new(0, HashedBlockHeader::from(headers[0]));
+        assert_eq!(tip, expected_tip);
+        assert_eq!(storage.get_tip_height().await, Some(0));
+        // Add multiple headers and validate tip
+        storage.store_headers(&headers[1..]).await.unwrap();
+        let tip = storage.get_tip().await.unwrap();
+        let expected_tip = BlockHeaderTip::new(4, HashedBlockHeader::from(headers[4]));
+        assert_eq!(tip, expected_tip);
+        assert_eq!(storage.get_tip_height().await, Some(4));
+    }
+}

dash-spv/src/storage/mod.rs

@@ -24,7 +24,7 @@ use std::time::Duration;
 use tokio::sync::RwLock;
 
 use crate::error::StorageResult;
-use crate::storage::blocks::PersistentBlockHeaderStorage;
+use crate::storage::blocks::{BlockHeaderTip, PersistentBlockHeaderStorage};
 use crate::storage::chainstate::PersistentChainStateStorage;
 use crate::storage::filters::{PersistentFilterHeaderStorage, PersistentFilterStorage};
 use crate::storage::lockfile::LockFile;
@@ -273,6 +273,10 @@ impl blocks::BlockHeaderStorage for DiskStorageManager {
         self.block_headers.read().await.get_tip_height().await
     }
 
+    async fn get_tip(&self) -> Option<BlockHeaderTip> {
+        self.block_headers.read().await.get_tip().await
+    }
+
     async fn get_start_height(&self) -> Option<u32> {
         self.block_headers.read().await.get_start_height().await
     }