Add disallow_reorg_within_first_proposal_burn_block_timing_secs_but_more_than_one_block_scenario() and new madhouse commands

Commands added:
SendAndMineTransferTx
BuildNextBitcoinBlock
WaitForAndVerifyBlockRejection
VerifyMiner1BlockCount

Author: orsissimo

Cargo.lock

@@ -52,8 +52,8 @@ tempfile = "3.3"
 mockito = "1.5"
 serial_test = "3.2.0"
 pinny = { git = "https://github.com/BitcoinL2-Labs/pinny-rs.git", rev = "54ba9d533a7b84525a5e65a3eae1a3ae76b9ea49" } #v0.0.2
-madhouse = { git = "https://github.com/stacks-network/madhouse-rs.git", rev = "fc651ddcbaf85e888b06d4a87aa788c4b7ba9309" }
-proptest = { git = "https://github.com/proptest-rs/proptest.git", rev = "c9bdf18c232665b2b740c667c81866b598d06dc7" }
+madhouse = { git = "https://github.com/stacks-network/madhouse-rs.git", tag = "0.2.0" }
+proptest = "1.6.*"
 
 [[bin]]
 name = "stacks-node"

testnet/stacks-node/Cargo.toml

@@ -35,6 +35,7 @@ impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitMiner2 {
         let sortdb = burnchain.open_sortition_db(true).unwrap();
 
         self.miners.lock().unwrap().submit_commit_miner_2(&sortdb);
+        //TODO: ??? state.operations_counter += 1;
     }
 
     fn label(&self) -> String {
@@ -79,6 +80,7 @@ impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitMiner1 {
         let sortdb = burnchain.open_sortition_db(true).unwrap();
 
         self.miners.lock().unwrap().submit_commit_miner_1(&sortdb);
+        //TODO: ??? state.operations_counter += 1;
     }
 
     fn label(&self) -> String {
@@ -93,3 +95,46 @@ impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitMiner1 {
         )))
     }
 }
+
+pub struct BuildNextBitcoinBlock {
+    miners: Arc<Mutex<MultipleMinerTest>>,
+    num_blocks: u64,
+}
+
+impl BuildNextBitcoinBlock {
+    pub fn new(miners: Arc<Mutex<MultipleMinerTest>>, num_blocks: u64) -> Self {
+        Self { miners, num_blocks }
+    }
+}
+
+impl Command<SignerTestState, SignerTestContext> for BuildNextBitcoinBlock {
+    fn check(&self, _state: &SignerTestState) -> bool {
+        info!(
+            "Checking: Build next {} Bitcoin block(s). Result: {:?}",
+            self.num_blocks, true
+        );
+        true
+    }
+
+    fn apply(&self, _state: &mut SignerTestState) {
+        info!("Applying: Build next {} Bitcoin block(s)", self.num_blocks);
+
+        let mut miners = self.miners.lock().unwrap();
+        miners
+            .btc_regtest_controller_mut()
+            .build_next_block(self.num_blocks);
+        //TODO: ??? state.operations_counter += 1;
+    }
+
+    fn label(&self) -> String {
+        "BUILD_NEXT_BITCOIN_BLOCK".to_string()
+    }
+
+    fn build(
+        ctx: Arc<SignerTestContext>,
+    ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
+        (1u64..=5u64).prop_map(move |num_blocks| {
+            CommandWrapper::new(BuildNextBitcoinBlock::new(ctx.miners.clone(), num_blocks))
+        })
+    }
+}

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

@@ -1,11 +1,16 @@
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
 
+use libsigner::v0::messages::RejectReason;
 use madhouse::{Command, CommandWrapper};
 use proptest::prelude::{Just, Strategy};
 
 use super::context::{SignerTestContext, SignerTestState};
-use crate::tests::signer::v0::{wait_for_block_pushed_by_miner_key, MultipleMinerTest};
+use crate::stacks_common::types::PublicKey;
+use crate::tests::signer::v0::{
+    get_nakamoto_headers, wait_for_block_global_rejection_with_reject_reason,
+    wait_for_block_proposal, wait_for_block_pushed_by_miner_key, MultipleMinerTest,
+};
 
 pub struct WaitForTenureChangeBlockFromMiner1 {
     miners: Arc<Mutex<MultipleMinerTest>>,
@@ -123,3 +128,199 @@ impl Command<SignerTestState, SignerTestContext> for WaitForTenureChangeBlockFro
         ))
     }
 }
