Merge branch 'develop' into feat/current-contract

Author: obycode

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - Adds support for new Clarity 4 builtins (not activated until epoch 3.3):
   - `contract-hash?`
   - `current-contract`
+- Added `contract_cost_limit_percentage` to the miner config file — sets the percentage of a block’s execution cost at which, if a large non-boot contract call would cause a BlockTooBigError, the miner will stop adding further non-boot contract calls and only include STX transfers and boot contract calls for the remainder of the block.
 
 ### Changed
 

stacks-node/src/tests/nakamoto_integrations.rs

@@ -3891,41 +3891,48 @@ fn tx_replay_btc_on_stx_invalidation() {
         .expect("Timed out waiting for tx replay set to be updated");
 
     info!("---- Waiting for tx replay set to be cleared ----");
-
-    let stacks_height_before = get_chain_info(&conf).stacks_tip_height;
-
+    test_observer::clear();
     fault_injection_unstall_miner();
-
     signer_test
         .wait_for_signer_state_check(30, |state| Ok(state.get_tx_replay_set().is_none()))
         .expect("Timed out waiting for tx replay set to be cleared");
 
-    // Ensure that only one block was mined
-    wait_for(30, || {
-        let new_tip = get_chain_info(&conf).stacks_tip_height;
-        Ok(new_tip == stacks_height_before + 1)
-    })
-    .expect("Timed out waiting for block to advance by 1");
+    let mut found_block = false;
+    // Ensure that we don't mine any of the replay transactions in a sufficient amount of elapsed time
+    let _ = wait_for(30, || {
+        let blocks = test_observer::get_blocks();
+        for block in blocks {
+            let block: StacksBlockEvent =
+                serde_json::from_value(block).expect("Failed to parse block");
+            for tx in block.transactions {
+                match tx.payload {
+                    TransactionPayload::TenureChange(TenureChangePayload {
+                        cause: TenureChangeCause::BlockFound,
+                        ..
+                    })
+                    | TransactionPayload::Coinbase(..) => {
+                        found_block = true;
+                    }
+                    TransactionPayload::TenureChange(TenureChangePayload {
+                        cause: TenureChangeCause::Extended,
+                        ..
+                    }) => {
+                        continue;
+                    }
+                    _ => {
+                        panic!("We should not see any transactions mined beyond tenure change or coinbase txs");
+                    }
+                }
+            }
+        }
+        Ok(false)
+    });
 
+    assert!(found_block, "Failed to mine the tenure change block");
+    // Ensure that in the 30 seconds, the nonce did not increase. This also asserts that no tx replays were mined.
     let account = get_account(&_http_origin, &recipient_addr);
     assert_eq!(account.nonce, 0, "Expected recipient nonce to be 0");
 
-    let blocks = test_observer::get_blocks();
-    let block: StacksBlockEvent =
-        serde_json::from_value(blocks.last().unwrap().clone()).expect("Failed to parse block");
-    assert_eq!(block.transactions.len(), 2);
-    assert!(matches!(
-        block.transactions[0].payload,
-        TransactionPayload::TenureChange(TenureChangePayload {
-            cause: TenureChangeCause::BlockFound,
-            ..
-        })
-    ));
-    assert!(matches!(
-        block.transactions[1].payload,
-        TransactionPayload::Coinbase(..)
-    ));
-
     signer_test.shutdown();
 }
 
@@ -5466,7 +5473,7 @@ fn tx_replay_with_fork_middle_replay_while_tenure_extending_and_new_tx_submitted
     signer_test
         .wait_for_signer_state_check(60, |state| {
             let tx_replay_set = state.get_tx_replay_set();
-            Ok(tx_replay_set.is_none())
+            Ok(tx_replay_set.is_none() && get_account(&http_origin, &sender1_addr).nonce >= 3)
         })
         .expect("Timed out waiting for tx replay set to be cleared");
 
