Merge branch 'develop' into chore/add-http-traffic-heartbeat-log

Author: Jiloc

.github/workflows/clippy.yml

@@ -7,6 +7,9 @@ name: Clippy Checks
 # Only run when:
 #   - PRs are (re)opened against develop branch
 on:
+  merge_group:
+    types:
+      - checks_requested
   pull_request:
     branches:
       - develop
@@ -34,4 +37,4 @@ jobs:
           components: clippy
       - name: Clippy
         id: clippy
-        run: cargo clippy-stacks
+        run: cargo clippy-stacks

.github/workflows/github-release.yml

@@ -164,8 +164,11 @@ jobs:
   ## Create the downstream PR for the release branch to master,develop
   create-pr:
     if: |
-      inputs.node_tag != '' ||
-      inputs.signer_tag != ''
+      !contains(github.ref, '-rc') &&
+      (
+        inputs.node_tag != '' ||
+        inputs.signer_tag != ''
+      )
     name: Create Downstream PR (${{ github.ref_name }})
     runs-on: ubuntu-latest
     needs:

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - When a miner times out waiting for signatures, it will re-propose the same block instead of building a new block ([#5877](https://github.com/stacks-network/stacks-core/pull/5877))
 - Improve tenure downloader trace verbosity applying proper logging level depending on the tenure state ("debug" if unconfirmed, "info" otherwise) ([#5871](https://github.com/stacks-network/stacks-core/issues/5871))
 - Remove warning log about missing UTXOs when a node is configured as `miner` with `mock_mining` mode enabled ([#5841](https://github.com/stacks-network/stacks-core/issues/5841)) 
+- Deprecated the `wait_on_interim_blocks` option in the miner config file. This option is no longer needed, as the miner will always wait for interim blocks to be processed before mining a new block. To wait extra time in between blocks, use the `min_time_between_blocks_ms` option instead.
 
 ## [3.1.0.0.7]
 

stacks-signer/src/signerdb.rs

@@ -1264,7 +1264,7 @@ impl SignerDb {
         // Plus (ms + 999)/1000 to round up to the nearest second
         let tenure_extend_timestamp = tenure_start_time
             .saturating_add(tenure_idle_timeout_secs)
-            .saturating_add(tenure_process_time_ms.saturating_add(999) / 1000);
+            .saturating_add(tenure_process_time_ms.div_ceil(1000));
         debug!("Calculated tenure extend timestamp";
             "tenure_extend_timestamp" => tenure_extend_timestamp,
             "tenure_start_time" => tenure_start_time,

stackslib/src/config/mod.rs

@@ -2138,7 +2138,8 @@ pub struct MinerConfig {
     pub unprocessed_block_deadline_secs: u64,
     pub mining_key: Option<Secp256k1PrivateKey>,
     /// Amount of time while mining in nakamoto to wait in between mining interim blocks
-    pub wait_on_interim_blocks: Duration,
+    /// DEPRECATED: use `min_time_between_blocks_ms` instead
+    pub wait_on_interim_blocks: Option<Duration>,
     /// minimum number of transactions that must be in a block if we're going to replace a pending
     /// block-commit with a new block-commit
     pub min_tx_count: u64,
@@ -2209,7 +2210,7 @@ impl Default for MinerConfig {
             candidate_retry_cache_size: 1024 * 1024,
             unprocessed_block_deadline_secs: 30,
             mining_key: None,
-            wait_on_interim_blocks: Duration::from_millis(2_500),
+            wait_on_interim_blocks: None,
             min_tx_count: 0,
             only_increase_tx_count: false,
             unconfirmed_commits_helper: None,
@@ -2733,8 +2734,7 @@ impl MinerConfigFile {
                 .transpose()?,
             wait_on_interim_blocks: self
                 .wait_on_interim_blocks_ms
-                .map(Duration::from_millis)
-                .unwrap_or(miner_default_config.wait_on_interim_blocks),
+                .map(Duration::from_millis),
             min_tx_count: self
                 .min_tx_count
                 .unwrap_or(miner_default_config.min_tx_count),
@@ -2789,7 +2789,7 @@ impl MinerConfigFile {
             pre_nakamoto_mock_signing: self
                 .pre_nakamoto_mock_signing
                 .unwrap_or(pre_nakamoto_mock_signing), // Should only default true if mining key is set
-                min_time_between_blocks_ms: self.min_time_between_blocks_ms.map(|ms| if ms < DEFAULT_MIN_TIME_BETWEEN_BLOCKS_MS {
+            min_time_between_blocks_ms: self.min_time_between_blocks_ms.map(|ms| if ms < DEFAULT_MIN_TIME_BETWEEN_BLOCKS_MS {
                 warn!("miner.min_time_between_blocks_ms is less than the minimum allowed value of {DEFAULT_MIN_TIME_BETWEEN_BLOCKS_MS} ms. Using the default value instead.");
                 DEFAULT_MIN_TIME_BETWEEN_BLOCKS_MS
             } else {

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

@@ -643,6 +643,9 @@ impl BlockMinerThread {
                     "block_height" => new_block.header.chain_length,
                     "consensus_hash" => %new_block.header.consensus_hash,
                 );
+
+                // We successfully mined, so the mempool caches are valid.
+                self.reset_nonce_cache = false;
             }
 
             // update mined-block counters and mined-tenure counters
@@ -660,20 +663,35 @@ impl BlockMinerThread {
             self.mined_blocks += 1;
         }
 
-        let Ok(sort_db) = SortitionDB::open(
-            &self.config.get_burn_db_file_path(),
-            true,
-            self.burnchain.pox_constants.clone(),
-        ) else {
-            error!("Failed to open sortition DB. Will try mining again.");
-            return Ok(());
-        };
+        if let Some(last_block_mined) = &self.last_block_mined {
+            // Wait until the last block mined has been processed
+            loop {
+                let (_, processed, _, _) = chain_state
+                    .nakamoto_blocks_db()
+                    .get_block_processed_and_signed_weight(
+                        &last_block_mined.header.consensus_hash,
+                        &last_block_mined.header.block_hash(),
+                    )?
+                    .ok_or_else(|| NakamotoNodeError::UnexpectedChainState)?;
+
+                if processed {
+                    break;
+                }
+
+                thread::sleep(Duration::from_millis(ABORT_TRY_AGAIN_MS));
 
-        let wait_start = Instant::now();
-        while wait_start.elapsed() < self.config.miner.wait_on_interim_blocks {
-            thread::sleep(Duration::from_millis(ABORT_TRY_AGAIN_MS));
-            if self.check_burn_tip_changed(&sort_db).is_err() {
-                return Err(NakamotoNodeError::BurnchainTipChanged);
+                // Check if the burnchain tip has changed
+                let Ok(sort_db) = SortitionDB::open(
+                    &self.config.get_burn_db_file_path(),
+                    false,
+                    self.burnchain.pox_constants.clone(),
+                ) else {
+                    error!("Failed to open sortition DB. Will try mining again.");
+                    return Ok(());
+                };
+                if self.check_burn_tip_changed(&sort_db).is_err() {
+                    return Err(NakamotoNodeError::BurnchainTipChanged);
+                }
             }
         }