Added tenure size checker/limiter

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

@@ -2841,6 +2841,7 @@ fn forked_tenure_testing(
         burn_header_timestamp: tip_sn.burn_header_timestamp,
         anchored_block_size: tip_b_block.serialize_to_vec().len() as u64,
         burn_view: Some(tip_b_block.header.consensus_hash),
+        total_tenure_size: 0,
     };
 
     let blocks = test_observer::get_mined_nakamoto_blocks();
@@ -17586,6 +17587,7 @@ fn reorging_signers_capitulate_to_nonreorging_signers_during_tenure_fork() {
         burn_header_timestamp: tip_sn.burn_header_timestamp,
         anchored_block_size: tenure_b_block.serialize_to_vec().len() as u64,
         burn_view: Some(tenure_b_block.header.consensus_hash),
+        total_tenure_size: 0,
     };
 
     // Block B was built atop block A

stackslib/src/chainstate/nakamoto/miner.rs

@@ -38,7 +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::config::{DEFAULT_CONTRACT_COST_LIMIT_PERCENTAGE, DEFAULT_MAX_TENURE_BYTES};
 use crate::core::mempool::*;
 use crate::core::*;
 use crate::monitoring::{
@@ -94,6 +94,8 @@ pub struct NakamotoBlockBuilder {
     /// 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>,
+    /// Maximum size of the whole tenure
+    pub max_tenure_bytes: u64,
 }
 
 pub struct MinerTenureInfo<'a> {
@@ -146,6 +148,7 @@ impl NakamotoBlockBuilder {
             header: NakamotoBlockHeader::genesis(),
             soft_limit: None,
             contract_limit_percentage: None,
+            max_tenure_bytes: u64::from(DEFAULT_MAX_TENURE_BYTES),
         }
     }
 
@@ -176,6 +179,7 @@ impl NakamotoBlockBuilder {
         bitvec_len: u16,
         soft_limit: Option<ExecutionCost>,
         contract_limit_percentage: Option<u8>,
+        max_tenure_bytes: u64,
     ) -> Result<NakamotoBlockBuilder, Error> {
         let next_height = parent_stacks_header
             .anchored_header
@@ -217,6 +221,7 @@ impl NakamotoBlockBuilder {
             ),
             soft_limit,
             contract_limit_percentage,
+            max_tenure_bytes,
         })
     }
 
@@ -542,6 +547,7 @@ impl NakamotoBlockBuilder {
             signer_bitvec_len,
             None,
             settings.mempool_settings.contract_cost_limit_percentage,
+            settings.max_tenure_bytes,
         )?;
 
         let ts_start = get_epoch_time_ms();
@@ -679,6 +685,20 @@ impl BlockBuilder for NakamotoBlockBuilder {
             return TransactionResult::skipped_due_to_error(tx, Error::BlockTooBigError);
         }
 
+        if let Some(parent_header) = &self.parent_header {
+            let mut total_tenure_size = self.bytes_so_far + tx_len;
+
+            // if we are in the same tenure of the parent, accumulate the parent total_tenure_size
+            // note that total_tenure_size is reset whenever a new tenure extend happens
+            if parent_header.consensus_hash == self.header.consensus_hash {
+                total_tenure_size += parent_header.total_tenure_size;
+            }
+
+            if total_tenure_size >= self.max_tenure_bytes {
+                return TransactionResult::skipped_due_to_error(tx, Error::TenureTooBigError);
+            }
+        }
+
         let non_boot_code_contract_call = match &tx.payload {
             TransactionPayload::ContractCall(cc) => !cc.address.is_boot_code_addr(),
             TransactionPayload::SmartContract(..) => true,

stackslib/src/chainstate/nakamoto/mod.rs

@@ -288,6 +288,22 @@ pub static NAKAMOTO_CHAINSTATE_SCHEMA_6: &[&str] = &[
     "CREATE INDEX IF NOT EXISTS nakamoto_block_headers_by_ch_bv ON nakamoto_block_headers(consensus_hash, burn_view);"
 ];
 
+pub static NAKAMOTO_CHAINSTATE_SCHEMA_7: &[&str] = &[
+    r#"
+    UPDATE db_config SET version = "12";
+    "#,
+    // Add a `total_tenure_size` field to the block header row, so we can keep track
+    // of the whole tenure size (and eventually limit it)
+    //
+    //
+    //
+    // Default to 0.
+    r#"
+    ALTER TABLE nakamoto_block_headers
+    ADD COLUMN total_tenure_size NOT NULL DEFAULT 0;
+    "#,
+];
+
 #[cfg(test)]
 mod fault_injection {
     static PROCESS_BLOCK_STALL: std::sync::Mutex<bool> = std::sync::Mutex::new(false);
@@ -3196,6 +3212,7 @@ impl NakamotoChainState {
             stacks_block_height,
             burn_header_height,
             burn_header_timestamp,
+            total_tenure_size,
             ..
         } = tip_info;
 
@@ -3252,6 +3269,7 @@ impl NakamotoChainState {
                     "Nakamoto block StacksHeaderInfo did not set burnchain view".into(),
                 ))
             })?,
