Mining Rule Engine: No Transactions Rule

Author: coderofstuff

consensus/core/src/api/counters.rs

@@ -11,6 +11,8 @@ pub struct ProcessingCounters {
     pub chain_block_counts: AtomicU64,
     pub chain_disqualified_counts: AtomicU64,
     pub mass_counts: AtomicU64,
+    pub submit_block_bad_merkle_root_count: AtomicU64,
+    pub submit_block_success_count: AtomicU64,
 }
 
 impl ProcessingCounters {
@@ -25,6 +27,8 @@ impl ProcessingCounters {
             chain_block_counts: self.chain_block_counts.load(Ordering::Relaxed),
             chain_disqualified_counts: self.chain_disqualified_counts.load(Ordering::Relaxed),
             mass_counts: self.mass_counts.load(Ordering::Relaxed),
+            submit_block_bad_merkle_root_count: self.submit_block_bad_merkle_root_count.load(Ordering::Relaxed),
+            submit_block_success_count: self.submit_block_success_count.load(Ordering::Relaxed),
         }
     }
 }
@@ -40,6 +44,8 @@ pub struct ProcessingCountersSnapshot {
     pub chain_block_counts: u64,
     pub chain_disqualified_counts: u64,
     pub mass_counts: u64,
+    pub submit_block_bad_merkle_root_count: u64,
+    pub submit_block_success_count: u64,
 }
 
 impl core::ops::Sub for &ProcessingCountersSnapshot {
@@ -56,6 +62,10 @@ impl core::ops::Sub for &ProcessingCountersSnapshot {
             chain_block_counts: self.chain_block_counts.saturating_sub(rhs.chain_block_counts),
             chain_disqualified_counts: self.chain_disqualified_counts.saturating_sub(rhs.chain_disqualified_counts),
             mass_counts: self.mass_counts.saturating_sub(rhs.mass_counts),
+            submit_block_bad_merkle_root_count: self
+                .submit_block_bad_merkle_root_count
+                .saturating_sub(rhs.submit_block_bad_merkle_root_count),
+            submit_block_success_count: self.submit_block_success_count.saturating_sub(rhs.submit_block_success_count),
         }
     }
 }

consensus/core/src/mining_rules.rs

@@ -1,9 +1,13 @@
+use std::sync::{atomic::AtomicBool, Arc};
+
 #[derive(Debug)]
-pub struct MiningRules {}
+pub struct MiningRules {
+    pub no_transactions: Arc<AtomicBool>,
+}
 
 impl MiningRules {
     pub fn new() -> Self {
-        Self {}
+        Self { no_transactions: Arc::new(AtomicBool::new(false)) }
     }
 }
 

consensus/src/pipeline/virtual_processor/processor.rs

