chore: remove HeaderSyncMode::Continuous & debug.continuous (#8714)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
Co-authored-by: Oliver Nordbjerg <hi@notbjerg.me>

crates/storage/provider/src/providers/database/mod.rs

@@ -3,10 +3,9 @@ use crate::{
     to_range,
     traits::{BlockSource, ReceiptProvider},
     BlockHashReader, BlockNumReader, BlockReader, ChainSpecProvider, DatabaseProviderFactory,
-    EvmEnvProvider, HeaderProvider, HeaderSyncGap, HeaderSyncGapProvider, HeaderSyncMode,
-    ProviderError, PruneCheckpointReader, RequestsProvider, StageCheckpointReader,
-    StateProviderBox, StaticFileProviderFactory, TransactionVariant, TransactionsProvider,
-    WithdrawalsProvider,
+    EvmEnvProvider, HeaderProvider, HeaderSyncGap, HeaderSyncGapProvider, ProviderError,
+    PruneCheckpointReader, RequestsProvider, StageCheckpointReader, StateProviderBox,
+    StaticFileProviderFactory, TransactionVariant, TransactionsProvider, WithdrawalsProvider,
 };
 use reth_db::{init_db, mdbx::DatabaseArguments, DatabaseEnv};
 use reth_db_api::{database::Database, models::StoredBlockBodyIndices};
@@ -27,6 +26,7 @@ use std::{
     path::Path,
     sync::Arc,
 };
+use tokio::sync::watch;
 use tracing::trace;
 
 mod metrics;
@@ -165,10 +165,10 @@ impl<DB> StaticFileProviderFactory for ProviderFactory<DB> {
 impl<DB: Database> HeaderSyncGapProvider for ProviderFactory<DB> {
     fn sync_gap(
         &self,
-        mode: HeaderSyncMode,
+        tip: watch::Receiver<B256>,
         highest_uninterrupted_block: BlockNumber,
     ) -> ProviderResult<HeaderSyncGap> {
-        self.provider()?.sync_gap(mode, highest_uninterrupted_block)
+        self.provider()?.sync_gap(tip, highest_uninterrupted_block)
     }
 }
 
@@ -592,8 +592,7 @@ mod tests {
     use crate::{
         providers::{StaticFileProvider, StaticFileWriter},
         test_utils::create_test_provider_factory,
-        BlockHashReader, BlockNumReader, BlockWriter, HeaderSyncGapProvider, HeaderSyncMode,
-        TransactionsProvider,
+        BlockHashReader, BlockNumReader, BlockWriter, HeaderSyncGapProvider, TransactionsProvider,
     };
     use alloy_rlp::Decodable;
     use assert_matches::assert_matches;
@@ -748,7 +747,6 @@ mod tests {
         let mut rng = generators::rng();
         let consensus_tip = rng.gen();
         let (_tip_tx, tip_rx) = watch::channel(consensus_tip);
-        let mode = HeaderSyncMode::Tip(tip_rx);
 
         // Genesis
         let checkpoint = 0;
@@ -756,7 +754,7 @@ mod tests {
 
         // Empty database
         assert_matches!(
-            provider.sync_gap(mode.clone(), checkpoint),
+            provider.sync_gap(tip_rx.clone(), checkpoint),
             Err(ProviderError::HeaderNotFound(block_number))
                 if block_number.as_number().unwrap() == checkpoint
         );
@@ -768,7 +766,7 @@ mod tests {
         static_file_writer.commit().unwrap();
         drop(static_file_writer);
 
-        let gap = provider.sync_gap(mode, checkpoint).unwrap();
+        let gap = provider.sync_gap(tip_rx, checkpoint).unwrap();
         assert_eq!(gap.local_head, head);
         assert_eq!(gap.target.tip(), consensus_tip.into());
     }

crates/storage/provider/src/providers/database/provider.rs

@@ -7,8 +7,8 @@ use crate::{
     },
     AccountReader, BlockExecutionWriter, BlockHashReader, BlockNumReader, BlockReader, BlockWriter,
     Chain, EvmEnvProvider, FinalizedBlockReader, FinalizedBlockWriter, HashingWriter,
-    HeaderProvider, HeaderSyncGap, HeaderSyncGapProvider, HeaderSyncMode, HistoricalStateProvider,
-    HistoryWriter, LatestStateProvider, OriginalValuesKnown, ProviderError, PruneCheckpointReader,
+    HeaderProvider, HeaderSyncGap, HeaderSyncGapProvider, HistoricalStateProvider, HistoryWriter,
+    LatestStateProvider, OriginalValuesKnown, ProviderError, PruneCheckpointReader,
     PruneCheckpointWriter, RequestsProvider, StageCheckpointReader, StateProviderBox, StateWriter,
     StatsReader, StorageReader, TransactionVariant, TransactionsProvider, TransactionsProviderExt,
     WithdrawalsProvider,
@@ -55,6 +55,7 @@ use std::{
     sync::{mpsc, Arc},
     time::{Duration, Instant},
 };
+use tokio::sync::watch;
 use tracing::{debug, error, warn};
 
 /// A [`DatabaseProvider`] that holds a read-only database transaction.
@@ -1272,7 +1273,7 @@ impl<TX: DbTx> ChangeSetReader for DatabaseProvider<TX> {
 impl<TX: DbTx> HeaderSyncGapProvider for DatabaseProvider<TX> {
     fn sync_gap(
         &self,
-        mode: HeaderSyncMode,
+        tip: watch::Receiver<B256>,
         highest_uninterrupted_block: BlockNumber,
     ) -> ProviderResult<HeaderSyncGap> {
         let static_file_provider = self.static_file_provider();
@@ -1307,10 +1308,7 @@ impl<TX: DbTx> HeaderSyncGapProvider for DatabaseProvider<TX> {
             .sealed_header(highest_uninterrupted_block)?
             .ok_or_else(|| ProviderError::HeaderNotFound(highest_uninterrupted_block.into()))?;
 
-        let target = match mode {
-            HeaderSyncMode::Tip(rx) => SyncTarget::Tip(*rx.borrow()),
-            HeaderSyncMode::Continuous => SyncTarget::TipNum(highest_uninterrupted_block + 1),
-        };
+        let target = SyncTarget::Tip(*tip.borrow());
 
         Ok(HeaderSyncGap { local_head, target })
     }

crates/storage/provider/src/traits/header_sync_gap.rs

@@ -3,17 +3,6 @@ use reth_primitives::{BlockHashOrNumber, BlockNumber, SealedHeader, B256};
 use reth_storage_errors::provider::ProviderResult;
 use tokio::sync::watch;
 
-/// The header sync mode.
-#[derive(Clone, Debug)]
-pub enum HeaderSyncMode {
-    /// A sync mode in which the stage continuously requests the downloader for
-    /// next blocks.
-    Continuous,
-    /// A sync mode in which the stage polls the receiver for the next tip
-    /// to download from.
-    Tip(watch::Receiver<B256>),
-}
-
 /// Represents a gap to sync: from `local_head` to `target`
 #[derive(Clone, Debug)]
 pub struct HeaderSyncGap {
@@ -38,13 +27,13 @@ impl HeaderSyncGap {
 /// Client trait for determining the current headers sync gap.
 #[auto_impl::auto_impl(&, Arc)]
 pub trait HeaderSyncGapProvider: Send + Sync {
-    /// Find a current sync gap for the headers depending on the [HeaderSyncMode] and the last
+    /// Find a current sync gap for the headers depending on the last
     /// uninterrupted block number. Last uninterrupted block represents the block number before
     /// which there are no gaps. It's up to the caller to ensure that last uninterrupted block is
     /// determined correctly.
     fn sync_gap(
         &self,
-        mode: HeaderSyncMode,
+        tip: watch::Receiver<B256>,
         highest_uninterrupted_block: BlockNumber,
     ) -> ProviderResult<HeaderSyncGap>;
 }

crates/storage/provider/src/traits/mod.rs

@@ -13,7 +13,7 @@ mod chain_info;
 pub use chain_info::CanonChainTracker;
 
 mod header_sync_gap;
-pub use header_sync_gap::{HeaderSyncGap, HeaderSyncGapProvider, HeaderSyncMode};
+pub use header_sync_gap::{HeaderSyncGap, HeaderSyncGapProvider};
 
 mod state;
 pub use state::StateWriter;