Merge pull request #5805 from stacks-network/feat/miner-continues-tenure-if-tenure-empty

Issue tenure extend if incoming miner fails to mine

Author: jferrant

CHANGELOG.md

@@ -28,12 +28,14 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 ### Added
 
 - Add miner configuration option `tenure_extend_cost_threshold` to specify the percentage of the tenure budget that must be spent before a time-based tenure extend is attempted
+- Add miner configuration option `tenure_extend_wait_timeout_ms` to specify the time to wait before trying to continue a tenure because the next miner did not produce blocks
 
 ### Changed
 
 - Miner will include other transactions in blocks with tenure extend transactions (#5760)
 - Add `block_rejection_timeout_steps` to miner configuration for defining rejections-based timeouts while waiting for signers response (#5705)
 - Miner will not issue a tenure extend until at least half of the block budget has been spent (#5757)
+- Miner will issue a tenure extend if the incoming miner has failed to produce a block (#5729)
 
 ### Fixed
 

stacks-signer/CHANGELOG.md

@@ -27,6 +27,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
   `StackerDB` messages, it logs `INFO` messages. Other interactions with the `stacks-node`
   behave normally (e.g., submitting validation requests, submitting finished blocks). A
   dry run signer will error out if the supplied key is actually a registered signer.
+- Reduce default value of `block_proposal_timeout_ms` to 120_000
 
 ## [3.1.0.0.4.0]
 

stacks-signer/src/config.rs

@@ -35,7 +35,7 @@ use stacks_common::util::hash::Hash160;
 use crate::client::SignerSlotID;
 
 const EVENT_TIMEOUT_MS: u64 = 5000;
-const BLOCK_PROPOSAL_TIMEOUT_MS: u64 = 14_400_000;
+const BLOCK_PROPOSAL_TIMEOUT_MS: u64 = 120_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;

stackslib/src/config/mod.rs

@@ -114,6 +114,8 @@ const DEFAULT_TENURE_COST_LIMIT_PER_BLOCK_PERCENTAGE: u8 = 25;
 /// see if we need to extend the ongoing tenure (e.g. because the current
 /// sortition is empty or invalid).
 const DEFAULT_TENURE_EXTEND_POLL_SECS: u64 = 1;
+/// Default number of millis to wait before trying to continue a tenure because the next miner did not produce blocks
+const DEFAULT_TENURE_EXTEND_WAIT_MS: u64 = 120_000;
 /// Default duration to wait before attempting to issue a tenure extend.
 /// This should be greater than the signers' timeout. This is used for issuing
 /// fallback tenure extends
@@ -2162,9 +2164,11 @@ pub struct MinerConfig {
     pub block_commit_delay: Duration,
     /// The percentage of the remaining tenure cost limit to consume each block.
     pub tenure_cost_limit_per_block_percentage: Option<u8>,
-    /// The number of seconds to wait in-between polling the sortition DB to see if we need to
+    /// Duration to wait in-between polling the sortition DB to see if we need to
     /// extend the ongoing tenure (e.g. because the current sortition is empty or invalid).
-    pub tenure_extend_poll_secs: Duration,
+    pub tenure_extend_poll_timeout: Duration,
+    /// Duration to wait before trying to continue a tenure because the next miner did not produce blocks
+    pub tenure_extend_wait_timeout: Duration,
     /// Duration to wait before attempting to issue a tenure extend
     pub tenure_timeout: Duration,
     /// Percentage of block budget that must be used before attempting a time-based tenure extend
@@ -2207,7 +2211,8 @@ impl Default for MinerConfig {
             tenure_cost_limit_per_block_percentage: Some(
                 DEFAULT_TENURE_COST_LIMIT_PER_BLOCK_PERCENTAGE,
             ),
-            tenure_extend_poll_secs: Duration::from_secs(DEFAULT_TENURE_EXTEND_POLL_SECS),
+            tenure_extend_poll_timeout: Duration::from_secs(DEFAULT_TENURE_EXTEND_POLL_SECS),
+            tenure_extend_wait_timeout: Duration::from_millis(DEFAULT_TENURE_EXTEND_WAIT_MS),
             tenure_timeout: Duration::from_secs(DEFAULT_TENURE_TIMEOUT_SECS),
             tenure_extend_cost_threshold: DEFAULT_TENURE_EXTEND_COST_THRESHOLD,
 
@@ -2614,6 +2619,7 @@ pub struct MinerConfigFile {
     pub block_commit_delay_ms: Option<u64>,
     pub tenure_cost_limit_per_block_percentage: Option<u8>,
     pub tenure_extend_poll_secs: Option<u64>,
+    pub tenure_extend_wait_timeout_ms: Option<u64>,
     pub tenure_timeout_secs: Option<u64>,
     pub tenure_extend_cost_threshold: Option<u64>,
     pub block_rejection_timeout_steps: Option<HashMap<String, u64>>,
@@ -2757,7 +2763,8 @@ impl MinerConfigFile {
             subsequent_rejection_pause_ms: self.subsequent_rejection_pause_ms.unwrap_or(miner_default_config.subsequent_rejection_pause_ms),
             block_commit_delay: self.block_commit_delay_ms.map(Duration::from_millis).unwrap_or(miner_default_config.block_commit_delay),
             tenure_cost_limit_per_block_percentage,
-            tenure_extend_poll_secs: self.tenure_extend_poll_secs.map(Duration::from_secs).unwrap_or(miner_default_config.tenure_extend_poll_secs),
+            tenure_extend_poll_timeout: self.tenure_extend_poll_secs.map(Duration::from_secs).unwrap_or(miner_default_config.tenure_extend_poll_timeout),
+            tenure_extend_wait_timeout: self.tenure_extend_wait_timeout_ms.map(Duration::from_millis).unwrap_or(miner_default_config.tenure_extend_wait_timeout),
             tenure_timeout: self.tenure_timeout_secs.map(Duration::from_secs).unwrap_or(miner_default_config.tenure_timeout),
             tenure_extend_cost_threshold: self.tenure_extend_cost_threshold.unwrap_or(miner_default_config.tenure_extend_cost_threshold),
 

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

@@ -47,7 +47,11 @@ use stacks::net::stackerdb::StackerDBs;
 use stacks::net::{NakamotoBlocksData, StacksMessageType};
 use stacks::util::get_epoch_time_secs;
 use stacks::util::secp256k1::MessageSignature;
+#[cfg(test)]
+use stacks::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
+#[cfg(test)]
+use stacks_common::types::PublicKey;
 use stacks_common::types::{PrivateKey, StacksEpochId};
 #[cfg(test)]
 use stacks_common::util::tests::TestFlag;
@@ -64,8 +68,8 @@ use crate::run_loop::RegisteredKey;
 /// 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_PROPOSAL_STALL: LazyLock<TestFlag<bool>> =
+/// Test flag to stall block proposal broadcasting for the specified miner keys
+pub static TEST_BROADCAST_PROPOSAL_STALL: LazyLock<TestFlag<Vec<Secp256k1PublicKey>>> =
     LazyLock::new(TestFlag::default);
 #[cfg(test)]
 // Test flag to stall the miner from announcing a block while this flag is true
@@ -262,21 +266,32 @@ impl BlockMinerThread {
 
     #[cfg(test)]
     fn fault_injection_block_proposal_stall(new_block: &NakamotoBlock) {
-        if TEST_BROADCAST_PROPOSAL_STALL.get() {
-            // Do an extra check just so we don't log EVERY time.
+        if TEST_BROADCAST_PROPOSAL_STALL.get().iter().any(|key| {
+            key.verify(
+                new_block.header.miner_signature_hash().as_bytes(),
+                &new_block.header.miner_signature,
+            )
+            .unwrap_or_default()
+        }) {
             warn!("Fault injection: Block proposal broadcast is stalled due to testing directive.";
-                      "stacks_block_id" => %new_block.block_id(),
-                      "stacks_block_hash" => %new_block.header.block_hash(),
-                      "height" => new_block.header.chain_length,
-                      "consensus_hash" => %new_block.header.consensus_hash
+                        "stacks_block_id" => %new_block.block_id(),
+                        "stacks_block_hash" => %new_block.header.block_hash(),
+                        "height" => new_block.header.chain_length,
+                        "consensus_hash" => %new_block.header.consensus_hash
             );
-            while TEST_BROADCAST_PROPOSAL_STALL.get() {
+            while TEST_BROADCAST_PROPOSAL_STALL.get().iter().any(|key| {
+                key.verify(
+                    new_block.header.miner_signature_hash().as_bytes(),
+                    &new_block.header.miner_signature,
+                )
+                .unwrap_or_default()
+            }) {
                 std::thread::sleep(std::time::Duration::from_millis(10));
             }
             info!("Fault injection: Block proposal broadcast is no longer stalled due to testing directive.";
-                  "block_id" => %new_block.block_id(),
-                  "height" => new_block.header.chain_length,
-                  "consensus_hash" => %new_block.header.consensus_hash
+                    "block_id" => %new_block.block_id(),
+                    "height" => new_block.header.chain_length,
+                    "consensus_hash" => %new_block.header.consensus_hash
             );
         }
     }