Update allow_reorg_within_first_proposal_burn_block_timing_secs_scenario

This commit updates the scenario to correctly test the reorg, following @kantai
suggestions. Addresses #6007 (comment).

Author: BowTiedRadone

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

@@ -6,16 +6,19 @@ mod block_wait;
 mod boot;
 mod commit_ops;
 mod shutdown;
+mod sortition;
 mod stacks_mining;
 mod transfer;
 
 pub use context::SignerTestContext;
 
-pub use bitcoin_mining::{MineBitcoinBlock, MineBitcoinBlockTenureChangePrimaryMiner};
-pub use block_commit::{SubmitBlockCommitPrimaryMiner, SubmitBlockCommitSecondaryMiner};
+pub use bitcoin_mining::MineBitcoinBlock;
+pub use block_commit::SubmitBlockCommitSecondaryMiner;
 pub use block_wait::{WaitForBlockFromMiner1, WaitForBlockFromMiner2};
 pub use boot::BootToEpoch3;
 pub use commit_ops::{SkipCommitOpPrimaryMiner, SkipCommitOpSecondaryMiner};
 pub use shutdown::ShutdownMiners;
+pub use sortition::{
+    VerifyLastSortitionWinnerReorged, VerifyMiner1WonSortition, VerifyMiner2WonSortition,
+};
 pub use stacks_mining::{PauseStacksMining, ResumeStacksMining};
-pub use transfer::SendTransferTx;

testnet/stacks-node/src/tests/signer/commands/sortition.rs

@@ -0,0 +1,130 @@
+use std::sync::{Arc, Mutex};
+
+use madhouse::{Command, CommandWrapper};
+use proptest::prelude::{Just, Strategy};
+
+use crate::tests::signer::v0::{verify_sortition_winner, MultipleMinerTest};
+
+use super::{context::SignerTestState, SignerTestContext};
+
+pub struct VerifyMiner1WonSortition {
+    miners: Arc<Mutex<MultipleMinerTest>>,
+}
+
+impl VerifyMiner1WonSortition {
+    pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
+        Self { miners }
+    }
+}
+
+impl Command<SignerTestState, SignerTestContext> for VerifyMiner1WonSortition {
+    fn check(&self, _state: &SignerTestState) -> bool {
+        info!(
+            "Checking: Verifying miner 1 won sortition. Result: {:?}",
+            true
+        );
+        true
+    }
+
+    fn apply(&self, _state: &mut SignerTestState) {
+        info!("Applying: Verifying miner 1 won sortition");
+
+        let (conf_1, _) = self.miners.lock().unwrap().get_node_configs();
+        let burnchain = conf_1.get_burnchain();
+        let sortdb = burnchain.open_sortition_db(true).unwrap();
+        let (miner_pkh_1, _) = self.miners.lock().unwrap().get_miner_public_key_hashes();
+
+        verify_sortition_winner(&sortdb, &miner_pkh_1);
+    }
+    fn label(&self) -> String {
+        "VERIFY_MINER_1_WON_SORTITION".to_string()
+    }
+    fn build(
+        ctx: Arc<SignerTestContext>,
+    ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
+        Just(CommandWrapper::new(VerifyMiner1WonSortition::new(
+            ctx.miners.clone(),
+        )))
+    }
+}
+
+pub struct VerifyMiner2WonSortition {
+    miners: Arc<Mutex<MultipleMinerTest>>,
+}
+
+impl VerifyMiner2WonSortition {
+    pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
+        Self { miners }
+    }
+}
+
+impl Command<SignerTestState, SignerTestContext> for VerifyMiner2WonSortition {
+    fn check(&self, _state: &SignerTestState) -> bool {
+        info!(
+            "Checking: Verifying miner 2 won sortition. Result: {:?}",
+            true
+        );
+        true
+    }
+
+    fn apply(&self, _state: &mut SignerTestState) {
+        info!("Applying: Verifying miner 2 won sortition");
+
+        let (conf_1, _) = self.miners.lock().unwrap().get_node_configs();
+        let burnchain = conf_1.get_burnchain();
+        let sortdb = burnchain.open_sortition_db(true).unwrap();
+        let (_, miner_pkh_2) = self.miners.lock().unwrap().get_miner_public_key_hashes();
+
+        verify_sortition_winner(&sortdb, &miner_pkh_2);
+    }
+    fn label(&self) -> String {
+        "VERIFY_MINER_2_WON_SORTITION".to_string()
+    }
+    fn build(
+        ctx: Arc<SignerTestContext>,
+    ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
+        Just(CommandWrapper::new(VerifyMiner2WonSortition::new(
+            ctx.miners.clone(),
+        )))
+    }
+}
+
+pub struct VerifyLastSortitionWinnerReorged {
+    miners: Arc<Mutex<MultipleMinerTest>>,
+}
+
+impl VerifyLastSortitionWinnerReorged {
+    pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
+        Self { miners }
+    }
+}
+
+impl Command<SignerTestState, SignerTestContext> for VerifyLastSortitionWinnerReorged {
+    fn check(&self, _state: &SignerTestState) -> bool {
+        info!(
+            "Checking: Verifying last sortition winner reorged. Result: {:?}",
+            true
+        );
+        true
+    }
+
+    fn apply(&self, _state: &mut SignerTestState) {
+        info!("Applying: Verifying last sortition winner reorged");
+        self.miners
+            .lock()
+            .unwrap()
+            .assert_last_sortition_winner_reorged();
+    }
+
+    fn label(&self) -> String {
+        "VERIFY_LAST_SORTITION_WINNER_REORGED".to_string()
+    }
+
+    fn build(
+        ctx: Arc<SignerTestContext>,
+    ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
+        Just(CommandWrapper::new(VerifyLastSortitionWinnerReorged::new(
+            ctx.miners.clone(),
+        )))
+    }
+}

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

