diff --git a/dash-spv/src/chain/checkpoints.rs b/dash-spv/src/chain/checkpoints.rs index d06a6bfaf..be94b2663 100644 --- a/dash-spv/src/chain/checkpoints.rs +++ b/dash-spv/src/chain/checkpoints.rs @@ -2,7 +2,9 @@ //! //! Each checkpoint holds its block header and the [`CHECKPOINT_HEADERS`] - 1 headers before //! it, so the difficulty of the blocks after it can be checked from the first one on. The -//! checkpoints of mainnet and testnet are generated from the network by the +//! genesis checkpoint is the exception: it holds only the genesis header and is never +//! encoded, as decoding always reads [`CHECKPOINT_HEADERS`] headers. The checkpoints of +//! mainnet and testnet are generated from the network by the //! `generate-checkpoints` binary into `checkpoints/.json`, which `build.rs` encodes //! for embedding. @@ -11,12 +13,13 @@ use std::io::{Read, Write}; use std::sync::LazyLock; use dashcore::block::Header; +use dashcore::blockdata::constants::genesis_block; use dashcore::consensus::{encode, Decodable, Encodable}; use dashcore::{BlockHash, Network}; use crate::types::HashedBlockHeader; -/// Headers each checkpoint holds, the checkpoint block last. +/// Headers each checkpoint but genesis holds, the checkpoint block last. pub const CHECKPOINT_HEADERS: usize = 25; const MAINNET_CHECKPOINTS: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/mainnet.checkpoints")); @@ -37,7 +40,7 @@ static NO_CHECKPOINTS: CheckpointManager = CheckpointManager { checkpoints: BTreeMap::new(), }; -/// A known block and the [`CHECKPOINT_HEADERS`] - 1 headers before it. +/// A known block and the [`CHECKPOINT_HEADERS`] - 1 headers before it, or the genesis block alone. #[derive(Debug, Clone)] pub struct Checkpoint { height: u32, @@ -58,6 +61,14 @@ impl Checkpoint { }) } + /// The genesis block of `network`, alone. + pub(crate) fn genesis(network: Network) -> Self { + Self { + height: 0, + headers: vec![genesis_block(network).header.into()], + } + } + /// Height of the checkpoint block. pub fn height(&self) -> u32 { self.height @@ -70,7 +81,7 @@ impl Checkpoint { /// Header of the checkpoint block. pub fn header(&self) -> &HashedBlockHeader { - &self.headers[CHECKPOINT_HEADERS - 1] + self.headers.last().expect("a checkpoint holds headers") } /// All the headers of the checkpoint, oldest first, from [`Self::start_height`]. @@ -80,7 +91,7 @@ impl Checkpoint { /// Height of the first of [`Self::headers`]. pub fn start_height(&self) -> u32 { - self.height - (CHECKPOINT_HEADERS as u32 - 1) + self.height + 1 - self.headers.len() as u32 } } @@ -131,7 +142,7 @@ impl CheckpointManager { } } - fn new(checkpoints: Vec) -> Self { + pub(crate) fn new(checkpoints: Vec) -> Self { Self { checkpoints: checkpoints .into_iter() diff --git a/dash-spv/src/client/lifecycle.rs b/dash-spv/src/client/lifecycle.rs index 0660967f7..50abaf180 100644 --- a/dash-spv/src/client/lifecycle.rs +++ b/dash-spv/src/client/lifecycle.rs @@ -142,6 +142,9 @@ impl DashSpvClient { storage.block_headers(), storage.filter_headers(), storage.filters(), + config + .start_from_height + .unwrap_or_else(|| config.network.hd_wallet_sync_floor()), ) .await, ); diff --git a/dash-spv/src/sync/block_headers/manager.rs b/dash-spv/src/sync/block_headers/manager.rs index 17a22408c..7be284423 100644 --- a/dash-spv/src/sync/block_headers/manager.rs +++ b/dash-spv/src/sync/block_headers/manager.rs @@ -11,7 +11,7 @@ use std::net::SocketAddr; use std::sync::Arc; use std::time::Instant; -use crate::chain::CheckpointManager; +use crate::chain::{Checkpoint, CheckpointManager}; use crate::error::{SyncError, SyncResult}; use crate::network::{NetworkManager, RequestKey}; use crate::storage::{BlockHeaderStorage, BlockHeaderTip, MetadataStorage}; @@ -53,6 +53,8 @@ pub struct BlockHeadersManager { pub(super) announced_peers: HashSet, /// Network whose difficulty rules new headers are checked against. network: Network, + /// Lowest height a wallet needs, which [`Self::extend_down`] syncs down to. + pub(super) floor: Option, } impl std::fmt::Debug for BlockHeadersManager { @@ -99,6 +101,7 @@ impl BlockHeadersManager { pending_announcements: HashMap::new(), announced_peers: HashSet::new(), network, + floor: None, }) } @@ -111,6 +114,93 @@ impl BlockHeadersManager { .ok_or_else(|| SyncError::MissingDependency("storage not initialized".to_string())) } + /// Sync the headers below the lowest stored one, down to [`Self::floor`]. + /// + /// Splits the range at the checkpoints below the lowest stored header, down to the + /// one that reaches the floor or genesis, and downloads the segments in parallel. + /// It waits until the pipeline runs. + pub(super) async fn extend_down(&mut self) -> SyncResult<()> { + if self.pipeline.is_syncing_below() || !self.pipeline.is_initialized() { + return Ok(()); + } + let Some(floor) = self.floor else { + return Ok(()); + }; + let storage = self.header_storage.read().await; + let Some(start) = storage.get_start_height().await.filter(|start| floor < *start) else { + self.floor = None; + self.progress.update_missing_below(0); + return Ok(()); + }; + self.progress.update_missing_below(start - floor); + let mut join = storage + .get_header(start) + .await? + .ok_or_else(|| SyncError::MissingDependency(format!("no header at {start}")))? + .header() + .prev_blockhash; + drop(storage); + + let mut end = start; + loop { + let anchor = self.anchor_below(end); + self.pipeline.sync_below(anchor.height(), *anchor.hash(), end - 1, join); + if anchor.start_height() <= floor { + tracing::info!( + "Syncing headers {}..{} below the stored ones", + anchor.height() + 1, + start + ); + return Ok(()); + } + end = anchor.start_height(); + join = anchor.headers().first().map(|first| first.header().prev_blockhash).ok_or_else( + || { + SyncError::InvalidState(format!( + "checkpoint {} has no headers", + anchor.height() + )) + }, + )?; + } + } + + /// The checkpoint below `start`, or genesis. + fn anchor_below(&self, start: u32) -> Checkpoint { + self.checkpoint_manager + .last_checkpoint_before_height(start - 1) + .cloned() + .unwrap_or_else(|| Checkpoint::genesis(self.network)) + } + + /// Store the anchor below `start` and the `downloaded` headers joining it to `start`. + async fn store_below( + &mut self, + start: u32, + downloaded: &[HashedBlockHeader], + ) -> SyncResult<()> { + let anchor = self.anchor_below(start); + if !downloaded.is_empty() { + let ancestors = anchor.headers().iter().map(|header| *header.header()).collect(); + BlockHeaderValidator::new(self.network, ancestors, anchor.height()) + .validate(downloaded)?; + } + let mut headers = anchor.headers().to_vec(); + headers.extend_from_slice(downloaded); + let mut storage = self.header_storage.write().await; + let joins = storage.get_header(start).await?.map(|header| header.header().prev_blockhash) + == headers.last().map(|last| *last.hash()); + if !joins { + return Err(SyncError::Validation(format!("headers below {start} do not join it"))); + } + storage.store_headers_at_height(&headers, anchor.start_height()).await?; + if let Some(floor) = self.floor { + self.progress.update_missing_below(anchor.start_height().saturating_sub(floor)); + } + tracing::info!("Headers synced down to {}", anchor.start_height()); + Ok(()) + } + /// The stored headers up to `height` the next one's difficulty is computed from. async fn ancestors(&self, height: u32) -> SyncResult> { let storage = self.header_storage.read().await; @@ -227,6 +317,7 @@ impl BlockHeadersManager { } events.extend(self.store_ready_batches(ready_batches).await?); + self.pipeline.send_below(network).await; // After storing unsolicited post-sync headers, mark the tip complete so the next header goes through // the clean reset path. Don't mark complete during active catch-up. @@ -341,9 +432,31 @@ impl BlockHeadersManager { } } + // Last, and without failing, as the batches above already left the pipeline + // and their events would otherwise be dropped. + if let Err(e) = self.store_completed_below().await { + tracing::warn!("Failed to store the headers synced below: {}", e); + } + Ok(events) } + /// Store the segments below that finished downloading, from the highest down. + pub(super) async fn store_completed_below(&mut self) -> SyncResult<()> { + while let Some(below) = self.pipeline.take_below() { + let start = self.header_storage.read().await.get_start_height().await; + let start = start.ok_or_else(|| { + SyncError::MissingDependency("no headers stored to sync below".to_string()) + })?; + if let Err(e) = self.store_below(start, &below).await { + // `extend_down` starts the segments again only once none is left. + self.pipeline.clear_below(); + return Err(e); + } + } + Ok(()) + } + /// Close out an initial sync whose pipeline has nothing left to download. /// /// Extracted alongside [`Self::store_ready_batches`] and for the same @@ -679,6 +792,97 @@ mod tests { ); } + /// Headers below the stored ones that fail to store must not take the + /// forward batches stored alongside them down too, nor their events: those + /// already left the pipeline, so nothing would download them again. + #[tokio::test] + async fn test_failed_store_below_keeps_forward_batches() { + let storage = DiskStorageManager::with_temp_dir().await.unwrap(); + let stored: Vec = Header::dummy_chain(3, BlockHash::dummy(1)) + .iter() + .map(HashedBlockHeader::from) + .collect(); + storage.block_headers().write().await.store_headers_at_height(&stored, 10).await.unwrap(); + let mut manager = BlockHeadersManager::new( + storage.block_headers(), + storage.metadata(), + create_test_checkpoint_manager(), + Network::Regtest, + ) + .await + .unwrap(); + let tip = manager.tip().await.unwrap(); + manager.pipeline.init(tip.height(), *tip.hash(), tip.height() + 2); + + // Headers below that join neither the anchor nor the stored ones. + let below: Vec = Header::dummy_chain(1, BlockHash::dummy(2)) + .iter() + .map(HashedBlockHeader::from) + .collect(); + manager.pipeline.sync_below(0, BlockHash::dummy(2), 1, *below[0].hash()); + manager.pipeline.receive_headers(&below).unwrap(); + + let forward: Vec = + Header::dummy_chain(2, *tip.hash()).iter().map(HashedBlockHeader::from).collect(); + manager.pipeline.receive_headers(&forward).unwrap(); + let ready = manager.pipeline.take_ready_to_store(); + assert!(!ready.is_empty(), "precondition: the forward batch is ready"); + + let events = manager.store_ready_batches(ready).await.unwrap(); + + let stored_tip = tip.height() + 2; + assert!(matches!( + events.as_slice(), + [SyncEvent::BlockHeadersStored { tip_height }] if *tip_height == stored_tip + )); + + assert!(!manager.pipeline.is_syncing_below()); + assert_eq!(manager.tip().await.unwrap().height(), tip.height() + 2); + } + + /// Syncs every checkpoint segment down to the floor at once: one adjacent to its + /// checkpoint needs no download, a distant one does, and it stops at the floor, not genesis. + #[tokio::test] + async fn test_extend_down_descends_checkpoints_to_the_floor() { + let chain: Vec = Header::dummy_chain(130, BlockHash::dummy(1)) + .iter() + .map(HashedBlockHeader::from) + .collect(); + + let storage = DiskStorageManager::with_temp_dir().await.unwrap(); + let headers = storage.block_headers(); + headers.write().await.store_headers_at_height(&chain[100..], 100).await.unwrap(); + let mut manager = BlockHeadersManager::new( + headers.clone(), + storage.metadata(), + Box::leak(Box::new(CheckpointManager::dummy(&chain))), + Network::Regtest, + ) + .await + .unwrap(); + manager.pipeline.init(129, *chain[129].hash(), 129); + manager.floor = Some(30); + + manager.extend_down().await.unwrap(); + manager.store_completed_below().await.unwrap(); + assert!(manager.pipeline.is_syncing_below()); + assert_eq!(headers.read().await.get_start_height().await, Some(75)); + + manager.pipeline.receive_headers(&chain[50..75]).unwrap(); + manager.store_completed_below().await.unwrap(); + assert!(!manager.pipeline.is_syncing_below()); + assert_eq!(headers.read().await.get_start_height().await, Some(25)); + + manager.extend_down().await.unwrap(); + assert_eq!(manager.floor, None); + assert!(!manager.pipeline.is_syncing_below()); + assert_eq!(headers.read().await.get_start_height().await, Some(25)); + for height in 25..=129u32 { + let stored = headers.read().await.get_header(height).await.unwrap(); + assert_eq!(stored.map(|header| *header.hash()), Some(*chain[height as usize].hash())); + } + } + #[tokio::test] async fn test_block_headers_manager_new() { let manager = create_test_manager().await; diff --git a/dash-spv/src/sync/block_headers/pipeline.rs b/dash-spv/src/sync/block_headers/pipeline.rs index 6b7c00118..e7241f5f3 100644 --- a/dash-spv/src/sync/block_headers/pipeline.rs +++ b/dash-spv/src/sync/block_headers/pipeline.rs @@ -32,6 +32,9 @@ pub struct HeadersPipeline { checkpoint_manager: &'static CheckpointManager, /// Whether the pipeline has been initialized. initialized: bool, + /// Segments syncing below the stored headers, highest first, each stored whole + /// once it and the ones above it are. + below: Vec, } impl std::fmt::Debug for HeadersPipeline { @@ -52,6 +55,7 @@ impl HeadersPipeline { next_to_store: 0, checkpoint_manager, initialized: false, + below: Vec::new(), } } @@ -60,6 +64,7 @@ impl HeadersPipeline { self.segments.clear(); self.next_to_store = 0; self.initialized = true; + self.below.clear(); // Find checkpoints between current_height and target_height let mut boundaries: Vec<(u32, BlockHash)> = Vec::new(); @@ -111,6 +116,53 @@ impl HeadersPipeline { ); } + /// Download `(start_height, end_height]` below the stored headers and the segments + /// already added, the block at `end_height` being `end_hash`. + pub(super) fn sync_below( + &mut self, + start_height: u32, + start_hash: BlockHash, + end_height: u32, + end_hash: BlockHash, + ) { + let mut segment = SegmentState::new( + self.segments.len() + self.below.len(), + start_height, + start_hash, + Some(end_height), + Some(end_hash), + ); + segment.complete = start_height == end_height; + self.below.push(segment); + } + + /// Whether a [`Self::sync_below`] segment is still to be stored. + pub(super) fn is_syncing_below(&self) -> bool { + !self.below.is_empty() + } + + /// Headers of the highest [`Self::sync_below`] segment, once complete. + pub(super) fn take_below(&mut self) -> Option> { + if !self.below.first()?.complete { + return None; + } + Some(self.below.remove(0).buffered_headers) + } + + /// Drop the [`Self::sync_below`] segments, to sync below again from scratch. + pub(super) fn clear_below(&mut self) { + self.below.clear(); + } + + /// Declare the `getheaders` of the highest [`Self::sync_below`] segments still downloading. + pub(super) async fn send_below(&mut self, network: &Arc) { + for below in + self.below.iter_mut().take(ACTIVE_SEGMENT_WINDOW).filter(|below| below.can_send()) + { + below.send_request(network).await; + } + } + /// Get the number of segments in the pipeline. pub fn segment_count(&self) -> usize { self.segments.len() @@ -157,6 +209,13 @@ impl HeadersPipeline { let prev_hash = headers[0].header().prev_blockhash; + if let Some(below) = + self.below.iter_mut().find(|below| !below.complete && below.matches(&prev_hash)) + { + below.receive_headers(headers)?; + return Ok(Some(below.segment_id)); + } + // Find the segment that matches for (idx, segment) in self.segments.iter_mut().enumerate() { if segment.matches(&prev_hash) { @@ -266,14 +325,15 @@ impl HeadersPipeline { ready } - /// Check if all segments are complete. + /// Whether all segments above the stored headers are complete. The segments below + /// do not count, so syncing below never holds back the sync to the tip. pub fn is_complete(&self) -> bool { self.segments.iter().all(|s| s.complete && s.buffered_headers.is_empty()) } /// Get the total number of buffered headers across all segments. pub fn total_buffered(&self) -> u32 { - self.segments.iter().map(|s| s.buffered_headers.len() as u32).sum() + self.segments.iter().chain(&self.below).map(|s| s.buffered_headers.len() as u32).sum() } /// Locator of the non-complete tip segment, used to key an empty `headers` response. @@ -312,7 +372,7 @@ impl HeadersPipeline { /// Treats every segment's next request as new, for a sync that starts again after /// losing its peers, when queued requests may have been dropped. pub(super) fn forget_declared(&mut self) { - for segment in &mut self.segments { + for segment in self.segments.iter_mut().chain(&mut self.below) { segment.forget_declared(); } } diff --git a/dash-spv/src/sync/block_headers/progress.rs b/dash-spv/src/sync/block_headers/progress.rs index 3a068d1c1..709834f37 100644 --- a/dash-spv/src/sync/block_headers/progress.rs +++ b/dash-spv/src/sync/block_headers/progress.rs @@ -14,6 +14,8 @@ pub struct BlockHeadersProgress { target_height: u32, /// Number of block-headers processed (stored) in the current sync session. processed: u32, + /// Number of heights below the stored ones still to sync. + missing_below: u32, /// Number of headers currently buffered in the pipeline (waiting to be stored). buffered: u32, /// The last time a block-header was stored to disk or the last manager state change. @@ -27,6 +29,7 @@ impl Default for BlockHeadersProgress { tip_height: 0, target_height: 0, processed: 0, + missing_below: 0, buffered: 0, last_activity: Instant::now(), } @@ -83,6 +86,10 @@ impl BlockHeadersProgress { pub fn update_buffered(&mut self, count: u32) { self.buffered = count; } + /// Update the number of heights below the stored ones still to sync. + pub fn update_missing_below(&mut self, count: u32) { + self.missing_below = count; + } /// Bump the last activity time. pub fn bump_last_activity(&mut self) { self.last_activity = Instant::now(); @@ -107,6 +114,9 @@ impl fmt::Display for BlockHeadersProgress { } impl ProgressPercentage for BlockHeadersProgress { + fn missing_below(&self) -> u32 { + self.missing_below + } fn target_height(&self) -> u32 { self.target_height } diff --git a/dash-spv/src/sync/block_headers/sync_manager.rs b/dash-spv/src/sync/block_headers/sync_manager.rs index 013fbd274..8efb16ab7 100644 --- a/dash-spv/src/sync/block_headers/sync_manager.rs +++ b/dash-spv/src/sync/block_headers/sync_manager.rs @@ -131,17 +131,26 @@ impl SyncManager for BlockHeadersMana async fn handle_sync_event( &mut self, - _event: &SyncEvent, + event: &SyncEvent, _network: &Arc, ) -> SyncResult> { - // BlockHeadersManager doesn't react to events from other managers + if let SyncEvent::HeadersBackfillNeeded { + height, + } = event + { + self.floor = Some(*height); + self.extend_down().await?; + } Ok(vec![]) } async fn tick(&mut self, network: &Arc) -> SyncResult> { + self.extend_down().await?; if !self.pipeline.is_initialized() { return Ok(vec![]); } + self.store_completed_below().await?; + self.pipeline.send_below(network).await; if self.state() == SyncState::Syncing { // Take, refill, then store — the same order `handle_headers_pipeline` diff --git a/dash-spv/src/sync/events.rs b/dash-spv/src/sync/events.rs index 9b6d91787..695042093 100644 --- a/dash-spv/src/sync/events.rs +++ b/dash-spv/src/sync/events.rs @@ -187,6 +187,16 @@ pub enum SyncEvent { fork_height: u32, }, + /// A wallet needs blocks below the lowest stored header. + /// + /// Emitted by: `FiltersManager` + /// Consumed by: `BlockHeadersManager`, which fills them in from the + /// checkpoint at or below `height` + HeadersBackfillNeeded { + /// Lowest height a wallet needs + height: u32, + }, + /// Sync has reached the chain tip (all managers idle). /// /// Emitted on every not-synced to synced transition. Cycle 0 is the @@ -287,6 +297,9 @@ impl fmt::Display for SyncEvent { SyncEvent::ForkDetected { fork_height, } => write!(f, "ForkDetected(height={})", fork_height), + SyncEvent::HeadersBackfillNeeded { + height, + } => write!(f, "HeadersBackfillNeeded(height={})", height), SyncEvent::SyncComplete { header_tip, cycle, diff --git a/dash-spv/src/sync/filter_headers/manager.rs b/dash-spv/src/sync/filter_headers/manager.rs index 302d17859..229f7da03 100644 --- a/dash-spv/src/sync/filter_headers/manager.rs +++ b/dash-spv/src/sync/filter_headers/manager.rs @@ -59,6 +59,7 @@ impl FilterHeadersManager /// `Synced` or conditions are not met. pub(super) fn try_complete_sync(&mut self) -> Option { if self.block_headers_synced + && self.progress.missing_below() == 0 && self.progress.current_height() >= self.progress.target_height() { if self.state() == SyncState::Synced { @@ -184,6 +185,90 @@ impl FilterHeadersManager Ok(count) } + /// Queue the batches below the lowest stored filter header while block headers + /// reach below it, which the pipeline downloads in parallel. + pub(super) async fn extend_down(&mut self) -> SyncResult<()> { + let header_storage = self.header_storage.read().await; + let header_start = header_storage.get_start_height().await; + let filter_start = self.filter_header_storage.read().await.get_filter_start_height().await; + // A chain anchored at a checkpoint holds the filter header below it too. + let (Some(header_start), Some(end)) = (header_start, filter_start) else { + return Ok(()); + }; + self.progress.update_missing_below(end.saturating_sub(header_start.saturating_sub(1))); + if end <= header_start.saturating_sub(1) { + return Ok(()); + } + self.pipeline.extend_below(&*header_storage, end, header_start).await?; + drop(header_storage); + + if self.state() == SyncState::Synced { + self.set_state(SyncState::Syncing); + } + Ok(()) + } + + /// Store the received batches below, from the one ending at the lowest stored + /// filter header down. A batch that does not match the header it ends at is + /// requested again. + pub(super) async fn store_lower_batches(&mut self) -> SyncResult> { + let mut events = Vec::new(); + loop { + let Some(end) = self.filter_header_storage.read().await.get_filter_start_height().await + else { + break; + }; + let Some((start, cfheaders)) = self.pipeline.take_below(end) else { + break; + }; + let Some(stored) = self.store_lower_batch(start, end, &cfheaders).await? else { + self.pipeline.want_below(cfheaders.stop_hash, start, end); + break; + }; + events.push(stored); + } + if events.is_empty() { + return Ok(events); + } + let header_start = self.header_storage.read().await.get_start_height().await.unwrap_or(0); + let filter_start = + self.filter_header_storage.read().await.get_filter_start_height().await.unwrap_or(0); + self.progress + .update_missing_below(filter_start.saturating_sub(header_start.saturating_sub(1))); + events.extend(self.try_complete_sync()); + Ok(events) + } + + /// Store the batch `start..=end` below, if it ends at the stored filter header at `end`. + pub(super) async fn store_lower_batch( + &mut self, + start: u32, + end: u32, + cfheaders: &CFHeaders, + ) -> SyncResult> { + let mut headers = compute_filter_headers(cfheaders); + let mut storage = self.filter_header_storage.write().await; + if start + headers.len() as u32 != end + 1 + || headers.pop() != storage.get_filter_header(end).await? + { + tracing::warn!( + "CFHeaders batch at {} does not end at the stored filter headers", + start + ); + return Ok(None); + } + if start > 0 { + headers.insert(0, cfheaders.previous_filter_header); + } + let first = start.saturating_sub(1); + storage.store_filter_headers_at_height(&headers, first).await?; + Ok(Some(SyncEvent::FilterHeadersStored { + start_height: first, + end_height: end - 1, + tip_height: self.progress.current_height(), + })) + } + /// Start or resume filter header download. async fn start_download( &mut self, @@ -315,6 +400,7 @@ mod tests { use dashcore::network::message::NetworkMessage; use dashcore::{block::Version, BlockHash, CompactTarget, Header as BlockHeader}; use dashcore_hashes::sha256d; + use test_case::test_case; type TestFilterHeadersManager = FilterHeadersManager; @@ -649,6 +735,43 @@ mod tests { storage.filter_headers().read().await.get_filter_tip_height().await.unwrap() } + /// A batch below the stored filter headers that doesn't end at them stores nothing. + #[test_case(0, b"prev" ; "empty")] + #[test_case(1999, b"prev" ; "wrong end")] + #[test_case(2000, b"other" ; "last header mismatch")] + #[tokio::test] + async fn test_lower_batch_not_ending_at_stored_filter_headers_is_rejected( + count: u32, + previous: &[u8], + ) { + let storage = DiskStorageManager::with_temp_dir().await.unwrap(); + let hashes = store_block_headers(&storage, 0, 2001).await; + let stop_hash = hashes[2000]; + let stored = compute_filter_headers(&cfheaders( + FilterHeader::from_raw_hash(sha256d::Hash::hash(b"prev")), + stop_hash, + 2000, + )); + let filter_headers = storage.filter_headers(); + filter_headers + .write() + .await + .store_filter_headers_at_height(&stored[1999..], 2000) + .await + .unwrap(); + let mut manager = + FilterHeadersManager::new(storage.block_headers(), filter_headers.clone()) + .await + .unwrap(); + + let batch = + cfheaders(FilterHeader::from_raw_hash(sha256d::Hash::hash(previous)), stop_hash, count); + let stored = manager.store_lower_batch(1, 2000, &batch).await.unwrap(); + + assert!(stored.is_none()); + assert_eq!(filter_headers.read().await.get_filter_start_height().await, Some(2000)); + } + #[tokio::test] async fn test_cfheaders_batch_not_connecting_to_stored_header_is_requeued() { let storage = DiskStorageManager::with_temp_dir().await.unwrap(); diff --git a/dash-spv/src/sync/filter_headers/pipeline.rs b/dash-spv/src/sync/filter_headers/pipeline.rs index 01204f856..be3162ffa 100644 --- a/dash-spv/src/sync/filter_headers/pipeline.rs +++ b/dash-spv/src/sync/filter_headers/pipeline.rs @@ -13,7 +13,7 @@ use crate::network::{NetworkManager, SendRequest}; use crate::storage::BlockHeaderStorage; /// Batch size for filter header requests. -const FILTER_HEADERS_BATCH_SIZE: u32 = 2000; +pub(super) const FILTER_HEADERS_BATCH_SIZE: u32 = 2000; /// Pipeline for downloading compact block filter headers. #[derive(Debug)] @@ -28,6 +28,13 @@ pub(super) struct FilterHeadersPipeline { next_expected: u32, /// Target height for sync. target_height: u32, + /// Wanted batches below the stored filter headers (stop_hash -> (start_height, end_height)). + below_batches: HashMap, + /// Received batches below (end_height -> (start_height, data)), kept until the stored + /// filter headers reach down to their end. + below_buffered: HashMap, + /// End height of the next batch to queue below. + below_end: Option, } impl Default for FilterHeadersPipeline { @@ -45,9 +52,54 @@ impl FilterHeadersPipeline { buffered: HashMap::new(), next_expected: 0, target_height: 0, + below_batches: HashMap::new(), + below_buffered: HashMap::new(), + below_end: None, } } + /// Queue the batches below the stored filter headers, from the one ending at `top`, + /// or below the ones queued already, down to the one starting at `lowest`. + pub(super) async fn extend_below( + &mut self, + storage: &impl BlockHeaderStorage, + top: u32, + lowest: u32, + ) -> SyncResult<()> { + let mut end = self.below_end.unwrap_or(top); + while end > lowest.saturating_sub(1) { + let start = lowest.max(end.saturating_sub(FILTER_HEADERS_BATCH_SIZE - 1)); + let stop_hash = + storage.get_header(end).await?.map(|h| *h.hash()).ok_or_else(|| { + SyncError::Storage(format!("Missing header at height {}", end)) + })?; + self.want_below(stop_hash, start, end); + end = start.saturating_sub(1); + } + self.below_end = Some(end); + Ok(()) + } + + /// Buffer `data` if it answers a wanted batch below. Returns whether it does. + pub(super) fn receive_below(&mut self, data: &CFHeaders) -> bool { + let Some((start, end)) = self.below_batches.remove(&data.stop_hash) else { + return false; + }; + self.below_buffered.insert(end, (start, data.clone())); + true + } + + /// Start height and data of the received batch below that ends at `end`. + pub(super) fn take_below(&mut self, end: u32) -> Option<(u32, CFHeaders)> { + self.below_buffered.remove(&end) + } + + /// Want the batch `start..=end` below the stored filter headers, whose block at `end` is `stop_hash`. + pub(super) fn want_below(&mut self, stop_hash: BlockHash, start: u32, end: u32) { + self.below_batches.insert(stop_hash, (start, end)); + self.undeclared = true; + } + /// Extend the pipeline to a new target height. /// /// Queues additional batches from the current target to the new target. @@ -150,13 +202,16 @@ impl FilterHeadersPipeline { &mut self, network: &Arc, ) -> SyncResult { - if self.batch_starts.is_empty() { + let batches: Vec<(BlockHash, u32)> = self + .batch_starts + .iter() + .map(|(stop_hash, start)| (*stop_hash, *start)) + .chain(self.below_batches.iter().map(|(stop_hash, (start, _))| (*stop_hash, *start))) + .collect(); + if batches.is_empty() { return Ok(0); } - let batches: Vec<(BlockHash, u32)> = - self.batch_starts.iter().map(|(stop_hash, start)| (*stop_hash, *start)).collect(); - for (stop_hash, start_height) in &batches { network .send(GetCFHeaders { diff --git a/dash-spv/src/sync/filter_headers/progress.rs b/dash-spv/src/sync/filter_headers/progress.rs index 1ec82679d..6f1717643 100644 --- a/dash-spv/src/sync/filter_headers/progress.rs +++ b/dash-spv/src/sync/filter_headers/progress.rs @@ -16,6 +16,8 @@ pub struct FilterHeadersProgress { block_header_tip_height: u32, /// Number of filter-headers processed (stored) in the current sync session. processed: u32, + /// Number of heights below the stored ones still to sync. + missing_below: u32, /// The last time a filter-header was stored to disk or the last manager state change. last_activity: Instant, } @@ -28,6 +30,7 @@ impl Default for FilterHeadersProgress { target_height: 0, block_header_tip_height: 0, processed: 0, + missing_below: 0, last_activity: Instant::now(), } } @@ -86,6 +89,10 @@ impl FilterHeadersProgress { self.bump_last_activity(); } + /// Update the number of heights below the stored ones still to sync. + pub fn update_missing_below(&mut self, count: u32) { + self.missing_below = count; + } /// Bump the last activity time. pub fn bump_last_activity(&mut self) { self.last_activity = Instant::now(); @@ -109,6 +116,9 @@ impl fmt::Display for FilterHeadersProgress { } impl ProgressPercentage for FilterHeadersProgress { + fn missing_below(&self) -> u32 { + self.missing_below + } fn target_height(&self) -> u32 { self.target_height } diff --git a/dash-spv/src/sync/filter_headers/sync_manager.rs b/dash-spv/src/sync/filter_headers/sync_manager.rs index 73d6c1b5c..aaa12346c 100644 --- a/dash-spv/src/sync/filter_headers/sync_manager.rs +++ b/dash-spv/src/sync/filter_headers/sync_manager.rs @@ -8,6 +8,7 @@ use crate::sync::{ }; use crate::SyncError; use async_trait::async_trait; +use dashcore::network::message::NetworkMessage; use std::net::SocketAddr; use std::sync::Arc; @@ -45,6 +46,13 @@ impl SyncManager for FilterHeade msg: InboundMessage, network: &Arc, ) -> SyncResult> { + if let NetworkMessage::CFHeaders(cfheaders) = &*msg { + if self.pipeline.receive_below(cfheaders) { + network.release_request(RequestKey::CfHeaders(cfheaders.stop_hash)).await; + return self.store_lower_batches().await; + } + } + // Match response to get start height let Some((start_height, cfheaders)) = self.pipeline.match_response(&msg) else { if self.pipeline.is_complete() { @@ -141,6 +149,7 @@ impl SyncManager for FilterHeade } async fn tick(&mut self, network: &Arc) -> SyncResult> { + self.extend_down().await?; self.pipeline.send_pending(network).await?; // Re-read the block-header tip and extend from here if it moved. diff --git a/dash-spv/src/sync/filters/coinjoin_gap_discovery_tests.rs b/dash-spv/src/sync/filters/coinjoin_gap_discovery_tests.rs index dcd701234..ecb7ba3c4 100644 --- a/dash-spv/src/sync/filters/coinjoin_gap_discovery_tests.rs +++ b/dash-spv/src/sync/filters/coinjoin_gap_discovery_tests.rs @@ -96,6 +96,7 @@ async fn setup() -> (CjFiltersManager, Arc @@ -193,6 +196,7 @@ impl>, filter_header_storage: Arc>, filter_storage: Arc>, + sync_floor: u32, ) -> Self { let committed_height = wallet.read().await.synced_height(); let checks_derived_addresses = wallet.read().await.checks_derived_addresses(); @@ -227,6 +231,7 @@ impl 0 { @@ -383,6 +397,14 @@ impl download_start.saturating_sub(1)) { + self.set_state(SyncState::WaitForEvents); + return Ok(vec![]); + } + // Anchor the scan and store frontiers even when we return early below. // A wallet that boots already synced takes the early return, and a // later new block would otherwise create a lookahead batch from a @@ -1363,6 +1385,7 @@ mod tests { storage.block_headers(), storage.filter_headers(), storage.filters(), + 0, ) .await } @@ -1376,6 +1399,7 @@ mod tests { storage.block_headers(), storage.filter_headers(), storage.filters(), + 0, ) .await } @@ -1423,17 +1447,17 @@ mod tests { } } - // Non-zero, since the segment store reads an all-zero filter header - // back as an empty slot. - let prev_filter_header = FilterHeader::from_byte_array([1u8; 32]); + // From the one below the anchor, as a checkpoint sync stores them. Non-zero, + // since the segment store reads an all-zero filter header back as an empty slot. + let mut filter_headers = vec![FilterHeader::from_byte_array([1u8; 32])]; + for _ in anchor..=anchor + span { + filter_headers.push(filter.filter_header(filter_headers.last().unwrap())); + } manager .filter_header_storage .write() .await - .store_filter_headers_at_height( - &[prev_filter_header, filter.filter_header(&prev_filter_header)], - anchor + span, - ) + .store_filter_headers_at_height(&filter_headers, anchor - 1) .await .unwrap(); } @@ -1460,7 +1484,9 @@ mod tests { /// Headers and filters both cover `anchor..=anchor + span`. Filter headers /// are stored so `handle_new_filter_headers` can drive a real download. async fn create_anchored_test_manager(anchor: u32, span: u32) -> TestFiltersManager { - let manager = create_test_manager().await; + let mut manager = create_test_manager().await; + // Floored at the anchor, so a wallet below it needs no backfill. + manager.sync_floor = anchor; seed_anchored_storage(&manager, anchor, span).await; manager } @@ -1586,6 +1612,7 @@ mod tests { storage.block_headers(), storage.filter_headers(), storage.filters(), + 0, ) .await; @@ -2604,6 +2631,7 @@ mod tests { storage.block_headers(), storage.filter_headers(), storage.filters(), + 0, ) .await; filters_manager.set_state(SyncState::Syncing); @@ -4209,6 +4237,7 @@ mod tests { ); let mut manager = create_multi_test_manager(multi.clone()).await; + manager.sync_floor = 200_000; seed_anchored_storage(&manager, 200_000, 10).await; let requests: Arc = Arc::new(MockNetworkManager::new()); diff --git a/dash-spv/src/sync/progress.rs b/dash-spv/src/sync/progress.rs index 17f4e3035..160b58408 100644 --- a/dash-spv/src/sync/progress.rs +++ b/dash-spv/src/sync/progress.rs @@ -261,11 +261,16 @@ pub trait ProgressPercentage { fn target_height(&self) -> CoreBlockHeight; /// Get the current height used for calculating progress. fn current_height(&self) -> CoreBlockHeight; + /// Get the number of heights below the stored ones still to sync. + fn missing_below(&self) -> CoreBlockHeight { + 0 + } /// Get completion percentage (0.0 to 1.0). fn percentage(&self) -> f64 { if self.target_height() == 0 { return 0.0; } - (self.current_height() as f64 / self.target_height() as f64).min(1.0) + let done = self.current_height().saturating_sub(self.missing_below()); + (done as f64 / self.target_height() as f64).min(1.0) } } diff --git a/dash-spv/src/test_utils/checkpoint.rs b/dash-spv/src/test_utils/checkpoint.rs index 0e1e20a6c..8db8e99c0 100644 --- a/dash-spv/src/test_utils/checkpoint.rs +++ b/dash-spv/src/test_utils/checkpoint.rs @@ -1,7 +1,7 @@ use dashcore::Header; use crate::chain::checkpoints::CHECKPOINT_HEADERS; -use crate::chain::Checkpoint; +use crate::chain::{Checkpoint, CheckpointManager}; use crate::types::HashedBlockHeader; impl Checkpoint { @@ -13,3 +13,17 @@ impl Checkpoint { Checkpoint::new(height, headers).expect("dummy checkpoint height must fit its headers") } } + +impl CheckpointManager { + /// Checkpoints at every 50th block of `chain`. + pub fn dummy(chain: &[HashedBlockHeader]) -> Self { + let checkpoints = (49..chain.len()) + .step_by(50) + .map(|height| { + let headers = chain[height + 1 - CHECKPOINT_HEADERS..=height].to_vec(); + Checkpoint::new(height as u32, headers).expect("dummy checkpoint must fit") + }) + .collect(); + Self::new(checkpoints) + } +} diff --git a/dash-spv/tests/dashd_sync/helpers.rs b/dash-spv/tests/dashd_sync/helpers.rs index 386b8e05d..b9472bbef 100644 --- a/dash-spv/tests/dashd_sync/helpers.rs +++ b/dash-spv/tests/dashd_sync/helpers.rs @@ -145,12 +145,15 @@ pub(super) async fn wait_for_wallet_synced( if synced >= target { return; } - let deadline = tokio::time::Instant::now() + Duration::from_secs(30); + let deadline = tokio::time::Instant::now() + SYNC_TIMEOUT; loop { let recv = tokio::time::timeout_at(deadline, events.recv()).await; match recv { Err(_) => { - panic!("wallet did not reach synced_height {} within 30s, got {}", target, synced) + panic!( + "wallet did not reach synced_height {} within {:?}, got {}", + target, SYNC_TIMEOUT, synced + ) } Ok(Err(_)) => { panic!("wallet event channel error before reaching synced_height {}", target); diff --git a/dash-spv/tests/dashd_sync/setup.rs b/dash-spv/tests/dashd_sync/setup.rs index 3cccb7c3e..49c8a0a47 100644 --- a/dash-spv/tests/dashd_sync/setup.rs +++ b/dash-spv/tests/dashd_sync/setup.rs @@ -145,14 +145,22 @@ impl TestContext { progress: &SyncProgress, wallet: &Arc>>, wallet_id: &WalletId, + ) { + self.assert_wallet_synced_at(progress, wallet, wallet_id, self.dashd.initial_height).await; + } + + /// [`Self::assert_wallet_synced`] with the chain at `tip`. + pub(super) async fn assert_wallet_synced_at( + &self, + progress: &SyncProgress, + wallet: &Arc>>, + wallet_id: &WalletId, + tip: u32, ) { let header_height = progress.headers().unwrap().current_height(); let filter_header_height = progress.filter_headers().unwrap().current_height(); - assert_eq!(header_height, self.dashd.initial_height, "Header height mismatch"); - assert_eq!( - filter_header_height, self.dashd.initial_height, - "Filter header height mismatch" - ); + assert_eq!(header_height, tip, "Header height mismatch"); + assert_eq!(filter_header_height, tip, "Filter header height mismatch"); let wallet_read = wallet.read().await; let wallet_info = wallet_read.get_wallet_info(wallet_id).expect("Wallet info not found"); diff --git a/dash-spv/tests/dashd_sync/tests_multi_wallet.rs b/dash-spv/tests/dashd_sync/tests_multi_wallet.rs index 3cc6def6f..2ee3c80c7 100644 --- a/dash-spv/tests/dashd_sync/tests_multi_wallet.rs +++ b/dash-spv/tests/dashd_sync/tests_multi_wallet.rs @@ -5,9 +5,15 @@ use key_wallet_manager::WalletManager; use std::collections::HashSet; use std::sync::Arc; use std::time::Duration; +use test_case::test_case; use tokio::sync::RwLock; -use dash_spv::Network; +use dash_spv::chain::checkpoints::CHECKPOINT_HEADERS; +use dash_spv::test_utils::{BlockHeaderStorage, DashCoreNode, DiskStorageManager, StorageManager}; +use dash_spv::types::HashedBlockHeader; +use dash_spv::{ClientConfig, Network, ProgressPercentage, SyncState}; +use dashcore::block::Header; +use dashcore::consensus::deserialize; use dashcore::{Address, Amount}; use super::helpers::{ @@ -616,3 +622,117 @@ async fn test_runtime_add_with_tip_advance_during_rescan() { client_handle.stop().await; } + +/// Stores the headers a checkpoint at `height` of `node`'s chain holds, so the +/// client anchors there as on a bundled one. +async fn anchor_at_checkpoint(config: &ClientConfig, node: &DashCoreNode, height: u32) { + let start = height + 1 - CHECKPOINT_HEADERS as u32; + let headers: Vec = (start..=height) + .map(|h| { + let hash = node.get_block_hash(h).to_string(); + let hex = node.try_rpc_call("getblockheader", &[hash.into(), false.into()]).unwrap(); + let bytes = hex_conservative::decode_to_vec(hex.as_str().unwrap()).unwrap(); + deserialize::
(&bytes).unwrap().into() + }) + .collect(); + let mut storage = DiskStorageManager::new(config).await.unwrap(); + storage.store_headers_at_height(&headers, start).await.unwrap(); + storage.stop().await; +} + +/// A wallet born at genesis, added after the client anchored on a checkpoint +/// above it synced one born at the tip, gets its full history, optionally +/// across a restart and a block mined meanwhile. +#[test_case(false, false ; "at runtime")] +#[test_case(false, true ; "at runtime mining")] +#[test_case(true, false ; "across restart")] +#[test_case(true, true ; "across restart mining")] +#[tokio::test] +async fn test_wallet_added_below_synced_wallet(restart: bool, mine: bool) { + let Some(ctx) = TestContext::new(TestChain::Full).await else { + return; + }; + if mine && !ctx.dashd.supports_mining { + return; + } + let height = ctx.dashd.initial_height; + anchor_at_checkpoint(&ctx.client_config, &ctx.dashd.node, height / 2).await; + let wallet = Arc::new(RwLock::new(WalletManager::::new(Network::Regtest))); + let tip_id = wallet + .write() + .await + .create_wallet_from_mnemonic(EMPTY_MNEMONIC, height, default_test_account_options()) + .unwrap(); + let mut handle = create_and_start_client(&ctx.client_config, Arc::clone(&wallet)).await; + wait_for_sync(&mut handle.progress_receiver, height).await; + + if restart { + handle.stop().await; + } + let history_id = wallet + .write() + .await + .create_wallet_from_mnemonic(&ctx.dashd.wallet.mnemonic, 0, default_test_account_options()) + .unwrap(); + if restart { + drop(handle); + handle = create_and_start_client(&ctx.client_config, Arc::clone(&wallet)).await; + } + + let tip = height + mine as u32; + if mine { + let miner = ctx.dashd.node.get_new_address_from_wallet("default"); + ctx.dashd.node.generate_blocks(1, &miner); + } + + wait_for_sync(&mut handle.progress_receiver, tip).await; + wait_for_wallet_synced(&wallet, &history_id, tip).await; + wait_for_wallet_synced(&wallet, &tip_id, tip).await; + + let progress = handle.client.progress().await; + for (part, state) in [ + ( + progress.headers().unwrap() as &dyn ProgressPercentage, + progress.headers().unwrap().state(), + ), + (progress.filter_headers().unwrap(), progress.filter_headers().unwrap().state()), + ] { + assert_eq!(state, SyncState::Synced); + assert_eq!(part.missing_below(), 0); + assert_eq!(part.percentage(), 1.0); + } + ctx.assert_wallet_synced_at(&progress, &wallet, &history_id, tip).await; + assert_eq!(count_wallet_transactions(&wallet, &tip_id).await, 0); + handle.stop().await; +} + +/// An explicit `start_from_height` limits how far down the client syncs, even +/// for a wallet born below it. +#[tokio::test] +async fn test_explicit_start_height_limits_backfill() { + let Some(ctx) = TestContext::new(TestChain::Full).await else { + return; + }; + let height = ctx.dashd.initial_height; + let anchor = height / 2; + anchor_at_checkpoint(&ctx.client_config, &ctx.dashd.node, anchor).await; + let mut config = ctx.client_config.clone(); + config.start_from_height = Some(anchor); + + let wallet = Arc::new(RwLock::new(WalletManager::::new(Network::Regtest))); + let wallet_id = wallet + .write() + .await + .create_wallet_from_mnemonic(&ctx.dashd.wallet.mnemonic, 0, default_test_account_options()) + .unwrap(); + let mut handle = create_and_start_client(&config, Arc::clone(&wallet)).await; + wait_for_sync(&mut handle.progress_receiver, height).await; + wait_for_wallet_synced(&wallet, &wallet_id, height).await; + handle.stop().await; + drop(handle); + + let mut storage = DiskStorageManager::new(&config).await.unwrap(); + let start = storage.get_start_height().await; + storage.stop().await; + assert_eq!(start, Some(anchor + 1 - CHECKPOINT_HEADERS as u32)); +}