Merge branch 'develop' into fix/deadlock

Author: obycode

.github/workflows/bitcoin-tests.yml

@@ -93,13 +93,15 @@ jobs:
           - tests::signer::v0::bitcoind_forking_test
           - tests::signer::v0::multiple_miners
           - tests::signer::v0::mock_sign_epoch_25
+          - tests::signer::v0::miner_forking
           - tests::nakamoto_integrations::stack_stx_burn_op_integration_test
           - tests::nakamoto_integrations::check_block_heights
           - tests::nakamoto_integrations::clarity_burn_state
           - tests::nakamoto_integrations::check_block_times
           - tests::nakamoto_integrations::check_block_info
           - tests::nakamoto_integrations::check_block_info_rewards
           - tests::nakamoto_integrations::continue_tenure_extend
+          - tests::nakamoto_integrations::mock_mining
           - tests::nakamoto_integrations::multiple_miners
           # Do not run this one until we figure out why it fails in CI
           # - tests::neon_integrations::bitcoin_reorg_flap

stacks-signer/CHANGELOG.md

@@ -7,3 +7,18 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 
 ## [Unreleased]
 
+## [2.5.0.0.5.1]
+
+### Added
+
+- Adds signerdb schema versioning (#4965)
+- Added voting cli commands `generate-vote` and `verify-vote` (#4934)
+- Add soritiion tracking cache (#4905)
+- Push blocks to signer set and adds `/v3/blocks/upload` (#4902)
+
+### Changed
+
+- Fix an issue of poorly timed tenure and bitcoin blocks (#4956)
+- Process pending blocks before ending tenure (#4952)
+- Update rusqlite/sqlite versions (#4948)
+- return last block sortition in `/v3/sortitions` (#4939)

testnet/stacks-node/src/nakamoto_node/miner.rs

@@ -224,6 +224,35 @@ impl BlockMinerThread {
         // now, actually run this tenure
         loop {
             let new_block = loop {
+                // If we're mock mining, we may not have processed the block that the
+                // actual tenure winner committed to yet. So, before attempting to
+                // mock mine, check if the parent is processed.
+                if self.config.get_node_config(false).mock_mining {
+                    let burn_db_path = self.config.get_burn_db_file_path();
+                    let mut burn_db = SortitionDB::open(
+                        &burn_db_path,
+                        true,
+                        self.burnchain.pox_constants.clone(),
+                    )
+                    .expect("FATAL: could not open sortition DB");
+                    let burn_tip_changed = self.check_burn_tip_changed(&burn_db);
+                    let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
+                        .expect("FATAL: could not open chainstate DB");
+                    match burn_tip_changed
+                        .and_then(|_| self.load_block_parent_info(&mut burn_db, &mut chain_state))
+                    {
+                        Ok(..) => {}
+                        Err(NakamotoNodeError::ParentNotFound) => {
+                            info!("Mock miner has not processed parent block yet, sleeping and trying again");
+                            thread::sleep(Duration::from_millis(ABORT_TRY_AGAIN_MS));
+                            continue;
+                        }
+                        Err(e) => {
+                            warn!("Mock miner failed to load parent info: {e:?}");
+                            return Err(e);
+                        }
+                    }
+                }
                 match self.mine_block(&stackerdbs) {
                     Ok(x) => break Some(x),
                     Err(NakamotoNodeError::MiningFailure(ChainstateError::MinerAborted)) => {
@@ -430,6 +459,11 @@ impl BlockMinerThread {
 
         let miner_privkey_as_scalar = Scalar::from(miner_privkey.as_slice().clone());
         let reward_set = self.load_signer_set()?;
+
+        if self.config.get_node_config(false).mock_mining {
+            return Ok((reward_set, Vec::new()));
+        }
+
         let mut coordinator =
             SignCoordinator::new(&reward_set, miner_privkey_as_scalar, &self.config).map_err(
                 |e| {

testnet/stacks-node/src/nakamoto_node/relayer.rs

@@ -66,11 +66,6 @@ use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::run_loop::RegisteredKey;
 use crate::BitcoinRegtestController;
 
-#[cfg(test)]
-lazy_static::lazy_static! {
-    pub static ref TEST_SKIP_COMMIT_OP: std::sync::Mutex<Option<bool>> = std::sync::Mutex::new(None);
-}
-
 /// Command types for the Nakamoto relayer thread, issued to it by other threads
 pub enum RelayerDirective {
     /// Handle some new data that arrived on the network (such as blocks, transactions, and
@@ -412,7 +407,7 @@ impl RelayerThread {
         }
 
         let directive = if sn.sortition {
-            if won_sortition {
+            if won_sortition || self.config.get_node_config(false).mock_mining {
                 MinerDirective::BeginTenure {
                     parent_tenure_start: committed_index_hash,
                     burnchain_tip: sn,
@@ -794,7 +789,7 @@ impl RelayerThread {
 
     fn continue_tenure(&mut self, new_burn_view: ConsensusHash) -> Result<(), NakamotoNodeError> {
         if let Err(e) = self.stop_tenure() {
-            error!("Relayer: Failed to stop tenure: {:?}", e);
+            error!("Relayer: Failed to stop tenure: {e:?}");
             return Ok(());
         }
         debug!("Relayer: successfully stopped tenure.");
@@ -867,7 +862,7 @@ impl RelayerThread {
                 debug!("Relayer: successfully started new tenure.");
             }
             Err(e) => {
-                error!("Relayer: Failed to start new tenure: {:?}", e);
+                error!("Relayer: Failed to start new tenure: {e:?}");
             }
         }
         Ok(())
@@ -879,13 +874,11 @@ impl RelayerThread {
         burn_hash: BurnchainHeaderHash,
         committed_index_hash: StacksBlockId,
     ) -> bool {
-        let miner_instruction =
-            match self.process_sortition(consensus_hash, burn_hash, committed_index_hash) {
-                Ok(mi) => mi,
-                Err(_) => {
-                    return false;
-                }
-            };
+        let Ok(miner_instruction) =
+            self.process_sortition(consensus_hash, burn_hash, committed_index_hash)
+        else {
+            return false;
+        };
 
         match miner_instruction {
             MinerDirective::BeginTenure {
@@ -901,7 +894,7 @@ impl RelayerThread {
                     debug!("Relayer: successfully started new tenure.");
                 }
                 Err(e) => {
-                    error!("Relayer: Failed to start new tenure: {:?}", e);
+                    error!("Relayer: Failed to start new tenure: {e:?}");
                 }
             },
             MinerDirective::ContinueTenure { new_burn_view } => {
@@ -910,7 +903,7 @@ impl RelayerThread {
                         debug!("Relayer: successfully handled continue tenure.");
                     }
                     Err(e) => {
-                        error!("Relayer: Failed to continue tenure: {:?}", e);
+                        error!("Relayer: Failed to continue tenure: {e:?}");
                         return false;
                     }
                 }
@@ -920,7 +913,7 @@ impl RelayerThread {
                     debug!("Relayer: successfully stopped tenure.");
                 }
                 Err(e) => {
-                    error!("Relayer: Failed to stop tenure: {:?}", e);
+                    error!("Relayer: Failed to stop tenure: {e:?}");
                 }
             },
         }
@@ -937,7 +930,15 @@ impl RelayerThread {
         let mut last_committed = self.make_block_commit(&tip_block_ch, &tip_block_bh)?;
         #[cfg(test)]
         {
-            if TEST_SKIP_COMMIT_OP.lock().unwrap().unwrap_or(false) {
+            if self
+                .globals
+                .counters
+                .naka_skip_commit_op
+                .0
+                .lock()
+                .unwrap()
+                .unwrap_or(false)
+            {
                 warn!("Relayer: not submitting block-commit to bitcoin network due to test directive.");
                 return Ok(());
             }

testnet/stacks-node/src/run_loop/neon.rs

@@ -82,6 +82,17 @@ impl std::ops::Deref for RunLoopCounter {
     }
 }
 
+#[cfg(test)]
+#[derive(Clone)]
+pub struct TestFlag(pub Arc<std::sync::Mutex<Option<bool>>>);
+
+#[cfg(test)]
+impl Default for TestFlag {
+    fn default() -> Self {
+        Self(Arc::new(std::sync::Mutex::new(None)))
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct Counters {
     pub blocks_processed: RunLoopCounter,
@@ -95,6 +106,9 @@ pub struct Counters {
     pub naka_mined_blocks: RunLoopCounter,
     pub naka_proposed_blocks: RunLoopCounter,
     pub naka_mined_tenures: RunLoopCounter,
+
+    #[cfg(test)]
+    pub naka_skip_commit_op: TestFlag,
 }
 
 impl Counters {