feat: allow other transactions with tenure extends

We want the heuristic to be such that the miner mines block found tenure
changes quickly, only including the tenure change and the coinbase, but
tenure extensions do not require this quick response, so they should
include other transactions.

Fixes #5577

Author: obycode

.github/workflows/bitcoin-tests.yml

@@ -124,6 +124,7 @@ jobs:
           - tests::signer::v0::signing_in_0th_tenure_of_reward_cycle
           - tests::signer::v0::continue_after_tenure_extend
           - tests::signer::v0::tenure_extend_after_idle_signers
+          - tests::signer::v0::tenure_extend_with_other_transactions
           - tests::signer::v0::tenure_extend_after_idle_miner
           - tests::signer::v0::tenure_extend_after_failed_miner
           - tests::signer::v0::tenure_extend_succeeds_after_rejected_attempt

stackslib/src/chainstate/stacks/miner.rs

@@ -2258,7 +2258,13 @@ impl StacksBlockBuilder {
         // nakamoto miner tenure start heuristic:
         //  mine an empty block so you can start your tenure quickly!
         if let Some(tx) = initial_txs.first() {
-            if matches!(&tx.payload, TransactionPayload::TenureChange(_)) {
+            if matches!(
+                &tx.payload,
+                TransactionPayload::TenureChange(TenureChangePayload {
+                    cause: TenureChangeCause::BlockFound,
+                    ..
+                })
+            ) {
                 info!("Nakamoto miner heuristic: during tenure change blocks, produce a fast short block to begin tenure");
                 return Ok((false, tx_events));
             }

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

@@ -247,9 +247,15 @@ pub fn check_nakamoto_empty_block_heuristics() {
             continue;
         }
         let txs = test_observer::parse_transactions(block);
-        let has_tenure_change = txs
-            .iter()
-            .any(|tx| matches!(tx.payload, TransactionPayload::TenureChange(_)));
+        let has_tenure_change = txs.iter().any(|tx| {
+            matches!(
+                tx.payload,
+                TransactionPayload::TenureChange(TenureChangePayload {
+                    cause: TenureChangeCause::BlockFound,
+                    ..
+                })
+            )
+        });
         if has_tenure_change {
             let only_coinbase_and_tenure_change = txs.iter().all(|tx| {
                 matches!(

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

@@ -2616,6 +2616,51 @@ fn tenure_extend_after_idle_signers() {
         return;
     }
 
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
+
+    info!("------------------------- Test Setup -------------------------");
+    let num_signers = 5;
+    let idle_timeout = Duration::from_secs(30);
+    let mut signer_test: SignerTest<SpawnedSigner> = SignerTest::new_with_config_modifications(
+        num_signers,
+        vec![],
+        |config| {
+            config.tenure_idle_timeout = idle_timeout;
+        },
+        |_| {},
+        None,
+        None,
+    );
+
+    signer_test.boot_to_epoch_3();
+
+    info!("---- Nakamoto booted, starting test ----");
+    signer_test.mine_nakamoto_block(Duration::from_secs(30), true);
+
+    info!("---- Waiting for a tenure extend ----");
+
+    // Now, wait for a block with a tenure extend
+    wait_for(idle_timeout.as_secs() + 10, || {
+        Ok(last_block_contains_tenure_change_tx(
+            TenureChangeCause::Extended,
+        ))
+    })
+    .expect("Timed out waiting for a block with a tenure extend");
+
+    signer_test.shutdown();
+}
+
+#[test]
+#[ignore]
+/// This test verifies that a miner will include other transactions with a TenureExtend transaction.
+fn tenure_extend_with_other_transactions() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
     tracing_subscriber::registry()
         .with(fmt::layer())
         .with(EnvFilter::from_default_env())
@@ -2627,7 +2672,7 @@ fn tenure_extend_after_idle_signers() {
     let sender_addr = tests::to_addr(&sender_sk);
     let send_amt = 100;
     let send_fee = 180;
-    let _recipient = PrincipalData::from(StacksAddress::burn_address(false));
+    let recipient = PrincipalData::from(StacksAddress::burn_address(false));
     let idle_timeout = Duration::from_secs(30);
     let mut signer_test: SignerTest<SpawnedSigner> = SignerTest::new_with_config_modifications(
         num_signers,
@@ -2639,20 +2684,72 @@ fn tenure_extend_after_idle_signers() {
         None,
         None,
     );
-    let _http_origin = format!("http://{}", &signer_test.running_nodes.conf.node.rpc_bind);
+    let http_origin = format!("http://{}", &signer_test.running_nodes.conf.node.rpc_bind);
 
     signer_test.boot_to_epoch_3();
 
     info!("---- Nakamoto booted, starting test ----");
     signer_test.mine_nakamoto_block(Duration::from_secs(30), true);
 
-    info!("---- Waiting for a tenure extend ----");
+    info!("Pause miner so it doesn't propose a block before the tenure extend");
+    TEST_MINE_STALL.set(true);
+
+    // Submit a transaction to be included with the tenure extend
+    let transfer_tx = make_stacks_transfer(
+        &sender_sk,
+        0,
+        send_fee,
+        signer_test.running_nodes.conf.burnchain.chain_id,
+        &recipient,
+        send_amt,
+    );
+    let _tx = submit_tx(&http_origin, &transfer_tx);
+
+    info!("---- Wait for tenure extend timeout ----");
+
+    sleep_ms(idle_timeout.as_millis() as u64 + 1000);
+
+    info!("---- Resume miner to propose a block with the tenure extend ----");
+    TEST_MINE_STALL.set(false);
 
     // Now, wait for a block with a tenure extend
     wait_for(idle_timeout.as_secs() + 10, || {
-        Ok(last_block_contains_tenure_change_tx(
-            TenureChangeCause::Extended,
-        ))
+        let blocks = test_observer::get_blocks();
+        let last_block = &blocks.last().unwrap();
+        let transactions = last_block["transactions"].as_array().unwrap();
+        let (first_tx, other_txs) = transactions.split_first().unwrap();
+        let raw_tx = first_tx["raw_tx"].as_str().unwrap();
+        let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
+        let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
+        let found_tenure_extend = match &parsed.payload {
+            TransactionPayload::TenureChange(payload)
+                if payload.cause == TenureChangeCause::Extended =>
+            {
+                info!("Found tenure extend transaction: {parsed:?}");
+                true
+            }
+            _ => false,
+        };
+        if found_tenure_extend {
+            let found_transfer = other_txs.iter().any(|tx| {
+                let raw_tx = tx["raw_tx"].as_str().unwrap();
+                let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
+                let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
+                match &parsed.payload {
+                    TransactionPayload::TokenTransfer(..) => true,
+                    _ => false,
+                }
+            });
+            if found_transfer {
+                info!("Found transfer transaction");
+                Ok(true)
+            } else {
+                Err("No transfer transaction found together with the tenure extend".to_string())
+            }
+        } else {
+            info!("No tenure change transaction found");
+            Ok(false)
+        }
     })
     .expect("Timed out waiting for a block with a tenure extend");