@@ -1056,6 +1056,12 @@ impl MultipleMinerTest {
         })
         .expect("Timed out waiting for boostrapped node to catch up to the miner");
     }
+
+    pub fn assert_last_sortition_winner_reorged(&self) {
+        let (conf_1, _) = self.get_node_configs();
+        let latest_sortition = get_sortition_info(&conf_1);
+        assert!(latest_sortition.stacks_parent_ch != latest_sortition.last_sortition_ch);
+    }
 }
 
 /// Returns whether the last block in the test observer contains a tenure change
@@ -1099,7 +1105,7 @@ fn verify_last_block_contains_tenure_change_tx(cause: TenureChangeCause) {
 }
 
 /// Verifies that the tip of the sortition database was won by the provided miner public key hash
-fn verify_sortition_winner(sortdb: &SortitionDB, miner_pkh: &Hash160) {
+pub fn verify_sortition_winner(sortdb: &SortitionDB, miner_pkh: &Hash160) {
     let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
     assert!(tip.sortition);
     assert_eq!(&tip.miner_pk_hash.unwrap(), miner_pkh);
@@ -10450,19 +10456,16 @@ fn allow_reorg_within_first_proposal_burn_block_timing_secs_scenario() {
         SkipCommitOpSecondaryMiner,
         BootToEpoch3,
         SkipCommitOpPrimaryMiner,
-        MineBitcoinBlockTenureChangePrimaryMiner,
-        SubmitBlockCommitSecondaryMiner,
         PauseStacksMining,
         MineBitcoinBlock,
-        SubmitBlockCommitPrimaryMiner,
+        VerifyMiner1WonSortition,
+        SubmitBlockCommitSecondaryMiner,
         ResumeStacksMining,
-        WaitForBlockFromMiner2,
-        MineBitcoinBlock,
-        WaitForBlockFromMiner1,
-        SubmitBlockCommitPrimaryMiner,
-        SendTransferTx,
         WaitForBlockFromMiner1,
-        MineBitcoinBlockTenureChangePrimaryMiner,
+        MineBitcoinBlock,
+        VerifyMiner2WonSortition,
+        VerifyLastSortitionWinnerReorged,
+        WaitForBlockFromMiner2,
         ShutdownMiners
     ]
 }