Add MiningRules and wire it up

Author: coderofstuff

consensus/core/src/lib.rs

@@ -27,6 +27,7 @@ pub mod hashing;
 pub mod header;
 pub mod mass;
 pub mod merkle;
+pub mod mining_rules;
 pub mod muhash;
 pub mod network;
 pub mod pruning;

consensus/core/src/mining_rules.rs

@@ -0,0 +1,14 @@
+#[derive(Debug)]
+pub struct MiningRules {}
+
+impl MiningRules {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Default for MiningRules {
+    fn default() -> Self {
+        Self::new()
+    }
+}

consensus/src/consensus/factory.rs

@@ -3,7 +3,7 @@ use super::utxo_set_override::{set_genesis_utxo_commitment_from_config, set_init
 use super::{ctl::Ctl, Consensus};
 use crate::{model::stores::U64Key, pipeline::ProcessingCounters};
 use itertools::Itertools;
-use kaspa_consensus_core::config::Config;
+use kaspa_consensus_core::{config::Config, mining_rules::MiningRules};
 use kaspa_consensus_notify::root::ConsensusNotificationRoot;
 use kaspa_consensusmanager::{ConsensusFactory, ConsensusInstance, DynConsensusCtl, SessionLock};
 use kaspa_core::{debug, time::unix_now, warn};
@@ -254,6 +254,7 @@ pub struct Factory {
     counters: Arc<ProcessingCounters>,
     tx_script_cache_counters: Arc<TxScriptCacheCounters>,
     fd_budget: i32,
+    mining_rules: Arc<MiningRules>,
 }
 
 impl Factory {
@@ -266,6 +267,7 @@ impl Factory {
         counters: Arc<ProcessingCounters>,
         tx_script_cache_counters: Arc<TxScriptCacheCounters>,
         fd_budget: i32,
+        mining_rules: Arc<MiningRules>,
     ) -> Self {
         assert!(fd_budget > 0, "fd_budget has to be positive");
         let mut config = config.clone();
@@ -283,6 +285,7 @@ impl Factory {
             counters,
             tx_script_cache_counters,
             fd_budget,
+            mining_rules,
         };
         factory.delete_inactive_consensus_entries();
         factory
@@ -325,6 +328,7 @@ impl ConsensusFactory for Factory {
             self.counters.clone(),
             self.tx_script_cache_counters.clone(),
             entry.creation_timestamp,
+            self.mining_rules.clone(),
         ));
 
         // We write the new active entry only once the instance was created successfully.
@@ -359,6 +363,7 @@ impl ConsensusFactory for Factory {
             self.counters.clone(),
             self.tx_script_cache_counters.clone(),
             entry.creation_timestamp,
+            self.mining_rules.clone(),
         ));
 
         (ConsensusInstance::new(session_lock, consensus.clone()), Arc::new(Ctl::new(self.management_store.clone(), db, consensus)))

consensus/src/consensus/mod.rs

@@ -65,6 +65,7 @@ use kaspa_consensus_core::{
     header::Header,
     mass::{ContextualMasses, NonContextualMasses},
     merkle::calc_hash_merkle_root,
+    mining_rules::MiningRules,
     muhash::MuHashExtensions,
     network::NetworkType,
     pruning::{PruningPointProof, PruningPointTrustedData, PruningPointsList, PruningProofMetadata},
@@ -162,6 +163,7 @@ impl Consensus {
         counters: Arc<ProcessingCounters>,
         tx_script_cache_counters: Arc<TxScriptCacheCounters>,
         creation_timestamp: u64,
+        mining_rules: Arc<MiningRules>,
     ) -> Self {
         let params = &config.params;
         let perf_params = &config.perf;
@@ -266,6 +268,7 @@ impl Consensus {
             pruning_lock.clone(),
             notification_root.clone(),
             counters.clone(),
+            mining_rules,
         ));
 
         let pruning_processor = Arc::new(PruningProcessor::new(

consensus/src/consensus/test_consensus.rs

@@ -1,5 +1,6 @@
 use async_channel::Sender;
 use kaspa_consensus_core::coinbase::MinerData;
+use kaspa_consensus_core::mining_rules::MiningRules;
 use kaspa_consensus_core::tx::ScriptPublicKey;
 use kaspa_consensus_core::{
     api::ConsensusApi, block::MutableBlock, blockstatus::BlockStatus, header::Header, merkle::calc_hash_merkle_root,
@@ -58,6 +59,7 @@ impl TestConsensus {
             counters,
             tx_script_cache_counters,
             0,
+            Arc::new(MiningRules::default()),
         ));
         let block_builder = TestBlockBuilder::new(consensus.virtual_processor.clone());
 
@@ -78,6 +80,7 @@ impl TestConsensus {
             counters,
             tx_script_cache_counters,
             0,
+            Arc::new(MiningRules::default()),
         ));
         let block_builder = TestBlockBuilder::new(consensus.virtual_processor.clone());
 
@@ -99,6 +102,7 @@ impl TestConsensus {
             counters,
             tx_script_cache_counters,
             0,
+            Arc::new(MiningRules::default()),
         ));
         let block_builder = TestBlockBuilder::new(consensus.virtual_processor.clone());
 

consensus/src/pipeline/virtual_processor/processor.rs

@@ -60,6 +60,7 @@ use kaspa_consensus_core::{
     },
     header::Header,
     merkle::calc_hash_merkle_root,
+    mining_rules::MiningRules,
     pruning::PruningPointsList,
     tx::{MutableTransaction, Transaction},
     utxo::{
@@ -175,6 +176,9 @@ pub struct VirtualStateProcessor {
 
     // Crescendo hardfork activation score (used here for activating KIPs 9,10)
     pub(crate) crescendo_activation: ForkActivation,
+
+    // Mining Rule
+    mining_rules: Arc<MiningRules>,
 }
 
 impl VirtualStateProcessor {
@@ -191,6 +195,7 @@ impl VirtualStateProcessor {
         pruning_lock: SessionLock,
         notification_root: Arc<ConsensusNotificationRoot>,
         counters: Arc<ProcessingCounters>,
+        mining_rules: Arc<MiningRules>,
     ) -> Self {
         Self {
             receiver,
@@ -240,6 +245,7 @@ impl VirtualStateProcessor {
             counters,
             crescendo_logger: CrescendoLogger::new(),
             crescendo_activation: params.crescendo_activation,
+            mining_rules,
         }
     }
 

kaspad/src/daemon.rs

@@ -5,6 +5,7 @@ use kaspa_consensus_core::{
     config::ConfigBuilder,
     constants::TRANSIENT_BYTE_TO_MASS_FACTOR,
     errors::config::{ConfigError, ConfigResult},
+    mining_rules::MiningRules,
 };
 use kaspa_consensus_notify::{root::ConsensusNotificationRoot, service::NotifyService};
 use kaspa_core::{core::Core, debug, info, trace};
@@ -508,6 +509,7 @@ do you confirm? (answer y/n or pass --yes to the Kaspad command line to confirm
     let grpc_tower_counters = Arc::new(TowerConnectionCounters::default());
 
     // Use `num_cpus` background threads for the consensus database as recommended by rocksdb
+    let mining_rules = Arc::new(MiningRules::default());
     let consensus_db_parallelism = num_cpus::get();
     let consensus_factory = Arc::new(ConsensusFactory::new(
         meta_db.clone(),
@@ -518,6 +520,7 @@ do you confirm? (answer y/n or pass --yes to the Kaspad command line to confirm
         processing_counters.clone(),
         tx_script_cache_counters.clone(),
         fd_remaining,
+        mining_rules.clone(),
     ));
     let consensus_manager = Arc::new(ConsensusManager::new(consensus_factory));
     let consensus_monitor = Arc::new(ConsensusMonitor::new(processing_counters.clone(), tick_service.clone()));
@@ -579,6 +582,7 @@ do you confirm? (answer y/n or pass --yes to the Kaspad command line to confirm
         processing_counters.clone(),
         tick_service.clone(),
         hub.clone(),
+        mining_rules,
     ));
     let flow_context = Arc::new(FlowContext::new(
         consensus_manager.clone(),

protocol/mining/src/rule_engine.rs

@@ -10,6 +10,7 @@ use kaspa_consensus_core::{
     api::counters::ProcessingCounters,
     config::{params::NEW_DIFFICULTY_WINDOW_DURATION, Config},
     daa_score_timestamp::DaaScoreTimestamp,
+    mining_rules::MiningRules,
     network::NetworkType::{Mainnet, Testnet},
 };
 use kaspa_consensusmanager::ConsensusManager;
@@ -35,6 +36,7 @@ pub struct MiningRuleEngine {
     use_sync_rate_rule: Arc<AtomicBool>,
     consensus_manager: Arc<ConsensusManager>,
     hub: Hub,
+    mining_rules: Arc<MiningRules>,
 }
 
 impl MiningRuleEngine {
@@ -44,6 +46,7 @@ impl MiningRuleEngine {
         let mut last_snapshot = self.processing_counters.snapshot();
         let mut last_log_time = Instant::now();
         loop {
+            // START: Sync monitor
             if let TickReason::Shutdown = self.tick_service.tick(Duration::from_secs(snapshot_interval)).await {
                 // Let the system print final logs before exiting
                 tokio::time::sleep(Duration::from_millis(500)).await;
@@ -102,6 +105,12 @@ impl MiningRuleEngine {
                         trace!("Finality period is old. Timestamp: {}. Sync rate: {:.2}", finality_point_timestamp, rate);
                     }
                 }
+
+                // END - Sync monitor
+
+                // START - Rule Engine
+                trace!("Current Mining Rule: {:?}", self.mining_rules);
+                // End - Rule Engine
             }
 
             last_snapshot = snapshot;
@@ -115,6 +124,7 @@ impl MiningRuleEngine {
         processing_counters: Arc<ProcessingCounters>,
         tick_service: Arc<TickService>,
         hub: Hub,
+        mining_rules: Arc<MiningRules>,
     ) -> Self {
         Self {
             consensus_manager,
@@ -123,6 +133,7 @@ impl MiningRuleEngine {
             tick_service,
             hub,
             use_sync_rate_rule: Arc::new(AtomicBool::new(false)),
+            mining_rules,
         }
     }
 

simpa/src/main.rs

@@ -17,7 +17,7 @@ use kaspa_consensus::{
 };
 use kaspa_consensus_core::{
     api::ConsensusApi, block::Block, blockstatus::BlockStatus, config::bps::calculate_ghostdag_k, errors::block::BlockProcessResult,
-    BlockHashSet, BlockLevel, HashMapCustomHasher,
+    mining_rules::MiningRules, BlockHashSet, BlockLevel, HashMapCustomHasher,
 };
 use kaspa_consensus_notify::root::ConsensusNotificationRoot;
 use kaspa_core::{
@@ -240,6 +240,7 @@ fn main_impl(mut args: Args) {
             Default::default(),
             Default::default(),
             unix_now(),
+            Arc::new(MiningRules::default()),
         ));
         (consensus, lifetime)
     } else {
@@ -311,6 +312,7 @@ fn main_impl(mut args: Args) {
         Default::default(),
         Default::default(),
         unix_now(),
+        Arc::new(MiningRules::default()),
     ));
     let handles2 = consensus2.run_processors();
     if args.headers_first {

simpa/src/simulator/network.rs

@@ -1,4 +1,5 @@
 use async_channel::unbounded;
+use kaspa_consensus_core::mining_rules::MiningRules;
 use kaspa_consensus_notify::root::ConsensusNotificationRoot;
 use kaspa_core::time::unix_now;
 use std::sync::Arc;
@@ -86,6 +87,7 @@ impl KaspaNetworkSimulator {
                 Default::default(),
                 Default::default(),
                 unix_now(),
+                Arc::new(MiningRules::default()),
             ));
             let handles = consensus.run_processors();
             let (sk, pk) = secp.generate_keypair(&mut rng);