@@ -964,7 +964,9 @@ impl VirtualStateProcessor {
         // We call for the initial tx batch before acquiring the virtual read lock,
         // optimizing for the common case where all txs are valid. Following selection calls
         // are called within the lock in order to preserve validness of already validated txs
-        let mut txs = tx_selector.select_transactions();
+        let mut txs =
+            if self.mining_rules.no_transactions.load(Ordering::Relaxed) { vec![] } else { tx_selector.select_transactions() };
+
         let mut calculated_fees = Vec::with_capacity(txs.len());
         let virtual_read = self.virtual_stores.read();
         let virtual_state = virtual_read.state.get().unwrap();

protocol/mining/src/rule_engine.rs

@@ -21,7 +21,7 @@ use kaspa_core::{
 };
 use kaspa_p2p_lib::Hub;
 
-use crate::rules::{mining_rule::MiningRule, sync_rate_rule::SyncRateRule, ExtraData};
+use crate::rules::{mining_rule::MiningRule, no_transactions_rule::NoTransactionsRule, sync_rate_rule::SyncRateRule, ExtraData};
 
 const RULE_ENGINE: &str = "mining-rule-engine";
 pub const SNAPSHOT_INTERVAL: u64 = 10;
@@ -75,6 +75,8 @@ impl MiningRuleEngine {
                     has_sufficient_peer_connectivity: self.has_sufficient_peer_connectivity(),
                     finality_duration: self.config.finality_duration_in_milliseconds().get(sink_daa_timestamp.daa_score),
                     elapsed_time,
+                    sink_daa_score_timestamp: session.async_get_sink_daa_score_timestamp().await,
+                    merge_depth: self.config.merge_depth().get(sink_daa_timestamp.daa_score),
                 };
 
                 trace!("Current Mining Rule: {:?}", self.mining_rules);
@@ -99,7 +101,10 @@ impl MiningRuleEngine {
         mining_rules: Arc<MiningRules>,
     ) -> Self {
         let use_sync_rate_rule = Arc::new(AtomicBool::new(false));
-        let rules: Vec<Arc<(dyn MiningRule + 'static)>> = vec![Arc::new(SyncRateRule::new(use_sync_rate_rule.clone()))];
+        let rules: Vec<Arc<(dyn MiningRule + 'static)>> = vec![
+            Arc::new(SyncRateRule::new(use_sync_rate_rule.clone())),
+            Arc::new(NoTransactionsRule::new(mining_rules.no_transactions.clone())),
+        ];
 
         Self { consensus_manager, config, processing_counters, tick_service, hub, use_sync_rate_rule, mining_rules, rules }
     }

protocol/mining/src/rules/mod.rs

@@ -1,5 +1,8 @@
 use std::time::Duration;
 
+use kaspa_consensus_core::daa_score_timestamp::DaaScoreTimestamp;
+
+pub mod no_transactions_rule;
 pub mod sync_rate_rule;
 
 pub mod mining_rule;
@@ -10,4 +13,6 @@ pub struct ExtraData {
     pub has_sufficient_peer_connectivity: bool,
     pub finality_duration: u64,
     pub elapsed_time: Duration,
+    pub sink_daa_score_timestamp: DaaScoreTimestamp,
+    pub merge_depth: u64,
 }

protocol/mining/src/rules/no_transactions_rule.rs

@@ -0,0 +1,64 @@
+use std::sync::{
+    atomic::{AtomicBool, AtomicU8, Ordering},
+    Arc,
+};
+
+use kaspa_consensus_core::api::counters::ProcessingCountersSnapshot;
+use kaspa_core::{trace, warn};
+
+use super::{mining_rule::MiningRule, ExtraData};
+
+/// NoTransactionsRule
+/// Attempt to recover from consistent BadMerkleRoot errors by mining blocks without
+/// any transactions.
+///
+/// Trigger:
+/// - Submitted blocks resulted in BadMerkleRoot errors and there were no successfully submitted blocks
+///
+/// Recovery:
+/// - Two cooldown periods have passed, OR
+/// - Any submit block RPC call succeeded
+pub struct NoTransactionsRule {
+    pub is_enabled: Arc<AtomicBool>,
+    pub cooldown: AtomicU8,
+}
+
+impl NoTransactionsRule {
+    pub fn new(is_enabled: Arc<AtomicBool>) -> Self {
+        Self { is_enabled, cooldown: AtomicU8::new(0) }
+    }
+}
+
+impl MiningRule for NoTransactionsRule {
+    fn check_rule(&self, delta: &ProcessingCountersSnapshot, _extra_data: &ExtraData) {
+        let cooldown_count = self.cooldown.load(Ordering::SeqCst);
+
+        if cooldown_count > 0 {
+            // Recovering
+            if delta.submit_block_success_count > 0 || self.cooldown.fetch_sub(1, Ordering::SeqCst) == 1 {
+                // Recovery condition #1: Any submit block RPC call succeeded in this interval
+                // Recovery condition #2: Cooldown period has passed (important for low hashrate miners whose successful blocks are few and far between)
+                self.cooldown.store(0, Ordering::SeqCst);
+                self.is_enabled.store(false, Ordering::SeqCst);
+                warn!("NoTransactionsRule: recovered | Bad Merkle Root Count: {}", delta.submit_block_bad_merkle_root_count);
+            }
+        } else if delta.submit_block_bad_merkle_root_count > 0 && delta.submit_block_success_count == 0 {
+            // Triggered state
+            // When submit block BadMerkleRoot errors occurred and there were no successfully submitted blocks
+            if let Ok(false) = self.is_enabled.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst) {
+                warn!(
+                    "NoTransactionsRule: triggered | Bad Merkle Root Count: {} | Successfully submitted blocks: {}",
+                    delta.submit_block_bad_merkle_root_count, delta.submit_block_success_count
+                );
+                self.cooldown.store(2, Ordering::Relaxed);
+            }
+        } else {
+            // Normal state
+            trace!(
+                "NoTransactionsRule: normal | Bad Merkle Root Count: {} | Successfully submitted blocks: {}",
+                delta.submit_block_bad_merkle_root_count,
+                delta.submit_block_success_count,
+            );
+        }
+    }
+}

rpc/service/src/service.rs

@@ -334,8 +334,13 @@ impl RpcApi for RpcCoreService {
 
         trace!("incoming SubmitBlockRequest for block {}", hash);
         match self.flow_context.submit_rpc_block(&session, block.clone()).await {
-            Ok(_) => Ok(SubmitBlockResponse { report: SubmitBlockReport::Success }),
+            Ok(_) => {
+                self.processing_counters.submit_block_success_count.fetch_add(1, Ordering::Relaxed);
+                Ok(SubmitBlockResponse { report: SubmitBlockReport::Success })
+            }
             Err(ProtocolError::RuleError(RuleError::BadMerkleRoot(h1, h2))) => {
+                // Count the number of bad merkle root errors as this may trigger NoTransactions rule
+                self.processing_counters.submit_block_bad_merkle_root_count.fetch_add(1, Ordering::Relaxed);
                 warn!(
                     "The RPC submitted block triggered a {} error: {}. 
 NOTE: This error usually indicates an RPC conversion error between the node and the miner. If you are on TN11 this is likely to reflect using a NON-SUPPORTED miner.",