Add a config option and wait a minimum number of seconds between mining blocks to prevent signers rejecting a block with same timestamp as its parent

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

testnet/stacks-node/src/config.rs

@@ -86,6 +86,7 @@ pub const OP_TX_ANY_ESTIM_SIZE: u64 = fmax!(
 const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x
 const DEFAULT_RBF_FEE_RATE_INCREMENT: u64 = 5;
 const INV_REWARD_CYCLES_TESTNET: u64 = 6;
+const DEFAULT_MINIMUM_GAP_SECS: u64 = 1;
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct ConfigFile {
@@ -2358,6 +2359,9 @@ pub struct MinerConfig {
     pub wait_on_signers: Duration,
     /// Whether to mock sign in Epoch 2.5 through the .miners and .signers contracts. This is used for testing purposes in Epoch 2.5 only.
     pub pre_nakamoto_mock_signing: bool,
+    /// The minimum gap to wait between blocks in seconds. The value must be greater than or equal to 1 second because if a block is mined
+    /// within the same second as its parent, it will be rejected by the signers.
+    pub min_block_time_gap_secs: u64,
 }
 
 impl Default for MinerConfig {
@@ -2389,6 +2393,7 @@ impl Default for MinerConfig {
             // TODO: update to a sane value based on stackerdb benchmarking
             wait_on_signers: Duration::from_secs(200),
             pre_nakamoto_mock_signing: false, // Should only default true if mining key is set
+            min_block_time_gap_secs: DEFAULT_MINIMUM_GAP_SECS,
         }
     }
 }
@@ -2739,6 +2744,7 @@ pub struct MinerConfigFile {
     pub max_reorg_depth: Option<u64>,
     pub wait_on_signers_ms: Option<u64>,
     pub pre_nakamoto_mock_signing: Option<bool>,
+    pub min_block_time_gap_secs: Option<u64>,
 }
 
 impl MinerConfigFile {
@@ -2850,6 +2856,12 @@ 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_block_time_gap_secs: self.min_block_time_gap_secs.map(|secs| if secs < DEFAULT_MINIMUM_GAP_SECS {
+                warn!("miner.min_block_time_gap_secs is less than the minimum allowed value of {DEFAULT_MINIMUM_GAP_SECS} secs. Using the default value instead.");
+                DEFAULT_MINIMUM_GAP_SECS
+            } else {
+                secs
+            }).unwrap_or(miner_default_config.min_block_time_gap_secs),
         })
     }
 }

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

@@ -45,6 +45,7 @@ use stacks::chainstate::stacks::{
 use stacks::net::p2p::NetworkHandle;
 use stacks::net::stackerdb::StackerDBs;
 use stacks::net::{NakamotoBlocksData, StacksMessageType};
+use stacks::util::get_epoch_time_secs;
 use stacks::util::secp256k1::MessageSignature;
 use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
@@ -317,6 +318,8 @@ impl BlockMinerThread {
                         }
                     }
                 }
+                self.wait_min_time_between_blocks()?;
+
                 match self.mine_block(&stackerdbs) {
                     Ok(x) => break Some(x),
                     Err(NakamotoNodeError::MiningFailure(ChainstateError::MinerAborted)) => {
@@ -1037,6 +1040,31 @@ impl BlockMinerThread {
         Some(vrf_proof)
     }
 
+    /// Wait the minimum time between blocks before mining a new block (if necessary)
+    /// This is to ensure that the signers do not reject the block due to the block being mined within the same second as the parent block.
+    fn wait_min_time_between_blocks(&self) -> Result<(), NakamotoNodeError> {
+        let burn_db_path = self.config.get_burn_db_file_path();
+        let mut burn_db =
+            SortitionDB::open(&burn_db_path, false, self.burnchain.pox_constants.clone())
+                .expect("FATAL: could not open sortition DB");
+
+        let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
+            .expect("FATAL: could not open chainstate DB");
+        let parent_block_info = self.load_block_parent_info(&mut burn_db, &mut chain_state)?;
+        let time_since_parent_secs = get_epoch_time_secs()
+            .saturating_sub(parent_block_info.stacks_parent_header.burn_header_timestamp);
+        if time_since_parent_secs < self.config.miner.min_block_time_gap_secs {
+            let wait_secs = self
+                .config
+                .miner
+                .min_block_time_gap_secs
+                .saturating_sub(time_since_parent_secs);
+            info!("Waiting {wait_secs} seconds before mining a new block.");
+            std::thread::sleep(Duration::from_secs(wait_secs));
+        }
+        Ok(())
+    }
+
     // TODO: add tests from mutation testing results #4869
     #[cfg_attr(test, mutants::skip)]
     /// Try to mine a Stacks block by assembling one from mempool transactions and sending a