+
+/// ---------------------------------------------------------
+/// ---------------------------------------------------------
+/// ---------------------------------------------------------
+/// ---------------------------------------------------------
+/// ---------------------------------------------------------
+
+pub struct WaitForAndVerifyBlockRejection {
+    miners: Arc<Mutex<MultipleMinerTest>>,
+    reason: RejectReason,
+    num_signers: usize,
+}
+
+impl WaitForAndVerifyBlockRejection {
+    pub fn new(
+        miners: Arc<Mutex<MultipleMinerTest>>,
+        reason: RejectReason,
+        num_signers: usize,
+    ) -> Self {
+        Self {
+            miners,
+            reason,
+            num_signers,
+        }
+    }
+}
+
+impl Command<SignerTestState, SignerTestContext> for WaitForAndVerifyBlockRejection {
+    fn check(&self, _state: &SignerTestState) -> bool {
+        info!(
+            "Checking: Waiting for block proposal from miner 1 and verifying rejection with reason {:?}",
+            self.reason
+        );
+        true
+    }
+
+    fn apply(&self, _state: &mut SignerTestState) {
+        info!("Applying: Waiting for block proposal from miner 1 and verifying rejection with reason {:?}", self.reason);
+
+        // Get the current block height and miner1's public key
+        let (block_height, miner_pk_1) = {
+            let miners = self.miners.lock().unwrap();
+            let (conf_1, _) = miners.get_node_configs();
+            let chain_info = crate::tests::neon_integrations::get_chain_info(&conf_1);
+            let current_height = chain_info.stacks_tip_height;
+            //TODO: let block_n_height = current_height - state.operations_counter as u64;
+            let block_n_height = current_height - 3;
+            let (miner_pk_1, _) = miners.get_miner_public_keys();
+            (block_n_height, miner_pk_1)
+        };
+
+        info!("Waiting for block proposal at height {}", block_height + 1);
+
+        // Wait for a block proposal from miner 1 at height N+1
+        let proposed_block = wait_for_block_proposal(30, block_height + 1, &miner_pk_1)
+            .expect("Timed out waiting for block proposal");
+
+        let block_hash = proposed_block.header.signer_signature_hash();
+
+        info!(
+            "Received block proposal at height {} with hash {:?}",
+            block_height + 1,
+            block_hash
+        );
+
+        // Check the block has been rejected with the expected reason
+        wait_for_block_global_rejection_with_reject_reason(
+            30,
+            block_hash,
+            self.num_signers,
+            self.reason.clone(),
+        )
+        .expect("Timed out waiting for block rejection");
+
+        info!(
+            "Block was rejected with the expected reason: {:?}",
+            self.reason
+        );
+    }
+
+    fn label(&self) -> String {
+        format!(
+            "WAIT_FOR_AND_VERIFY_BLOCK_REJECTION_WITH_REASON_{:?}",
+            self.reason
+        )
+    }
+
+    fn build(
+        ctx: Arc<SignerTestContext>,
+    ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
+        (1usize..=5usize).prop_map(move |num_signers: usize| {
+            CommandWrapper::new(WaitForAndVerifyBlockRejection::new(
+                ctx.miners.clone(),
+                RejectReason::ReorgNotAllowed,
+                num_signers,
+            ))
+        })
+    }
+}
+
+/// ---------------------------------------------------------
+/// ---------------------------------------------------------
+/// ---------------------------------------------------------
+/// ---------------------------------------------------------
+/// ---------------------------------------------------------
+
+pub struct VerifyMiner1BlockCount {
+    miners: Arc<Mutex<MultipleMinerTest>>,
+    expected_count: usize,
+}
+
+impl VerifyMiner1BlockCount {
+    pub fn new(miners: Arc<Mutex<MultipleMinerTest>>, expected_count: usize) -> Self {
+        Self {
+            miners,
+            expected_count,
+        }
+    }
+}
+
+impl Command<SignerTestState, SignerTestContext> for VerifyMiner1BlockCount {
+    fn check(&self, state: &SignerTestState) -> bool {
+        info!(
+            "Checking: Verifying miner 1 block count. Will run if miner 1 commit ops are paused: {:?}",
+            state.is_primary_miner_skip_commit_op
+        );
+
+        // Only run this verification when miner 1's commit operations are paused
+        state.is_primary_miner_skip_commit_op
+    }
+
+    fn apply(&self, _state: &mut SignerTestState) {
+        info!(
+            "Applying: Verifying miner 1 block count is {}",
+            self.expected_count
+        );
+
+        // Extract everything we need from the locked mutex within this scope
+        let (stacks_height_before, conf_1, miner_pk_1) = {
+            let miners = self.miners.lock().unwrap();
+            let current_height = miners.get_peer_stacks_tip_height();
+            //TODO: let stacks_height_before = current_height - state.operations_counter as u64;
+            let stacks_height_before = current_height - 3;
+
+            // Get the configs and miner public key
+            let (conf_1, _) = miners.get_node_configs();
+            let (miner_pk_1, _) = miners.get_miner_public_keys();
+
+            // Return the values we need outside the lock
+            (stacks_height_before, conf_1, miner_pk_1)
+        };
+
+        // Check only expected_count blocks from miner1 have been added after the epoch3 boot
+        let miner1_blocks_after_boot_to_epoch3 = get_nakamoto_headers(&conf_1)
+            .into_iter()
+            .filter(|block| {
+                // skip first nakamoto block
+                if block.stacks_block_height == stacks_height_before {
+                    return false;
+                }
+                let nakamoto_block_header = block.anchored_header.as_stacks_nakamoto().unwrap();
+                miner_pk_1
+                    .verify(
+                        nakamoto_block_header.miner_signature_hash().as_bytes(),
+                        &nakamoto_block_header.miner_signature,
+                    )
+                    .unwrap()
+            })
+            .count();
+
+        assert_eq!(
+            miner1_blocks_after_boot_to_epoch3, self.expected_count,
+            "Expected {} blocks from miner 1, but found {}",
+            self.expected_count, miner1_blocks_after_boot_to_epoch3
+        );
+
+        info!(
+            "Verified miner 1 has exactly {} blocks after epoch 3 boot",
+            self.expected_count
+        );
+    }
+
+    fn label(&self) -> String {
+        format!("VERIFY_MINER_1_BLOCK_COUNT_{}", self.expected_count)
+    }
+
+    fn build(
+        ctx: Arc<SignerTestContext>,
+    ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
+        //TODO: randomize expected_count?
+        Just(CommandWrapper::new(VerifyMiner1BlockCount::new(
+            ctx.miners.clone(),
+            1,
+        )))
+    }
+}

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

