CRC: ensure that the tenure change transaction and contract call get mined in the same stacks block

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

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

@@ -60,6 +60,8 @@ use crate::neon_node;
 use crate::run_loop::nakamoto::Globals;
 use crate::run_loop::RegisteredKey;
 
+#[cfg(test)]
+pub static TEST_MINE_STALL: std::sync::Mutex<Option<bool>> = std::sync::Mutex::new(None);
 #[cfg(test)]
 pub static TEST_BROADCAST_STALL: std::sync::Mutex<Option<bool>> = std::sync::Mutex::new(None);
 #[cfg(test)]
@@ -291,6 +293,15 @@ impl BlockMinerThread {
         let mut attempts = 0;
         // now, actually run this tenure
         loop {
+            #[cfg(test)]
+            if *TEST_MINE_STALL.lock().unwrap() == Some(true) {
+                // Do an extra check just so we don't log EVERY time.
+                warn!("Mining is stalled due to testing directive");
+                while *TEST_MINE_STALL.lock().unwrap() == Some(true) {
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                }
+                warn!("Mining is no longer stalled due to testing directive. Continuing...");
+            }
             let new_block = loop {
                 // If we're mock mining, we may not have processed the block that the
                 // actual tenure winner committed to yet. So, before attempting to

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

@@ -94,7 +94,9 @@ use wsts::net::Message;
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
-use crate::nakamoto_node::miner::{TEST_BLOCK_ANNOUNCE_STALL, TEST_BROADCAST_STALL};
+use crate::nakamoto_node::miner::{
+    TEST_BLOCK_ANNOUNCE_STALL, TEST_BROADCAST_STALL, TEST_MINE_STALL,
+};
 use crate::neon::{Counters, RunLoopCounter};
 use crate::operations::BurnchainOpSigner;
 use crate::run_loop::boot_nakamoto;
@@ -5074,6 +5076,7 @@ fn clarity_burn_state() {
     let mut signers = TestSigners::default();
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    // Increase the wait on interim blocks to prevent a stacks block being mined before we force it to be
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
     let sender_sk = Secp256k1PrivateKey::new();
     let sender_signer_sk = Secp256k1PrivateKey::new();
@@ -5185,21 +5188,68 @@ fn clarity_burn_state() {
                 vec![&Value::UInt(burn_block_height)],
             );
             result.expect_result_ok().expect("Read-only call failed");
+
+            // Pause mining to prevent the stacks block from being mined before the tenure change is processed
+            TEST_MINE_STALL.lock().unwrap().replace(true);
+            // Submit a tx for the next block (the next block will be a new tenure, so the burn block height will increment)
+            let call_tx = tests::make_contract_call(
+                &sender_sk,
+                sender_nonce,
+                tx_fee,
+                &sender_addr,
+                contract_name,
+                "bar",
+                &[Value::UInt(burn_block_height + 1)],
+            );
+            sender_nonce += 1;
+            submit_tx(&http_origin, &call_tx);
         }
 
         let commits_before = commits_submitted.load(Ordering::SeqCst);
-        next_block_and_mine_commit(
-            &mut btc_regtest_controller,
-            60,
-            &coord_channel,
-            &commits_submitted,
-        )
+        let blocks_processed_before = coord_channel
+            .lock()
+            .expect("Mutex poisoned")
+            .get_stacks_blocks_processed();
+        next_block_and(&mut btc_regtest_controller, 60, || {
+            Ok(commits_submitted.load(Ordering::SeqCst) > commits_before)
+        })
+        .unwrap();
+        TEST_MINE_STALL.lock().unwrap().replace(false);
+        wait_for(20, || {
+            Ok(coord_channel
+                .lock()
+                .expect("Mutex poisoned")
+                .get_stacks_blocks_processed()
+                > blocks_processed_before)
+        })
         .unwrap();
 
         let info = get_chain_info(&naka_conf);
         burn_block_height = info.burn_block_height as u128;
         info!("Expecting burn block height to be {}", burn_block_height);
 
+        // Assert that the contract call was successful
+        test_observer::get_mined_nakamoto_blocks()
+            .last()
+            .unwrap()
+            .tx_events
+            .iter()
+            .for_each(|event| match event {
+                TransactionEvent::Success(TransactionSuccessEvent { result, fee, .. }) => {
+                    // Ignore coinbase and tenure transactions
+                    if *fee == 0 {
+                        return;
+                    }
+
+                    info!("Contract call result: {}", result);
+                    result.clone().expect_result_ok().expect("Ok result");
+                }
+                _ => {
+                    info!("Unsuccessful event: {:?}", event);
+                    panic!("Expected a successful transaction");
+                }
+            });
+
         // mine the interim blocks
         for interim_block_ix in 0..inter_blocks_per_tenure {
             info!("Mining interim block {interim_block_ix}");