@@ -6539,6 +6546,8 @@ fn tx_replay_budget_exceeded_tenure_extend() {
 
     signer_test.wait_for_replay_set_eq(30, vec![txid1, txid2.clone()]);
 
+    // Clear the test observer so we know that if we see txid1 and txid2 again, that it means they were remined
+    test_observer::clear();
     fault_injection_unstall_miner();
 
     info!("---- Waiting for replay set to be cleared ----");
@@ -6547,25 +6556,25 @@ fn tx_replay_budget_exceeded_tenure_extend() {
     signer_test
         .wait_for_signer_state_check(30, |state| Ok(state.get_tx_replay_set().is_none()))
         .expect("Timed out waiting for tx replay set to be cleared");
-
-    let blocks = test_observer::get_blocks();
     let mut found_block: Option<StacksBlockEvent> = None;
-    // To reduce flakiness, we're just looking for the block containing `txid2`,
-    // which may or may not be the last block.
-    let last_blocks = blocks.iter().rev().take(3).collect::<Vec<_>>();
-    for block in last_blocks {
-        let block: StacksBlockEvent =
-            serde_json::from_value(block.clone()).expect("Failed to parse block");
-        if block
-            .transactions
-            .iter()
-            .find(|tx| tx.txid().to_hex() == txid2)
-            .is_some()
-        {
-            found_block = Some(block);
-            break;
+    wait_for(60, || {
+        let blocks = test_observer::get_blocks();
+        for block in blocks {
+            let block: StacksBlockEvent =
+                serde_json::from_value(block.clone()).expect("Failed to parse block");
+            if block
+                .transactions
+                .iter()
+                .find(|tx| tx.txid().to_hex() == txid2)
+                .is_some()
+            {
+                found_block = Some(block);
+                return Ok(true);
+            }
         }
-    }
+        Ok(false)
+    })
+    .expect("Failed to mine the replay txs");
     let block = found_block.expect("Failed to find block with txid2");
     assert_eq!(block.transactions.len(), 2);
     assert!(matches!(

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

@@ -38,6 +38,7 @@ use crate::chainstate::stacks::miner::{
 };
 use crate::chainstate::stacks::{Error, StacksBlockHeader, *};
 use crate::clarity_vm::clarity::ClarityInstance;
+use crate::config::DEFAULT_CONTRACT_COST_LIMIT_PERCENTAGE;
 use crate::core::mempool::*;
 use crate::core::*;
 use crate::monitoring::{
@@ -90,6 +91,9 @@ pub struct NakamotoBlockBuilder {
     pub header: NakamotoBlockHeader,
     /// Optional soft limit for this block's budget usage
     soft_limit: Option<ExecutionCost>,
+    /// Percentage of a block's budget that may be consumed by
+    /// contract calls before reverting to stx transfers/boot contract calls only
+    contract_limit_percentage: Option<u8>,
 }
 
 pub struct MinerTenureInfo<'a> {
@@ -141,6 +145,7 @@ impl NakamotoBlockBuilder {
             txs: vec![],
             header: NakamotoBlockHeader::genesis(),
             soft_limit: None,
+            contract_limit_percentage: None,
         }
     }
 
@@ -170,6 +175,7 @@ impl NakamotoBlockBuilder {
         coinbase: Option<&StacksTransaction>,
         bitvec_len: u16,
         soft_limit: Option<ExecutionCost>,
+        contract_limit_percentage: Option<u8>,
     ) -> Result<NakamotoBlockBuilder, Error> {
         let next_height = parent_stacks_header
             .anchored_header
@@ -210,6 +216,7 @@ impl NakamotoBlockBuilder {
                     .unwrap_or(0),
             ),
             soft_limit,
+            contract_limit_percentage,
         })
     }
 
@@ -534,6 +541,7 @@ impl NakamotoBlockBuilder {
             tenure_info.coinbase_tx(),
             signer_bitvec_len,
             None,
+            settings.mempool_settings.contract_cost_limit_percentage,
         )?;
 
         let ts_start = get_epoch_time_ms();
@@ -712,7 +720,6 @@ impl BlockBuilder for NakamotoBlockBuilder {
             }
 
             let cost_before = clarity_tx.cost_so_far();
-
             let (_fee, receipt) = match StacksChainState::process_transaction(
                 clarity_tx,
                 tx,
@@ -722,7 +729,13 @@ impl BlockBuilder for NakamotoBlockBuilder {
             ) {
                 Ok(x) => x,
                 Err(e) => {
-                    return parse_process_transaction_error(clarity_tx, tx, e);
+                    return parse_process_transaction_error(
+                        clarity_tx,
+                        tx,
+                        e,
+                        self.contract_limit_percentage
+                            .unwrap_or(DEFAULT_CONTRACT_COST_LIMIT_PERCENTAGE),
+                    );
                 }
             };
 
@@ -741,7 +754,7 @@ impl BlockBuilder for NakamotoBlockBuilder {
                   "origin" => %tx.origin_address(),
                   "soft_limit_reached" => soft_limit_reached,
                   "cost_after" => %cost_after,
-                  "cost_before" => %cost_before,
+                  "cost_before" => %cost_before
             );
 
             // save
@@ -758,6 +771,7 @@ fn parse_process_transaction_error(
     clarity_tx: &mut ClarityTx,
     tx: &StacksTransaction,
     e: Error,
+    contract_limit_percentage: u8,
 ) -> TransactionResult {
     let (is_problematic, e) = TransactionResult::is_problematic(tx, e, clarity_tx.get_epoch());
     if is_problematic {
@@ -766,14 +780,13 @@ fn parse_process_transaction_error(
         match e {
             Error::CostOverflowError(cost_before, cost_after, total_budget) => {
                 clarity_tx.reset_cost(cost_before.clone());
-                if total_budget.proportion_largest_dimension(&cost_before)
-                    < TX_BLOCK_LIMIT_PROPORTION_HEURISTIC
-                {
+                let cost_so_far_percentage =
+                    total_budget.proportion_largest_dimension(&cost_before);
+                if cost_so_far_percentage < TX_BLOCK_LIMIT_PROPORTION_HEURISTIC {
                     warn!(
-                            "Transaction {} consumed over {}% of block budget, marking as invalid; budget was {}",
+                            "Transaction {} consumed over {}% of block budget, marking as invalid; budget was {total_budget}",
                             tx.txid(),
-                            100 - TX_BLOCK_LIMIT_PROPORTION_HEURISTIC,
-                            &total_budget
+                            100 - TX_BLOCK_LIMIT_PROPORTION_HEURISTIC
                     );
                     let mut measured_cost = cost_after;
                     let measured_cost = if measured_cost.sub(&cost_before).is_ok() {
@@ -783,6 +796,13 @@ fn parse_process_transaction_error(
                         None
                     };
                     TransactionResult::error(tx, Error::TransactionTooBigError(measured_cost))
+                } else if cost_so_far_percentage < contract_limit_percentage.into() {
+                    warn!(
+                        "Transaction {} would exceed the tenure budget, but only {cost_so_far_percentage}% of total budget currently consumed. Skipping tx for this block.", tx.txid();
+                        "contract_limit_percentage" => contract_limit_percentage,
+                        "total_budget" => %total_budget
+                    );
+                    TransactionResult::skipped_due_to_error(tx, Error::BlockCostLimitError)
                 } else {
                     warn!(
                         "Transaction {} reached block cost {cost_after}; budget was {total_budget}",

stackslib/src/chainstate/nakamoto/miner.rs

@@ -727,6 +727,7 @@ impl NakamotoBlockBuilder {
             Some(&coinbase_tx),
             1,
             None,
+            None,
         )?;
 
         let mut block_txs = vec![tenure_change_tx, coinbase_tx];

stackslib/src/chainstate/nakamoto/shadow.rs

@@ -796,6 +796,7 @@ impl TestStacksNode {
                     },
                     1,
                     None,
+                    None,
                 )?
             } else {
                 NakamotoBlockBuilder::new_first_block(

stackslib/src/chainstate/nakamoto/tests/node.rs

@@ -2879,9 +2879,10 @@ fn select_and_apply_transactions_from_vec<B: BlockBuilder>(
             TransactionResult::Skipped(TransactionSkipped { error, .. })
             | TransactionResult::ProcessingError(TransactionError { error, .. }) => {
                 match &error {
-                    Error::BlockTooBigError => {
+                    Error::BlockTooBigError | Error::BlockCostLimitError => {
                         // done mining -- our execution budget is exceeded.
-                        // Make the block from the transactions we did manage to get
+                        // Make the block from the transactions we did manage
+                        // (We cannot simply skip as this would put the replay txs out of order)
                         debug!("Block budget exceeded on tx {txid}");
                         info!("Miner stopping due to limit reached");
                         break;

stackslib/src/chainstate/stacks/miner.rs

@@ -92,6 +92,7 @@ pub enum Error {
     NotInSameFork,
     InvalidChainstateDB,
     BlockTooBigError,
+    BlockCostLimitError,
     TransactionTooBigError(Option<ExecutionCost>),
     BlockCostExceeded,
     NoTransactionsToMine,
@@ -156,6 +157,7 @@ impl fmt::Display for Error {
             Error::NoSuchBlockError => write!(f, "No such Stacks block"),
             Error::InvalidChainstateDB => write!(f, "Invalid chainstate database"),
             Error::BlockTooBigError => write!(f, "Too much data in block"),
+            Error::BlockCostLimitError => write!(f, "Block cost limit exceeded"),
             Error::TransactionTooBigError(ref c) => {
                 write!(f, "Too much data in transaction: measured_cost={c:?}")
             }
@@ -236,6 +238,7 @@ impl error::Error for Error {
             Error::NoSuchBlockError => None,
             Error::InvalidChainstateDB => None,
             Error::BlockTooBigError => None,
+            Error::BlockCostLimitError => None,
             Error::TransactionTooBigError(..) => None,
             Error::BlockCostExceeded => None,
             Error::MicroblockStreamTooLongError => None,
@@ -281,6 +284,7 @@ impl Error {
             Error::NoSuchBlockError => "NoSuchBlockError",
             Error::InvalidChainstateDB => "InvalidChainstateDB",
             Error::BlockTooBigError => "BlockTooBigError",
+            Error::BlockCostLimitError => "BlockCostLimitError",
             Error::TransactionTooBigError(..) => "TransactionTooBigError",
             Error::BlockCostExceeded => "BlockCostExceeded",
             Error::MicroblockStreamTooLongError => "MicroblockStreamTooLongError",