+            total_tenure_size
         ];
 
         chainstate_tx.execute(
@@ -3284,8 +3302,9 @@ impl NakamotoChainState {
                     vrf_proof,
                     signer_bitvec,
                     height_in_tenure,
-                    burn_view)
-                    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23, ?24, ?25, ?26, ?27)",
+                    burn_view,
+                    total_tenure_size)
+                    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23, ?24, ?25, ?26, ?27, ?28)",
             args
         )?;
 
@@ -3351,6 +3370,9 @@ impl NakamotoChainState {
         let mut marf_keys = vec![];
         let mut marf_values = vec![];
 
+        // assume a new tenure (we will eventually add the parent accumulated size later)
+        let mut total_tenure_size = block_size;
+
         if new_tenure {
             // make the coinbase height point to this tenure-start block
             marf_keys.push(nakamoto_keys::ongoing_tenure_coinbase_height(
@@ -3403,6 +3425,20 @@ impl NakamotoChainState {
                 &tenure_change_tx.tenure_consensus_hash,
             ));
             marf_values.push(nakamoto_keys::make_tenure_id_value(&block_found_tenure_id));
+        } else {
+            // if we are here we need to accumulate the parent total tenure size
+            if let Some(parent_header_info) =
+                NakamotoChainState::get_block_header(&headers_tx, &new_tip.parent_block_id)?
+            {
+                total_tenure_size =
+                    match total_tenure_size.checked_add(parent_header_info.total_tenure_size) {
+                        Some(total_tenure_size) => total_tenure_size,
+                        // in the extremely improbable case of overflow, just throw the tenure too big error
+                        None => {
+                            return Err(ChainstateError::TenureTooBigError);
+                        }
+                    };
+            }
         }
 
         if let Some(tenure_tx) = new_block.get_tenure_tx_payload() {
@@ -3445,6 +3481,7 @@ impl NakamotoChainState {
             burn_header_timestamp: new_burnchain_timestamp,
             anchored_block_size: block_size,
             burn_view: Some(burn_view.clone()),
+            total_tenure_size,
         };
 
         let tenure_fees = block_fees

stackslib/src/chainstate/nakamoto/shadow.rs

@@ -69,6 +69,7 @@ use crate::chainstate::stacks::{
 use crate::clarity::vm::types::StacksAddressExtensions;
 use crate::clarity_vm::clarity::ClarityInstance;
 use crate::clarity_vm::database::SortitionDBRef;
+use crate::config::DEFAULT_MAX_TENURE_BYTES;
 use crate::net::Error as NetError;
 use crate::util_lib::db::{query_row, u64_to_sql, Error as DBError};
 
@@ -728,6 +729,7 @@ impl NakamotoBlockBuilder {
             1,
             None,
             None,
+            u64::from(DEFAULT_MAX_TENURE_BYTES),
         )?;
 
         let mut block_txs = vec![tenure_change_tx, coinbase_tx];

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

@@ -590,6 +590,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         burn_header_timestamp: 1000,
         anchored_block_size: 12345,
         burn_view: None,
+        total_tenure_size: 0,
     };
 
     let epoch2_execution_cost = ExecutionCost {
@@ -723,6 +724,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         burn_header_timestamp: 1001,
         anchored_block_size: 123,
         burn_view: Some(nakamoto_header.consensus_hash.clone()),
+        total_tenure_size: 0,
     };
 
     let epoch2_block = StacksBlock {
@@ -769,6 +771,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         burn_header_timestamp: 1001,
         anchored_block_size: 123,
         burn_view: Some(nakamoto_header_2.consensus_hash.clone()),
+        total_tenure_size: 0,
     };
 
     let nakamoto_block_2 = NakamotoBlock {
@@ -810,6 +813,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         burn_header_timestamp: 1001,
         anchored_block_size: 123,
         burn_view: Some(nakamoto_header_3.consensus_hash.clone()),
+        total_tenure_size: 0,
     };
 
     let nakamoto_block_3 = NakamotoBlock {
@@ -843,6 +847,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         burn_header_timestamp: 1001,
         anchored_block_size: 123,
         burn_view: Some(nakamoto_header_3.consensus_hash.clone()),
+        total_tenure_size: 0,
     };
 
     let nakamoto_block_3_weight_2 = NakamotoBlock {
@@ -876,6 +881,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         burn_header_timestamp: 1001,
         anchored_block_size: 123,
         burn_view: Some(nakamoto_header_4.consensus_hash.clone()),
+        total_tenure_size: 0,
     };
 
     let nakamoto_block_4 = NakamotoBlock {

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

@@ -51,6 +51,7 @@ use crate::chainstate::stacks::db::*;
 use crate::chainstate::stacks::miner::*;
 use crate::chainstate::stacks::tests::TestStacksNode;
 use crate::chainstate::stacks::{Error as ChainstateError, StacksBlock, *};
+use crate::config::DEFAULT_MAX_TENURE_BYTES;
 use crate::core::{BOOT_BLOCK_HASH, STACKS_EPOCH_3_0_MARKER};
 use crate::net::relay::{BlockAcceptResponse, Relayer};
 use crate::net::test::{TestPeer, *};
@@ -797,6 +798,7 @@ impl TestStacksNode {
                     1,
                     None,
                     None,
+                    u64::from(DEFAULT_MAX_TENURE_BYTES),
                 )?
             } else {
                 NakamotoBlockBuilder::new_first_block(

stackslib/src/chainstate/stacks/db/mod.rs

@@ -51,6 +51,7 @@ use crate::chainstate::nakamoto::{
     HeaderTypeNames, NakamotoBlockHeader, NakamotoChainState, NakamotoStagingBlocksConn,
     NAKAMOTO_CHAINSTATE_SCHEMA_1, NAKAMOTO_CHAINSTATE_SCHEMA_2, NAKAMOTO_CHAINSTATE_SCHEMA_3,
     NAKAMOTO_CHAINSTATE_SCHEMA_4, NAKAMOTO_CHAINSTATE_SCHEMA_5, NAKAMOTO_CHAINSTATE_SCHEMA_6,
+    NAKAMOTO_CHAINSTATE_SCHEMA_7,
 };
 use crate::chainstate::stacks::address::StacksAddressExtensions;
 use crate::chainstate::stacks::boot::*;
@@ -185,6 +186,8 @@ pub struct StacksHeaderInfo {
     /// The burnchain tip that is passed to Clarity while processing this block.
     /// This should always be `Some()` for Nakamoto blocks and `None` for 2.x blocks
     pub burn_view: Option<ConsensusHash>,
+    /// Total tenure size (reset at every tenure extend) in bytes
+    pub total_tenure_size: u64,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -283,8 +286,8 @@ impl DBConfig {
         });
         match epoch_id {
             StacksEpochId::Epoch10 => true,
-            StacksEpochId::Epoch20 => (1..=11).contains(&version_u32),
-            StacksEpochId::Epoch2_05 => (2..=11).contains(&version_u32),
+            StacksEpochId::Epoch20 => (1..=12).contains(&version_u32),
+            StacksEpochId::Epoch2_05 => (2..=12).contains(&version_u32),
             StacksEpochId::Epoch21
             | StacksEpochId::Epoch22
             | StacksEpochId::Epoch23
@@ -293,7 +296,7 @@ impl DBConfig {
             | StacksEpochId::Epoch30
             | StacksEpochId::Epoch31
             | StacksEpochId::Epoch32
-            | StacksEpochId::Epoch33 => (3..=11).contains(&version_u32),
+            | StacksEpochId::Epoch33 => (3..=12).contains(&version_u32),
         }
     }
 }
@@ -362,6 +365,7 @@ impl StacksHeaderInfo {
             burn_header_timestamp: 0,
             anchored_block_size: 0,
             burn_view: None,
+            total_tenure_size: 0,
         }
     }
 
@@ -382,6 +386,7 @@ impl StacksHeaderInfo {
             burn_header_timestamp: first_burnchain_block_timestamp,
             anchored_block_size: 0,
             burn_view: None,
+            total_tenure_size: 0,
         }
     }
 
@@ -454,6 +459,13 @@ impl FromRow<StacksHeaderInfo> for StacksHeaderInfo {
             return Err(db_error::ParseError);
         }
 
+        let total_tenure_size = {
+            match header_type {
+                HeaderTypeNames::Epoch2 => 0,
+                HeaderTypeNames::Nakamoto => u64::from_column(row, "total_tenure_size")?,
+            }
+        };
+
         Ok(StacksHeaderInfo {
             anchored_header: stacks_header,
             microblock_tail: None,
@@ -465,6 +477,7 @@ impl FromRow<StacksHeaderInfo> for StacksHeaderInfo {
             burn_header_timestamp,
             anchored_block_size,
             burn_view,
+            total_tenure_size,
         })
     }
 }
@@ -652,7 +665,7 @@ impl<'a> DerefMut for ChainstateTx<'a> {
     }
 }
 
-pub const CHAINSTATE_VERSION: &str = "11";
+pub const CHAINSTATE_VERSION: &str = "12";
 
 const CHAINSTATE_INITIAL_SCHEMA: &[&str] = &[
     "PRAGMA foreign_keys = ON;",
@@ -1145,6 +1158,14 @@ impl StacksChainState {
                         tx.execute_batch(cmd)?;
                     }
                 }
+                "11" => {
+                    info!(
+                        "Migrating chainstate schema from version 11 to 12: add total_tenure_size field"
+                    );
+                    for cmd in NAKAMOTO_CHAINSTATE_SCHEMA_7.iter() {
+                        tx.execute_batch(cmd)?;
+                    }
+                }
                 _ => {
                     error!(
                         "Invalid chain state database: expected version = {}, got {}",
@@ -2671,6 +2692,7 @@ impl StacksChainState {
             burn_header_timestamp: new_burnchain_timestamp,
             anchored_block_size: anchor_block_size,
             burn_view: None,
+            total_tenure_size: 0,
         };
 
         StacksChainState::insert_stacks_block_header(