test: add assertions for empty block heuristics

Author: kantai

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

@@ -230,6 +230,32 @@ impl TestSigningChannel {
     }
 }
 
+/// Assert that the block events captured by the test observer
+///  all match the miner heuristic of *exclusively* including the
+///  tenure change transaction in tenure changing blocks.
+pub fn check_nakamoto_empty_block_heuristics() {
+    let blocks = test_observer::get_blocks();
+    for block in blocks.iter() {
+        // if its not a nakamoto block, don't check anything
+        if block.get("miner_signature").is_none() {
+            continue;
+        }
+        let txs = test_observer::parse_transactions(block);
+        let has_tenure_change = txs
+            .iter()
+            .any(|tx| matches!(tx.payload, TransactionPayload::TenureChange(_)));
+        if has_tenure_change {
+            let only_coinbase_and_tenure_change = txs.iter().all(|tx| {
+                matches!(
+                    tx.payload,
+                    TransactionPayload::TenureChange(_) | TransactionPayload::Coinbase(..)
+                )
+            });
+            assert!(only_coinbase_and_tenure_change, "Nakamoto blocks with a tenure change in them should only have coinbase or tenure changes");
+        }
+    }
+}
+
 pub fn get_stacker_set(http_origin: &str, cycle: u64) -> GetStackersResponse {
     let client = reqwest::blocking::Client::new();
     let path = format!("{http_origin}/v3/stacker_set/{cycle}");
@@ -1683,6 +1709,8 @@ fn simple_neon_integration() {
         assert!(res.contains(&expected_result));
     }
 
+    check_nakamoto_empty_block_heuristics();
+
     coord_channel
         .lock()
         .expect("Mutex poisoned")
@@ -1960,6 +1988,7 @@ fn flash_blocks_on_epoch_3() {
     // Verify blocks before and after the gap
     test_observer::contains_burn_block_range(220..=(gap_start - 1)).unwrap();
     test_observer::contains_burn_block_range((gap_end + 1)..=bhh).unwrap();
+    check_nakamoto_empty_block_heuristics();
 
     info!("Verified burn block ranges, including expected gap for flash blocks");
     info!("Confirmed that the gap includes the Epoch 3.0 activation height (Bitcoin block height): {}", epoch_3_start_height);
@@ -2141,6 +2170,8 @@ fn mine_multiple_per_tenure_integration() {
         "Should have mined (1 + interim_blocks_per_tenure) * tenure_count nakamoto blocks"
     );
 
+    check_nakamoto_empty_block_heuristics();
+
     coord_channel
         .lock()
         .expect("Mutex poisoned")
@@ -2394,6 +2425,8 @@ fn multiple_miners() {
         "Should have mined (1 + interim_blocks_per_tenure) * tenure_count nakamoto blocks"
     );
 
+    check_nakamoto_empty_block_heuristics();
+
     coord_channel
         .lock()
         .expect("Mutex poisoned")
@@ -2761,6 +2794,8 @@ fn correct_burn_outs() {
         assert_eq!(signer_weight, 1, "The signer should have a weight of 1, indicating they stacked the minimum stacking amount");
     }
 
+    check_nakamoto_empty_block_heuristics();
+
     run_loop_thread.join().unwrap();
 }
 

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

@@ -197,7 +197,10 @@ pub mod test_observer {
 
     use stacks::chainstate::stacks::boot::RewardSet;
     use stacks::chainstate::stacks::events::StackerDBChunksEvent;
+    use stacks::chainstate::stacks::StacksTransaction;
+    use stacks::codec::StacksMessageCodec;
     use stacks::net::api::postblock_proposal::BlockValidateResponse;
+    use stacks::util::hash::hex_bytes;
     use stacks_common::types::chainstate::StacksBlockId;
     use warp::Filter;
     use {tokio, warp};
@@ -572,6 +575,30 @@ pub mod test_observer {
         PROPOSAL_RESPONSES.lock().unwrap().clear();
     }
 
+    /// Parse the StacksTransactions from a block (does not include burn ops)
+    ///  panics on any failures to parse
+    pub fn parse_transactions(block: &serde_json::Value) -> Vec<StacksTransaction> {
+        block
+            .get("transactions")
+            .unwrap()
+            .as_array()
+            .unwrap()
+            .iter()
+            .filter_map(|tx_json| {
+                if let Some(burnchain_op_val) = tx_json.get("burnchain_op") {
+                    if !burnchain_op_val.is_null() {
+                        return None;
+                    }
+                }
+                let tx_hex = tx_json.get("raw_tx").unwrap().as_str().unwrap();
+                let tx_bytes = hex_bytes(tx_hex).unwrap();
+                let tx =
+                    StacksTransaction::consensus_deserialize(&mut tx_bytes.as_slice()).unwrap();
+                Some(tx)
+            })
+            .collect()
+    }
+
     pub fn contains_burn_block_range(range: impl RangeBounds<u64>) -> Result<(), String> {
         // Get set of all burn block heights
         let burn_block_heights = get_blocks()

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

@@ -59,7 +59,7 @@ use stacks_signer::config::{build_signer_config_tomls, GlobalConfig as SignerCon
 use stacks_signer::runloop::{SignerResult, State, StateInfo};
 use stacks_signer::{Signer, SpawnedSigner};
 
-use super::nakamoto_integrations::wait_for;
+use super::nakamoto_integrations::{check_nakamoto_empty_block_heuristics, wait_for};
 use crate::config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance};
 use crate::event_dispatcher::MinedNakamotoBlockEvent;
 use crate::neon::{Counters, TestFlag};
@@ -549,6 +549,8 @@ impl<S: Signer<T> + Send + 'static, T: SignerEventTrait + 'static> SignerTest<Sp
     }
 
     pub fn shutdown(self) {
+        check_nakamoto_empty_block_heuristics();
+
         self.running_nodes
             .coord_channel
             .lock()