Spend down the block budget limit by x% every block

stackslib/src/chainstate/nakamoto/miner.rs

@@ -124,7 +124,7 @@ pub struct NakamotoBlockBuilder {
     txs: Vec<StacksTransaction>,
     /// header we're filling in
     pub header: NakamotoBlockHeader,
-    /// The execution cost for the block
+    /// Optional soft limit for this block's budget usage
     soft_limit: Option<ExecutionCost>,
 }
 
@@ -536,7 +536,7 @@ impl NakamotoBlockBuilder {
             .mempool_settings
             .tenure_cost_limit_per_block_percentage
         {
-            if percentage < 100 {
+            if (1..100).contains(&percentage) {
                 let mut remaining_limit = block_limit.clone();
                 let cost_so_far = tenure_tx.cost_so_far();
                 if remaining_limit.sub(&cost_so_far).is_ok() {

stackslib/src/chainstate/stacks/miner.rs

@@ -2468,7 +2468,6 @@ impl StacksBlockBuilder {
                                         }
                                     }
                                     Error::TransactionTooBigError(measured_cost) => {
-                                        debug!("TRANSACTION TOO BIG: {}", &txinfo.tx.txid());
                                         if update_estimator {
                                             if let Some(measured_cost) = measured_cost {
                                                 if let Err(e) = estimator.notify_event(

testnet/stacks-node/src/config.rs

@@ -2572,16 +2572,20 @@ impl MinerConfigFile {
             .map(|x| Secp256k1PrivateKey::from_hex(x))
             .transpose()?;
         let pre_nakamoto_mock_signing = mining_key.is_some();
-        let valid_tenure_cost_limit = self
-            .tenure_cost_limit_per_block_percentage
-            .map(|p| p < 100 && p > 0)
-            .unwrap_or(true);
-        if !valid_tenure_cost_limit {
-            return Err(
-                "miner.tenure_cost_limit_per_block_percentage must be between 1 and 100"
-                    .to_string(),
-            );
-        };
+
+        let tenure_cost_limit_per_block_percentage =
+            if let Some(percentage) = self.tenure_cost_limit_per_block_percentage {
+                if (1..=100).contains(&percentage) {
+                    Some(percentage)
+                } else {
+                    return Err(
+                        "miner.tenure_cost_limit_per_block_percentage must be between 1 and 100"
+                            .to_string(),
+                    );
+                }
+            } else {
+                miner_default_config.tenure_cost_limit_per_block_percentage
+            };
         Ok(MinerConfig {
             first_attempt_time_ms: self
                 .first_attempt_time_ms
@@ -2688,7 +2692,7 @@ impl MinerConfigFile {
             first_rejection_pause_ms: self.first_rejection_pause_ms.unwrap_or(miner_default_config.first_rejection_pause_ms),
             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: self.tenure_cost_limit_per_block_percentage,
+            tenure_cost_limit_per_block_percentage,
         })
     }
 }

testnet/stacks-node/src/tests/nakamoto_integrations.rs

@@ -8707,6 +8707,7 @@ fn mock_mining() {
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
     naka_conf.node.pox_sync_sample_secs = 30;
+    naka_conf.miner.tenure_cost_limit_per_block_percentage = None;
     let sender_sk = Secp256k1PrivateKey::new();
     let sender_signer_sk = Secp256k1PrivateKey::new();
     let sender_signer_addr = tests::to_addr(&sender_signer_sk);
@@ -9323,7 +9324,7 @@ fn skip_mining_long_tx() {
     naka_conf.node.prometheus_bind = Some(prom_bind.clone());
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
     naka_conf.miner.nakamoto_attempt_time_ms = 5_000;
-    naka_conf.miner.tenure_cost_limit_per_block_percentage = Some(100);
+    naka_conf.miner.tenure_cost_limit_per_block_percentage = None;
     let sender_1_sk = Secp256k1PrivateKey::from_seed(&[30]);
     let sender_2_sk = Secp256k1PrivateKey::from_seed(&[31]);
     // setup sender + recipient for a test stx transfer

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

@@ -1760,7 +1760,7 @@ fn miner_forking() {
             config.node.pox_sync_sample_secs = 30;
             config.burnchain.pox_reward_length = Some(max_sortitions as u32);
             config.miner.block_commit_delay = Duration::from_secs(0);
-            config.miner.tenure_cost_limit_per_block_percentage = Some(100);
+            config.miner.tenure_cost_limit_per_block_percentage = None;
 
             config.events_observers.retain(|listener| {
                 let Ok(addr) = std::net::SocketAddr::from_str(&listener.endpoint) else {