@@ -53,6 +53,7 @@ pub struct SignerTestState {
     pub is_secondary_miner_skip_commit_op: bool,
     pub mining_stalled: bool,
     pub transfer_txs_submitted: Vec<(StacksHeightBefore, TxId)>,
+    pub operations_counter: usize,
 }
 
 impl State for SignerTestState {}

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

@@ -10,9 +10,12 @@ mod sortition;
 mod stacks_mining;
 mod transfer;
 
-pub use bitcoin_mining::MineBitcoinBlock;
-pub use block_commit::SubmitBlockCommitMiner2;
-pub use block_wait::{WaitForTenureChangeBlockFromMiner1, WaitForTenureChangeBlockFromMiner2};
+pub use bitcoin_mining::{MineBitcoinBlock, MineBitcoinBlockTenureChangeMiner1};
+pub use block_commit::{BuildNextBitcoinBlock, SubmitBlockCommitMiner1, SubmitBlockCommitMiner2};
+pub use block_wait::{
+    VerifyMiner1BlockCount, WaitForAndVerifyBlockRejection, WaitForTenureChangeBlockFromMiner1,
+    WaitForTenureChangeBlockFromMiner2,
+};
 pub use boot::BootToEpoch3;
 pub use commit_ops::{SkipCommitOpMiner1, SkipCommitOpMiner2};
 pub use context::SignerTestContext;
@@ -21,3 +24,4 @@ pub use sortition::{
     VerifyLastSortitionWinnerReorged, VerifyMiner1WonSortition, VerifyMiner2WonSortition,
 };
 pub use stacks_mining::{PauseStacksMining, ResumeStacksMining};
+pub use transfer::SendAndMineTransferTx;