Merge branch 'develop' into fix/burn-view

Author: jcnelson

.github/workflows/bitcoin-tests.yml

@@ -54,6 +54,7 @@ jobs:
           # - tests::neon_integrations::size_overflow_unconfirmed_microblocks_integration_test
           # - tests::neon_integrations::size_overflow_unconfirmed_stream_microblocks_integration_test
           # - tests::neon_integrations::runtime_overflow_unconfirmed_microblocks_integration_test
+          # - tests::epoch_25::microblocks_disabled
           # Disable this flaky test. Microblocks are no longer supported anyways.
           # - tests::neon_integrations::microblock_large_tx_integration_test_FLAKY
           - tests::neon_integrations::miner_submit_twice
@@ -80,7 +81,6 @@ jobs:
           - tests::neon_integrations::bitcoin_reorg_flap
           - tests::neon_integrations::bitcoin_reorg_flap_with_follower
           - tests::neon_integrations::start_stop_bitcoind
-          - tests::epoch_25::microblocks_disabled
           - tests::should_succeed_handling_malformed_and_valid_txs
           - tests::nakamoto_integrations::simple_neon_integration
           - tests::nakamoto_integrations::flash_blocks_on_epoch_3
@@ -145,6 +145,8 @@ jobs:
           - tests::signer::v0::fast_sortition
           - tests::signer::v0::single_miner_empty_sortition
           - tests::signer::v0::multiple_miners_empty_sortition
+          - tests::signer::v0::block_proposal_timeout
+          - tests::signer::v0::rejected_blocks_count_towards_miner_validity
           - tests::nakamoto_integrations::burn_ops_integration_test
           - tests::nakamoto_integrations::check_block_heights
           - tests::nakamoto_integrations::clarity_burn_state

stacks-signer/src/chainstate.rs

@@ -89,10 +89,8 @@ impl SortitionState {
         if self.miner_status != SortitionMinerStatus::Valid {
             return Ok(false);
         }
-        // if we've already signed a block in this tenure, the miner can't have timed out.
-        let has_blocks = signer_db
-            .get_last_signed_block_in_tenure(&self.consensus_hash)?
-            .is_some();
+        // if we've already seen a proposed block from this miner. It cannot have timed out.
+        let has_blocks = signer_db.has_proposed_block_in_tenure(&self.consensus_hash)?;
         if has_blocks {
             return Ok(false);
         }

stacks-signer/src/config.rs

@@ -39,7 +39,7 @@ const BLOCK_PROPOSAL_TIMEOUT_MS: u64 = 600_000;
 const BLOCK_PROPOSAL_VALIDATION_TIMEOUT_MS: u64 = 120_000;
 const DEFAULT_FIRST_PROPOSAL_BURN_BLOCK_TIMING_SECS: u64 = 60;
 const DEFAULT_TENURE_LAST_BLOCK_PROPOSAL_TIMEOUT_SECS: u64 = 30;
-const TENURE_IDLE_TIMEOUT_SECS: u64 = 300;
+const TENURE_IDLE_TIMEOUT_SECS: u64 = 120;
 
 #[derive(thiserror::Error, Debug)]
 /// An error occurred parsing the provided configuration

stacks-signer/src/signerdb.rs

@@ -746,15 +746,13 @@ impl SignerDb {
         try_deserialize(result)
     }
 
-    /// Return the last signed block in a tenure (identified by its consensus hash)
-    pub fn get_last_signed_block_in_tenure(
-        &self,
-        tenure: &ConsensusHash,
-    ) -> Result<Option<BlockInfo>, DBError> {
-        let query = "SELECT block_info FROM blocks WHERE consensus_hash = ? AND signed_over = 1 ORDER BY stacks_height DESC LIMIT 1";
+    /// Return whether a block proposal has been stored for a tenure (identified by its consensus hash)
+    /// Does not consider the block's state.
+    pub fn has_proposed_block_in_tenure(&self, tenure: &ConsensusHash) -> Result<bool, DBError> {
+        let query = "SELECT block_info FROM blocks WHERE consensus_hash = ? LIMIT 1";
         let result: Option<String> = query_row(&self.db, query, [tenure])?;
 
-        try_deserialize(result)
+        Ok(result.is_some())
     }
 
     /// Return the first signed block in a tenure (identified by its consensus hash)
@@ -1904,4 +1902,28 @@ mod tests {
         let pendings = db.get_all_pending_block_validations().unwrap();
         assert_eq!(pendings.len(), 0);
     }
+
+    #[test]
+    fn has_proposed_block() {
+        let db_path = tmp_db_path();
+        let consensus_hash_1 = ConsensusHash([0x01; 20]);
+        let consensus_hash_2 = ConsensusHash([0x02; 20]);
+        let mut db = SignerDb::new(db_path).expect("Failed to create signer db");
+        let (mut block_info, _) = create_block_override(|b| {
+            b.block.header.consensus_hash = consensus_hash_1;
+            b.block.header.chain_length = 1;
+        });
+
+        assert!(!db.has_proposed_block_in_tenure(&consensus_hash_1).unwrap());
+        assert!(!db.has_proposed_block_in_tenure(&consensus_hash_2).unwrap());
+
+        db.insert_block(&block_info).unwrap();
+
+        block_info.block.header.chain_length = 2;
+
+        db.insert_block(&block_info).unwrap();
+
+        assert!(db.has_proposed_block_in_tenure(&consensus_hash_1).unwrap());
+        assert!(!db.has_proposed_block_in_tenure(&consensus_hash_2).unwrap());
+    }
 }

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

@@ -59,10 +59,11 @@ use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
 use crate::neon_node;
 use crate::run_loop::nakamoto::Globals;
 use crate::run_loop::RegisteredKey;
-
 #[cfg(test)]
+/// Test flag to stall the miner thread
 pub static TEST_MINE_STALL: LazyLock<TestFlag<bool>> = LazyLock::new(TestFlag::default);
 #[cfg(test)]
+/// Test flag to stall block proposal broadcasting
 pub static TEST_BROADCAST_STALL: LazyLock<TestFlag<bool>> = LazyLock::new(TestFlag::default);
 #[cfg(test)]
 pub static TEST_BLOCK_ANNOUNCE_STALL: LazyLock<TestFlag<bool>> = LazyLock::new(TestFlag::default);
@@ -239,6 +240,10 @@ impl BlockMinerThread {
         }
     }
 
+    pub fn get_abort_flag(&self) -> Arc<AtomicBool> {
+        self.abort_flag.clone()
+    }
+
     #[cfg(test)]
     fn fault_injection_block_broadcast_stall(new_block: &NakamotoBlock) {
         if TEST_BROADCAST_STALL.get() {

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

@@ -1099,7 +1099,7 @@ impl RelayerThread {
             reason,
             burn_tip_at_start,
         )?;
-        let miner_abort_flag = new_miner_state.abort_flag.clone();
+        let miner_abort_flag = new_miner_state.get_abort_flag();
 
         debug!("Relayer: starting new tenure thread");
 

testnet/stacks-node/src/tests/nakamoto_integrations.rs

@@ -5030,6 +5030,7 @@ fn forked_tenure_is_ignored() {
     // Stall the miner thread; only wait until the number of submitted commits increases.
     TEST_BROADCAST_STALL.set(true);
     TEST_BLOCK_ANNOUNCE_STALL.set(true);
+
     let blocks_before = mined_blocks.load(Ordering::SeqCst);
     let commits_before = commits_submitted.load(Ordering::SeqCst);