CRC: use ms precision for min_block_time config option

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

Author: jferrant

testnet/stacks-node/src/config.rs

@@ -86,7 +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;
+const DEFAULT_MINIMUM_GAP_MS: u64 = 1000;
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct ConfigFile {
@@ -2359,9 +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
+    /// The minimum gap to wait between blocks in milliseconds. The value must be greater than or equal to 1000 ms 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,
+    pub min_block_time_gap_ms: u64,
 }
 
 impl Default for MinerConfig {
@@ -2393,7 +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,
+            min_block_time_gap_ms: DEFAULT_MINIMUM_GAP_MS,
         }
     }
 }
@@ -2744,7 +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>,
+    pub min_block_time_gap_ms: Option<u64>,
 }
 
 impl MinerConfigFile {
@@ -2856,12 +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
+            min_block_time_gap_ms: self.min_block_time_gap_ms.map(|ms| if ms < DEFAULT_MINIMUM_GAP_MS {
+                warn!("miner.min_block_time_gap_ms is less than the minimum allowed value of {DEFAULT_MINIMUM_GAP_MS} ms. Using the default value instead.");
+                DEFAULT_MINIMUM_GAP_MS
             } else {
-                secs
-            }).unwrap_or(miner_default_config.min_block_time_gap_secs),
+                ms
+            }).unwrap_or(miner_default_config.min_block_time_gap_ms),
         })
     }
 }

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

@@ -45,8 +45,8 @@ 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::util::{get_epoch_time_secs, sleep_ms};
 use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
@@ -1051,16 +1051,17 @@ impl BlockMinerThread {
         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
+        let time_since_parent_ms = get_epoch_time_secs()
+            .saturating_sub(parent_block_info.stacks_parent_header.burn_header_timestamp)
+            / 1000;
+        if time_since_parent_ms < self.config.miner.min_block_time_gap_ms {
+            let wait_ms = 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));
+                .min_block_time_gap_ms
+                .saturating_sub(time_since_parent_ms);
+            info!("Waiting {wait_ms} ms before mining a new block.");
+            sleep_ms(wait_ms);
         }
         Ok(())
     }