Feat/block rejections timeout heuristic

CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 
 - 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)
 
 ### Fixed
 

stackslib/src/config/mod.rs

@@ -2182,6 +2182,8 @@ pub struct MinerConfig {
     pub tenure_extend_poll_secs: 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
+    pub tenure_extend_cost_threshold: u64,
     /// Define the timeout to apply while waiting for signers responses, based on the amount of rejections
     pub block_rejection_timeout_steps: HashMap<u32, Duration>,
 }
@@ -2222,6 +2224,8 @@ impl Default for MinerConfig {
             ),
             tenure_extend_poll_secs: Duration::from_secs(DEFAULT_TENURE_EXTEND_POLL_SECS),
             tenure_timeout: Duration::from_secs(DEFAULT_TENURE_TIMEOUT_SECS),
+            tenure_extend_cost_threshold: DEFAULT_TENURE_EXTEND_COST_THRESHOLD,
+
             block_rejection_timeout_steps: {
                 let mut rejections_timeouts_default_map = HashMap::<u32, Duration>::new();
                 rejections_timeouts_default_map.insert(0, Duration::from_secs(600));
@@ -2626,6 +2630,7 @@ pub struct MinerConfigFile {
     pub tenure_cost_limit_per_block_percentage: Option<u8>,
     pub tenure_extend_poll_secs: Option<u64>,
     pub tenure_timeout_secs: Option<u64>,
+    pub tenure_extend_cost_threshold: Option<u64>,
     pub block_rejection_timeout_steps: Option<HashMap<String, u64>>,
 }
 
@@ -2769,6 +2774,8 @@ impl MinerConfigFile {
             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_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),
+
             block_rejection_timeout_steps: {
                 if let Some(block_rejection_timeout_items) = self.block_rejection_timeout_steps {
                     let mut rejection_timeout_durations = HashMap::<u32, Duration>::new();

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

@@ -334,7 +334,7 @@ impl SignerCoordinator {
                         return false;
                     }
                     // number or rejections changed?
-                    if status.total_reject_weight as u64 != rejections {
+                    if u64::from(status.total_reject_weight) != rejections {
                         return false;
                     }
                     // enough signatures?
@@ -388,8 +388,8 @@ impl SignerCoordinator {
                 }
             };
 
-            if rejections != block_status.total_reject_weight as u64 {
-                rejections = block_status.total_reject_weight as u64;
+            if rejections != u64::from(block_status.total_reject_weight) {
+                rejections = u64::from(block_status.total_reject_weight);
                 let (rejections_step, new_rejections_timeout) = self
                     .block_rejection_timeout_steps
                     .range((Included(0), Included(rejections)))

testnet/stacks-node/src/tests/signer/mod.rs

@@ -936,7 +936,6 @@ fn setup_stx_btc_node<G: FnMut(&mut NeonConfig)>(
     let counters = run_loop.counters();
 
     let coord_channel = run_loop.coordinator_channels();
-
     let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
 
     // Give the run loop some time to start up!

testnet/stacks-node/src/tests/signer/v0.rs

@@ -7951,166 +7951,49 @@ fn block_validation_check_rejection_timeout_heuristic() {
 
     // note we just use mined nakamoto_blocks as the second block is not going to be confirmed
 
-    info!("------------------------- Check Rejections-based timeout with 1 rejection -------------------------");
+    let mut test_rejections = |signer_split_index: usize, expected_timeout: u64| {
+        let blocks_before = test_observer::get_mined_nakamoto_blocks().len();
+        let (ignore_signers, reject_signers) = all_signers.split_at(signer_split_index);
 
-    let blocks_before = test_observer::get_mined_nakamoto_blocks().len();
+        info!("------------------------- Check Rejections-based timeout with {} rejections -------------------------", reject_signers.len());
 
-    TEST_REJECT_ALL_BLOCK_PROPOSAL.set(vec![all_signers[19]]);
-    TEST_IGNORE_ALL_BLOCK_PROPOSALS.set(all_signers[0..19].to_vec());
+        TEST_REJECT_ALL_BLOCK_PROPOSAL.set(reject_signers.to_vec());
+        TEST_IGNORE_ALL_BLOCK_PROPOSALS.set(ignore_signers.to_vec());
 
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        30,
-        || Ok(test_observer::get_mined_nakamoto_blocks().len() > blocks_before),
-    )
-    .unwrap();
-
-    signer_test
-        .wait_for_block_rejections(timeout.as_secs(), &[all_signers[19]])
-        .unwrap();
-
-    wait_for(60, || {
-        Ok(signer_test
-            .running_nodes
-            .counters
-            .naka_miner_current_rejections
-            .get()
-            >= 1)
-    })
-    .unwrap();
-    assert_eq!(
-        signer_test
-            .running_nodes
-            .counters
-            .naka_miner_current_rejections_timeout_secs
-            .get(),
-        123
-    );
-
-    info!("------------------------- Check Rejections-based timeout with 2 rejections -------------------------");
-
-    let blocks_before = test_observer::get_mined_nakamoto_blocks().len();
-
-    TEST_REJECT_ALL_BLOCK_PROPOSAL.set(vec![all_signers[18], all_signers[19]]);
-    TEST_IGNORE_ALL_BLOCK_PROPOSALS.set(all_signers[0..18].to_vec());
-
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        30,
-        || Ok(test_observer::get_mined_nakamoto_blocks().len() > blocks_before),
-    )
-    .unwrap();
-
-    signer_test
-        .wait_for_block_rejections(timeout.as_secs(), &[all_signers[18], all_signers[19]])
-        .unwrap();
-
-    wait_for(60, || {
-        Ok(signer_test
-            .running_nodes
-            .counters
-            .naka_miner_current_rejections
-            .get()
-            >= 2)
-    })
-    .unwrap();
-    assert_eq!(
-        signer_test
-            .running_nodes
-            .counters
-            .naka_miner_current_rejections_timeout_secs
-            .get(),
-        20
-    );
-
-    info!("------------------------- Check Rejections-based timeout with 3 rejections -------------------------");
-
-    let blocks_before = test_observer::get_mined_nakamoto_blocks().len();
-
-    TEST_REJECT_ALL_BLOCK_PROPOSAL.set(vec![all_signers[17], all_signers[18], all_signers[19]]);
-    TEST_IGNORE_ALL_BLOCK_PROPOSALS.set(all_signers[0..17].to_vec());
-
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        30,
-        || Ok(test_observer::get_mined_nakamoto_blocks().len() > blocks_before),
-    )
-    .unwrap();
-
-    signer_test
-        .wait_for_block_rejections(
-            timeout.as_secs(),
-            &[all_signers[17], all_signers[18], all_signers[19]],
+        next_block_and(
+            &mut signer_test.running_nodes.btc_regtest_controller,
+            30,
+            || Ok(test_observer::get_mined_nakamoto_blocks().len() > blocks_before),
         )
         .unwrap();
 
-    wait_for(60, || {
-        Ok(signer_test
-            .running_nodes
-            .counters
-            .naka_miner_current_rejections
-            .get()
-            >= 3)
-    })
-    .unwrap();
-
-    assert_eq!(
         signer_test
-            .running_nodes
-            .counters
-            .naka_miner_current_rejections_timeout_secs
-            .get(),
-        10
-    );
-
-    info!("------------------------- Check Rejections-based timeout with 4 rejections -------------------------");
-
-    let blocks_before = test_observer::get_mined_nakamoto_blocks().len();
-
-    TEST_REJECT_ALL_BLOCK_PROPOSAL.set(vec![
-        all_signers[16],
-        all_signers[17],
-        all_signers[18],
-        all_signers[19],
-    ]);
-    TEST_IGNORE_ALL_BLOCK_PROPOSALS.set(all_signers[0..16].to_vec());
-
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        30,
-        || Ok(test_observer::get_mined_nakamoto_blocks().len() > blocks_before),
-    )
-    .unwrap();
+            .wait_for_block_rejections(timeout.as_secs(), &reject_signers)
+            .unwrap();
 
-    signer_test
-        .wait_for_block_rejections(
-            timeout.as_secs(),
-            &[
-                all_signers[16],
-                all_signers[17],
-                all_signers[18],
-                all_signers[19],
-            ],
-        )
+        wait_for(60, || {
+            Ok(signer_test
+                .running_nodes
+                .counters
+                .naka_miner_current_rejections
+                .get()
+                >= reject_signers.len() as u64)
+        })
         .unwrap();
+        assert_eq!(
+            signer_test
+                .running_nodes
+                .counters
+                .naka_miner_current_rejections_timeout_secs
+                .get(),
+            expected_timeout
+        );
+    };
 
-    wait_for(60, || {
-        Ok(signer_test
-            .running_nodes
-            .counters
-            .naka_miner_current_rejections
-            .get()
-            >= 4)
-    })
-    .unwrap();
-    assert_eq!(
-        signer_test
-            .running_nodes
-            .counters
-            .naka_miner_current_rejections_timeout_secs
-            .get(),
-        99
-    );
+    test_rejections(19, 123);
+    test_rejections(18, 20);
+    test_rejections(17, 10);
+    test_rejections(16, 99);
 
     // reset reject/ignore
     TEST_REJECT_ALL_BLOCK_PROPOSAL.set(vec![]);