Move is_nearly_synced logic from params to rule engine

Author: coderofstuff

consensus/core/src/config/params.rs

@@ -10,10 +10,7 @@ use crate::{
 };
 use kaspa_addresses::Prefix;
 use kaspa_math::Uint256;
-use std::{
-    cmp::min,
-    time::{SystemTime, UNIX_EPOCH},
-};
+use std::cmp::min;
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub struct ForkActivation(u64);
@@ -136,10 +133,6 @@ pub struct Params {
     pub runtime_sig_op_counting: ForkActivation,
 }
 
-fn unix_now() -> u64 {
-    SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64
-}
-
 impl Params {
     /// Returns the size of the full blocks window that is inspected to calculate the past median time (legacy)
     #[inline]
@@ -238,7 +231,7 @@ impl Params {
         }
     }
 
-    fn expected_daa_window_duration_in_milliseconds(&self, selected_parent_daa_score: u64) -> u64 {
+    pub fn expected_daa_window_duration_in_milliseconds(&self, selected_parent_daa_score: u64) -> u64 {
         if self.sampling_activation.is_active(selected_parent_daa_score) {
             self.target_time_per_block * self.difficulty_sample_rate * self.sampled_difficulty_window_size as u64
         } else {
@@ -264,26 +257,6 @@ impl Params {
         min(self.pruning_depth, anticone_finalization_depth)
     }
 
-    /// Returns whether the sink timestamp is recent enough and the node is considered synced or nearly synced.
-    pub fn is_nearly_synced(&self, sink_timestamp: u64, sink_daa_score: u64) -> bool {
-        if self.net.is_mainnet() {
-            // We consider the node close to being synced if the sink (virtual selected parent) block
-            // timestamp is within DAA window duration far in the past. Blocks mined over such DAG state would
-            // enter the DAA window of fully-synced nodes and thus contribute to overall network difficulty
-            unix_now() < sink_timestamp + self.expected_daa_window_duration_in_milliseconds(sink_daa_score)
-        } else {
-            // For testnets we consider the node to be synced if the sink timestamp is within a time range which
-            // is overwhelmingly unlikely to pass without mined blocks even if net hashrate decreased dramatically.
-            //
-            // This period is smaller than the above mainnet calculation in order to ensure that an IBDing miner
-            // with significant testnet hashrate does not overwhelm the network with deep side-DAGs.
-            //
-            // We use DAA duration as baseline and scale it down with BPS (and divide by 3 for mining only when very close to current time on TN11)
-            let max_expected_duration_without_blocks_in_milliseconds = self.target_time_per_block * NEW_DIFFICULTY_WINDOW_DURATION / 3; // = DAA duration in milliseconds / bps / 3
-            unix_now() < sink_timestamp + max_expected_duration_without_blocks_in_milliseconds
-        }
-    }
-
     pub fn network_name(&self) -> String {
         self.net.to_prefixed()
     }

protocol/mining/src/rule_engine.rs

@@ -8,7 +8,7 @@ use std::{
 
 use kaspa_consensus_core::{
     api::counters::ProcessingCounters,
-    config::Config,
+    config::{params::NEW_DIFFICULTY_WINDOW_DURATION, Config},
     daa_score_timestamp::DaaScoreTimestamp,
     network::NetworkType::{Mainnet, Testnet},
 };
@@ -133,12 +133,32 @@ impl MiningRuleEngine {
         is_nearly_synced || self.use_sync_rate_rule.load(std::sync::atomic::Ordering::Relaxed)
     }
 
-    /// Returns whether this consensus is considered synced or close to being synced.
+    /// Returns whether the sink timestamp is recent enough and the node is considered synced or nearly synced.
     ///
     /// This info is used to determine if it's ok to use a block template from this node for mining purposes.
     pub fn is_nearly_synced(&self, sink_daa_score_timestamp: DaaScoreTimestamp) -> bool {
-        // See comment within `config.is_nearly_synced`
-        self.config.is_nearly_synced(sink_daa_score_timestamp.timestamp, sink_daa_score_timestamp.daa_score)
+        let sink_timestamp = sink_daa_score_timestamp.timestamp;
+
+        if self.config.net.is_mainnet() {
+            // We consider the node close to being synced if the sink (virtual selected parent) block
+            // timestamp is within DAA window duration far in the past. Blocks mined over such DAG state would
+            // enter the DAA window of fully-synced nodes and thus contribute to overall network difficulty
+            let daa_window_duration = self.config.expected_daa_window_duration_in_milliseconds(sink_daa_score_timestamp.daa_score);
+
+            unix_now() < sink_timestamp + daa_window_duration
+        } else {
+            // For testnets we consider the node to be synced if the sink timestamp is within a time range which
+            // is overwhelmingly unlikely to pass without mined blocks even if net hashrate decreased dramatically.
+            //
+            // This period is smaller than the above mainnet calculation in order to ensure that an IBDing miner
+            // with significant testnet hashrate does not overwhelm the network with deep side-DAGs.
+            //
+            // We use DAA duration as baseline and scale it down with BPS (and divide by 3 for mining only when very close to current time on TN11)
+            let max_expected_duration_without_blocks_in_milliseconds =
+                self.config.target_time_per_block * NEW_DIFFICULTY_WINDOW_DURATION / 3; // = DAA duration in milliseconds / bps / 3
+
+            unix_now() < sink_timestamp + max_expected_duration_without_blocks_in_milliseconds
+        }
     }
 
     fn has_sufficient_peer_connectivity(&self) -> bool {