Merge pull request #5093 from stacks-network/feat/more-multi-miner-fixes-jude

Feat/more multi miner fixes jude

Author: kantai

.github/workflows/bitcoin-tests.yml

@@ -110,6 +110,7 @@ jobs:
           - tests::nakamoto_integrations::continue_tenure_extend
           - tests::nakamoto_integrations::mock_mining
           - tests::nakamoto_integrations::multiple_miners
+          - tests::nakamoto_integrations::follower_bootup_across_multiple_cycles
           - tests::nakamoto_integrations::utxo_check_on_startup_panic
           - tests::nakamoto_integrations::utxo_check_on_startup_recover
           - tests::signer::v0::multiple_miners_with_nakamoto_blocks

libstackerdb/src/libstackerdb.rs

@@ -82,7 +82,7 @@ pub struct SlotMetadata {
 }
 
 /// Stacker DB chunk (i.e. as a reply to a chunk request)
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, PartialEq, Serialize, Deserialize)]
 pub struct StackerDBChunkData {
     /// slot ID
     pub slot_id: u32,
@@ -98,6 +98,31 @@ pub struct StackerDBChunkData {
     pub data: Vec<u8>,
 }
 
+impl fmt::Debug for StackerDBChunkData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.data.len() < 128 {
+            write!(
+                f,
+                "StackerDBChunkData({},{},{},{})",
+                self.slot_id,
+                self.slot_version,
+                &self.sig,
+                &to_hex(&self.data)
+            )
+        } else {
+            write!(
+                f,
+                "StackerDBChunkData({},{},{},{}...({}))",
+                self.slot_id,
+                self.slot_version,
+                &self.sig,
+                &to_hex(&self.data[..128]),
+                self.data.len()
+            )
+        }
+    }
+}
+
 /// StackerDB post chunk acknowledgement
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct StackerDBChunkAckData {

stackslib/src/burnchains/db.rs

@@ -1411,6 +1411,8 @@ impl BurnchainDB {
         Ok(())
     }
 
+    /// Stores a newly-parsed burnchain block's relevant data into the DB.
+    /// The given block's operations will be validated.
     pub fn store_new_burnchain_block<B: BurnchainHeaderReader>(
         &mut self,
         burnchain: &Burnchain,

stackslib/src/chainstate/burn/db/processing.rs

@@ -211,7 +211,7 @@ impl<'a> SortitionHandleTx<'a> {
             "SORTITION-HASH({}): {}",
             this_block_height, &snapshot.sortition_hash
         );
-        debug!(
+        info!(
             "CONSENSUS({}): {}",
             this_block_height, &snapshot.consensus_hash
         );

stackslib/src/chainstate/burn/db/sortdb.rs

@@ -3456,6 +3456,14 @@ impl SortitionDB {
                         SortitionDB::apply_schema_9(&tx.deref(), epochs)?;
                         tx.commit()?;
                     } else if version == expected_version {
+                        // this transaction is almost never needed
+                        let validated_epochs = StacksEpoch::validate_epochs(epochs);
+                        let existing_epochs = Self::get_stacks_epochs(self.conn())?;
+                        if existing_epochs == validated_epochs {
+                            return Ok(());
+                        }
+
+                        // epochs are out of date
                         let tx = self.tx_begin()?;
                         SortitionDB::validate_and_replace_epochs(&tx, epochs)?;
                         tx.commit()?;

stackslib/src/chainstate/coordinator/mod.rs

@@ -543,20 +543,24 @@ impl<
             in_nakamoto_epoch: false,
         };
 
-        let mut nakamoto_available = false;
         loop {
-            if nakamoto_available
-                || inst
-                    .can_process_nakamoto()
-                    .expect("FATAL: could not determine if Nakamoto is available")
-            {
-                // short-circuit to avoid gratuitous I/O
-                nakamoto_available = true;
-                if !inst.handle_comms_nakamoto(&comms, miner_status.clone()) {
+            let bits = comms.wait_on();
+            if inst.in_subsequent_nakamoto_reward_cycle() {
+                debug!("Coordinator: in subsequent Nakamoto reward cycle");
+                if !inst.handle_comms_nakamoto(bits, miner_status.clone()) {
+                    return;
+                }
+            } else if inst.in_first_nakamoto_reward_cycle() {
+                debug!("Coordinator: in first Nakamoto reward cycle");
+                if !inst.handle_comms_nakamoto(bits, miner_status.clone()) {
+                    return;
+                }
+                if !inst.handle_comms_epoch2(bits, miner_status.clone()) {
                     return;
                 }
             } else {
-                if !inst.handle_comms_epoch2(&comms, miner_status.clone()) {
+                debug!("Coordinator: in epoch2 reward cycle");
+                if !inst.handle_comms_epoch2(bits, miner_status.clone()) {
                     return;
                 }
             }
@@ -566,13 +570,8 @@ impl<
     /// This is the Stacks 2.x coordinator loop body, which handles communications
     /// from the given `comms`.  It returns `true` if the coordinator is still running, and `false`
     /// if not.
-    pub fn handle_comms_epoch2(
-        &mut self,
-        comms: &CoordinatorReceivers,
-        miner_status: Arc<Mutex<MinerStatus>>,
-    ) -> bool {
+    pub fn handle_comms_epoch2(&mut self, bits: u8, miner_status: Arc<Mutex<MinerStatus>>) -> bool {
         // timeout so that we handle Ctrl-C a little gracefully
-        let bits = comms.wait_on();
         if (bits & (CoordinatorEvents::NEW_STACKS_BLOCK as u8)) != 0 {
             signal_mining_blocked(miner_status.clone());
             debug!("Received new stacks block notice");

stackslib/src/chainstate/nakamoto/coordinator/mod.rs

@@ -614,85 +614,68 @@ impl<
         B: BurnchainHeaderReader,
     > ChainsCoordinator<'a, T, N, U, CE, FE, B>
 {
-    /// Check to see if we're in the last of the 2.x epochs, and we have the first PoX anchor block
-    /// for epoch 3.
-    /// NOTE: the first block in epoch3 must be after the first block in the reward phase, so as
-    /// to ensure that the PoX stackers have been selected for this cycle.  This means that we
-    /// don't proceed to process Nakamoto blocks until the reward cycle has begun.  Also, the last
-    /// reward cycle of epoch2 _must_ be PoX so we have stackers who can sign.
-    pub fn can_process_nakamoto(&mut self) -> Result<bool, Error> {
-        let canonical_sortition_tip = self
-            .canonical_sortition_tip
-            .clone()
-            .expect("FAIL: checking epoch status, but we don't have a canonical sortition tip");
-
-        let canonical_sn =
-            SortitionDB::get_block_snapshot(self.sortition_db.conn(), &canonical_sortition_tip)?
-                .expect("FATAL: canonical sortition tip has no sortition");
-
-        // what epoch are we in?
-        let cur_epoch =
-            SortitionDB::get_stacks_epoch(self.sortition_db.conn(), canonical_sn.block_height)?
-                .unwrap_or_else(|| {
-                    panic!(
-                        "BUG: no epoch defined at height {}",
-                        canonical_sn.block_height
-                    )
-                });
-
-        if cur_epoch.epoch_id < StacksEpochId::Epoch30 {
-            return Ok(false);
-        }
+    /// Get the first nakamoto reward cycle
+    fn get_first_nakamoto_reward_cycle(&self) -> u64 {
+        let all_epochs = SortitionDB::get_stacks_epochs(self.sortition_db.conn())
+            .unwrap_or_else(|e| panic!("FATAL: failed to query sortition DB for epochs: {:?}", &e));
 
-        // in epoch3
-        let all_epochs = SortitionDB::get_stacks_epochs(self.sortition_db.conn())?;
-        let epoch_3_idx = StacksEpoch::find_epoch_by_id(&all_epochs, StacksEpochId::Epoch30)
-            .expect("FATAL: epoch3 not defined");
+        let Some(epoch_3_idx) = StacksEpoch::find_epoch_by_id(&all_epochs, StacksEpochId::Epoch30)
+        else {
+            // this is only reachable in tests
+            if cfg!(any(test, feature = "testing")) {
+                return u64::MAX;
+            } else {
+                panic!("FATAL: epoch3 not defined");
+            }
+        };
 
         let epoch3 = &all_epochs[epoch_3_idx];
         let first_epoch3_reward_cycle = self
             .burnchain
             .block_height_to_reward_cycle(epoch3.start_height)
             .expect("FATAL: epoch3 block height has no reward cycle");
 
-        // NOTE(safety): this is not guaranteed to be the canonical best Stacks tip.
-        // However, it's safe to use here because we're only interested in loading up the first
-        // Nakamoto reward set, which uses the epoch2 anchor block selection algorithm.  There will
-        // only be one such reward set in epoch2 rules, since it's tied to a specific block-commit
-        // (note that this is not true for reward sets generated in Nakamoto prepare phases).
-        let (local_best_stacks_ch, local_best_stacks_bhh) =
-            SortitionDB::get_canonical_stacks_chain_tip_hash(self.sortition_db.conn())?;
-        let local_best_stacks_tip =
-            StacksBlockId::new(&local_best_stacks_ch, &local_best_stacks_bhh);
-
-        // only proceed if we have processed the _anchor block_ for this reward cycle.
-        let Some((rc_info, _)) = load_nakamoto_reward_set(
-            self.burnchain
-                .block_height_to_reward_cycle(canonical_sn.block_height)
-                .expect("FATAL: snapshot has no reward cycle"),
-            &canonical_sn.sortition_id,
-            &self.burnchain,
-            &mut self.chain_state_db,
-            &local_best_stacks_tip,
-            &self.sortition_db,
-            &OnChainRewardSetProvider::new(),
-        )?
-        else {
-            return Ok(false);
-        };
-        Ok(rc_info.reward_cycle >= first_epoch3_reward_cycle)
+        first_epoch3_reward_cycle
+    }
+
+    /// Get the current reward cycle
+    fn get_current_reward_cycle(&self) -> u64 {
+        let canonical_sortition_tip = self.canonical_sortition_tip.clone().unwrap_or_else(|| {
+            panic!("FAIL: checking epoch status, but we don't have a canonical sortition tip")
+        });
+
+        let canonical_sn =
+            SortitionDB::get_block_snapshot(self.sortition_db.conn(), &canonical_sortition_tip)
+                .unwrap_or_else(|e| panic!("FATAL: failed to query sortition DB: {:?}", &e))
+                .unwrap_or_else(|| panic!("FATAL: canonical sortition tip has no sortition"));
+
+        let cur_reward_cycle = self
+            .burnchain
+            .block_height_to_reward_cycle(canonical_sn.block_height)
+            .expect("FATAL: snapshot has no reward cycle");
+
+        cur_reward_cycle
+    }
+
+    /// Are we in the first-ever Nakamoto reward cycle?
+    pub fn in_first_nakamoto_reward_cycle(&self) -> bool {
+        self.get_current_reward_cycle() == self.get_first_nakamoto_reward_cycle()
+    }
+
+    /// Are we in the second or later Nakamoto reward cycle?
+    pub fn in_subsequent_nakamoto_reward_cycle(&self) -> bool {
+        self.get_current_reward_cycle() > self.get_first_nakamoto_reward_cycle()
     }
 
     /// This is the main loop body for the coordinator in epoch 3.
     /// Returns true if the coordinator is still running.
     /// Returns false otherwise.
     pub fn handle_comms_nakamoto(
         &mut self,
-        comms: &CoordinatorReceivers,
+        bits: u8,
         miner_status: Arc<Mutex<MinerStatus>>,
     ) -> bool {
         // timeout so that we handle Ctrl-C a little gracefully
-        let bits = comms.wait_on();
         if (bits & (CoordinatorEvents::NEW_STACKS_BLOCK as u8)) != 0 {
             signal_mining_blocked(miner_status.clone());
             debug!("Received new Nakamoto stacks block notice");

stackslib/src/chainstate/nakamoto/coordinator/tests.rs

@@ -65,7 +65,7 @@ use crate::chainstate::stacks::{
 };
 use crate::clarity::vm::types::StacksAddressExtensions;
 use crate::core::StacksEpochExtension;
-use crate::net::relay::Relayer;
+use crate::net::relay::{BlockAcceptResponse, Relayer};
 use crate::net::stackerdb::StackerDBConfig;
 use crate::net::test::{TestEventObserver, TestPeer, TestPeerConfig};
 use crate::net::tests::NakamotoBootPlan;
@@ -338,8 +338,10 @@ fn replay_reward_cycle(
             None,
             NakamotoBlockObtainMethod::Pushed,
         )
-        .unwrap_or(false);
-        if accepted {
+        .unwrap_or(BlockAcceptResponse::Rejected(
+            "encountered error on acceptance".into(),
+        ));
+        if accepted.is_accepted() {
             test_debug!("Accepted Nakamoto block {block_id}");
             peer.coord.handle_new_nakamoto_stacks_block().unwrap();
         } else {

stackslib/src/chainstate/nakamoto/mod.rs

@@ -2064,6 +2064,12 @@ impl NakamotoChainState {
                 panic!()
             });
 
+        info!(
+            "Advanced to new tip! {}/{}",
+            &receipt.header.consensus_hash,
+            &receipt.header.anchored_header.block_hash()
+        );
+
         // announce the block, if we're connected to an event dispatcher
         if let Some(dispatcher) = dispatcher_opt {
             let block_event = (
@@ -2296,7 +2302,14 @@ impl NakamotoChainState {
                    "signing_weight" => signing_weight);
             true
         } else {
-            debug!("Will not store alternative copy of block {} ({}) with block hash {}, since it has less signing power", &block_id, &block.header.consensus_hash, &block_hash);
+            if existing_signing_weight > signing_weight {
+                debug!("Will not store alternative copy of block {} ({}) with block hash {}, since it has less signing power", &block_id, &block.header.consensus_hash, &block_hash);
+            } else {
+                debug!(
+                    "Will not store duplicate copy of block {} ({}) with block hash {}",
+                    &block_id, &block.header.consensus_hash, &block_hash
+                );
+            }
             false
         };
 
@@ -3022,7 +3035,6 @@ impl NakamotoChainState {
         );
 
         let parent_hash = new_tip.parent_block_id.clone();
-        let new_block_hash = new_tip.block_hash();
         let index_block_hash = new_tip.block_id();
 
         let mut marf_keys = vec![];
@@ -3214,10 +3226,6 @@ impl NakamotoChainState {
             headers_tx.deref_mut().execute(sql, args)?;
         }
 
-        debug!(
-            "Advanced to new tip! {}/{}",
-            &new_tip.consensus_hash, new_block_hash,
-        );
         Ok(new_tip_info)
     }
 

stackslib/src/chainstate/nakamoto/tests/node.rs

@@ -70,7 +70,7 @@ use crate::chainstate::stacks::{
 use crate::core::{BOOT_BLOCK_HASH, STACKS_EPOCH_3_0_MARKER};
 use crate::cost_estimates::metrics::UnitMetric;
 use crate::cost_estimates::UnitEstimator;
-use crate::net::relay::Relayer;
+use crate::net::relay::{BlockAcceptResponse, Relayer};
 use crate::net::test::{TestPeer, TestPeerConfig, *};
 use crate::util_lib::boot::boot_code_addr;
 use crate::util_lib::db::Error as db_error;
@@ -822,9 +822,9 @@ impl TestStacksNode {
                         }
                     }
                 } else {
-                    false
+                    BlockAcceptResponse::Rejected("try_to_process is false".into())
                 };
-                if accepted {
+                if accepted.is_accepted() {
                     test_debug!("Accepted Nakamoto block {}", &block_to_store.block_id());
                     coord.handle_new_nakamoto_stacks_block().unwrap();
                     processed_blocks.push(block_to_store.clone());
@@ -1247,7 +1247,7 @@ impl<'a> TestPeer<'a> {
             None,
             NakamotoBlockObtainMethod::Pushed,
         )?;
-        if !accepted {
+        if !accepted.is_accepted() {
             return Ok(false);
         }
         let sort_tip = SortitionDB::get_canonical_sortition_tip(self.sortdb().conn()).unwrap();
@@ -1491,7 +1491,7 @@ impl<'a> TestPeer<'a> {
                 NakamotoBlockObtainMethod::Pushed,
             )
             .unwrap();
-            if accepted {
+            if accepted.is_accepted() {
                 test_debug!("Accepted Nakamoto block {}", &block_id);
                 self.coord.handle_new_nakamoto_stacks_block().unwrap();