Add errors and remove old implementation

Author: someone235

consensus/core/src/errors/consensus.rs

@@ -32,6 +32,9 @@ pub enum ConsensusError {
     #[error("difficulty error: {0}")]
     DifficultyError(#[from] DifficultyError),
 
+    #[error("window data has only {0} entries -- this usually happens when the node has just began syncing")]
+    InsufficientWindowData(usize),
+
     #[error("{0}")]
     General(&'static str),
 

consensus/core/src/errors/difficulty.rs

@@ -2,12 +2,6 @@ use thiserror::Error;
 
 #[derive(Error, Debug, Clone)]
 pub enum DifficultyError {
-    #[error("under min allowed window size ({0} < {1})")]
-    UnderMinWindowSizeAllowed(usize, usize),
-
-    #[error("window data has only {0} entries -- this usually happens when the node has just began syncing")]
-    InsufficientWindowData(usize),
-
     #[error("min window timestamp is equal to the max window timestamp")]
     EmptyTimestampRange,
 }

consensus/src/consensus/mod.rs

@@ -41,7 +41,7 @@ use crate::{
     processes::{
         difficulty::calc_work,
         ghostdag::ordering::SortableBlock,
-        window::{WindowManager, WindowType},
+        window::{self, WindowManager, WindowType},
     },
 };
 use kaspa_consensus_core::{
@@ -470,6 +470,10 @@ impl Consensus {
     }
 
     fn estimate_network_hashes_per_second_impl(&self, ghostdag_data: &GhostdagData, window_size: usize) -> ConsensusResult<u64> {
+        if window_size == 0 {
+            return Err(ConsensusError::General("window size cannot be zero"));
+        }
+
         let mut count = 0;
         let mut red_work: BlueWorkType = 0.into();
         let mut bottom = ghostdag_data.selected_parent;
@@ -485,6 +489,11 @@ impl Consensus {
                 break;
             }
         }
+
+        if count < window_size {
+            return Err(ConsensusError::InsufficientWindowData(count));
+        }
+
         let sp_header = self.headers_store.get_header(ghostdag_data.selected_parent).unwrap();
         let bottom_header = self.headers_store.get_header(bottom).unwrap();
         let blue_work = sp_header.blue_work - bottom_header.blue_work;
@@ -1135,7 +1144,7 @@ impl ConsensusApi for Consensus {
                 let ghostdag_data = self.ghostdag_store.get_data(hash).unwrap();
                 // The selected parent header is used within to check for sampling activation, so we verify its existence first
                 if !self.headers_store.has(ghostdag_data.selected_parent).unwrap() {
-                    return Err(ConsensusError::DifficultyError(DifficultyError::InsufficientWindowData(0)));
+                    return Err(ConsensusError::InsufficientWindowData(0));
                 }
                 self.estimate_network_hashes_per_second_impl(&ghostdag_data, window_size)
             }

consensus/src/processes/difficulty.rs

@@ -44,29 +44,6 @@ trait DifficultyManagerExtension {
             .collect()
     }
 
-    fn internal_estimate_network_hashes_per_second(&self, window: &BlockWindowHeap) -> DifficultyResult<u64> {
-        // TODO: perhaps move this const
-        const MIN_WINDOW_SIZE: usize = 1000;
-        let window_size = window.len();
-        if window_size < MIN_WINDOW_SIZE {
-            return Err(DifficultyError::UnderMinWindowSizeAllowed(window_size, MIN_WINDOW_SIZE));
-        }
-        let difficulty_blocks = self.get_difficulty_blocks(window);
-        let (min_ts, max_ts) = difficulty_blocks.iter().map(|x| x.timestamp).minmax().into_option().unwrap();
-        if min_ts == max_ts {
-            return Err(DifficultyError::EmptyTimestampRange);
-        }
-        let window_duration = (max_ts - min_ts) / 1000; // Divided by 1000 to convert milliseconds to seconds
-        if window_duration == 0 {
-            return Ok(0);
-        }
-
-        let (min_blue_work, max_blue_work) =
-            difficulty_blocks.iter().map(|x| x.sortable_block.blue_work).minmax().into_option().unwrap();
-
-        Ok(((max_blue_work - min_blue_work) / window_duration).as_u64())
-    }
-
     #[inline]
     fn check_min_difficulty_window_size(difficulty_window_size: usize, min_difficulty_window_size: usize) {
         assert!(
@@ -156,10 +133,6 @@ impl<T: HeaderStoreReader> FullDifficultyManager<T> {
         let new_target = average_target * max(max_ts - min_ts, 1) / (self.target_time_per_block * difficulty_blocks_len);
         Uint256::try_from(new_target.min(self.max_difficulty_target)).expect("max target < Uint256::MAX").compact_target_bits()
     }
-
-    pub fn estimate_network_hashes_per_second(&self, window: &BlockWindowHeap) -> DifficultyResult<u64> {
-        self.internal_estimate_network_hashes_per_second(window)
-    }
 }
 
 impl<T: HeaderStoreReader> DifficultyManagerExtension for FullDifficultyManager<T> {
@@ -396,10 +369,6 @@ impl<T: HeaderStoreReader, U: GhostdagStoreReader> SampledDifficultyManager<T, U
 
         Uint256::try_from(new_target.min(self.max_difficulty_target)).expect("max target < Uint256::MAX").compact_target_bits()
     }
-
-    pub fn estimate_network_hashes_per_second(&self, window: &BlockWindowHeap) -> DifficultyResult<u64> {
-        self.internal_estimate_network_hashes_per_second(window)
-    }
 }
 
 impl<T: HeaderStoreReader, U: GhostdagStoreReader> DifficultyManagerExtension for SampledDifficultyManager<T, U> {

consensus/src/processes/window.rs

@@ -57,7 +57,6 @@ pub trait WindowManager {
     fn calculate_difficulty_bits(&self, ghostdag_data: &GhostdagData, daa_window: &DaaWindow) -> u32;
     fn calc_past_median_time(&self, ghostdag_data: &GhostdagData) -> Result<(u64, Arc<BlockWindowHeap>), RuleError>;
     fn calc_past_median_time_for_known_hash(&self, hash: Hash) -> Result<u64, RuleError>;
-    fn estimate_network_hashes_per_second(&self, window: Arc<BlockWindowHeap>) -> DifficultyResult<u64>;
     fn window_size(&self, ghostdag_data: &GhostdagData, window_type: WindowType) -> usize;
     fn sample_rate(&self, ghostdag_data: &GhostdagData, window_type: WindowType) -> u64;
 
@@ -263,10 +262,6 @@ impl<T: GhostdagStoreReader, U: BlockWindowCacheReader + BlockWindowCacheWriter,
         }
     }
 
-    fn estimate_network_hashes_per_second(&self, window: Arc<BlockWindowHeap>) -> DifficultyResult<u64> {
-        self.difficulty_manager.estimate_network_hashes_per_second(&window)
-    }
-
     fn window_size(&self, _ghostdag_data: &GhostdagData, window_type: WindowType) -> usize {
         match window_type {
             WindowType::DifficultyWindow => self.difficulty_window_size,
@@ -682,10 +677,6 @@ impl<T: GhostdagStoreReader, U: BlockWindowCacheReader + BlockWindowCacheWriter,
         }
     }
 
-    fn estimate_network_hashes_per_second(&self, window: Arc<BlockWindowHeap>) -> DifficultyResult<u64> {
-        self.difficulty_manager.estimate_network_hashes_per_second(&window)
-    }
-
     fn window_size(&self, _ghostdag_data: &GhostdagData, window_type: WindowType) -> usize {
         match window_type {
             WindowType::DifficultyWindow => self.difficulty_window_size,
@@ -865,10 +856,6 @@ impl<T: GhostdagStoreReader, U: BlockWindowCacheReader + BlockWindowCacheWriter,
         }
     }
 
-    fn estimate_network_hashes_per_second(&self, window: Arc<BlockWindowHeap>) -> DifficultyResult<u64> {
-        self.sampled_window_manager.estimate_network_hashes_per_second(window)
-    }
-
     fn window_size(&self, ghostdag_data: &GhostdagData, window_type: WindowType) -> usize {
         match self.sampling(ghostdag_data.selected_parent) {
             true => self.sampled_window_manager.window_size(ghostdag_data, window_type),