Mutants next/test stackslib with 5 shards 1/source

clarity/Cargo.toml

@@ -15,7 +15,7 @@ resolver = "2"
 
 [lib]
 name = "clarity"
-path = "./src/libclarity.rs"
+path = "./src/lib.rs"
 
 [dependencies]
 rand = "0.7.3"

libsigner/Cargo.toml

@@ -13,7 +13,7 @@ edition = "2021"
 
 [lib]
 name = "libsigner"
-path = "./src/libsigner.rs"
+path = "./src/lib.rs"
 
 [dependencies]
 clarity = { path = "../clarity" }

stacks-common/Cargo.toml

@@ -15,7 +15,7 @@ edition = "2021"
 
 [lib]
 name = "stacks_common"
-path = "./src/libcommon.rs"
+path = "./src/lib.rs"
 
 [dependencies]
 rand = "0.7.3"

stacks-common/src/libcommon.rs → stacks-common/src/lib.rs

@@ -6,7 +6,7 @@
 #![allow(non_upper_case_globals)]
 #![cfg_attr(test, allow(unused_variables, unused_assignments))]
 #![allow(clippy::assertions_on_constants)]
-
+// test to trigger mutants re-run
 #[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
 extern crate slog;
 

stackslib/Cargo.toml

@@ -56,7 +56,7 @@ pox-locking = { path = "../pox-locking" }
 libstackerdb = { path = "../libstackerdb" }
 siphasher = "0.3.7"
 wsts = {workspace = true}
-rand_core = "0.6"
+rand_core = {workspace = true}
 
 [target.'cfg(unix)'.dependencies]
 nix = "0.23"

stackslib/src/chainstate/burn/db/sortdb.rs

@@ -1004,6 +1004,12 @@ pub trait SortitionHandle {
         block_height: u64,
     ) -> Result<Option<BlockSnapshot>, db_error>;
 
+    /// Get the first burn block height
+    fn first_burn_block_height(&self) -> u64;
+
+    /// Get a ref to the PoX constants
+    fn pox_constants(&self) -> &PoxConstants;
+
     /// is the given block a descendant of `potential_ancestor`?
     ///  * block_at_burn_height: the burn height of the sortition that chose the stacks block to check
     ///  * potential_ancestor: the stacks block hash of the potential ancestor
@@ -1396,6 +1402,14 @@ impl SortitionHandle for SortitionHandleTx<'_> {
         SortitionDB::get_ancestor_snapshot_tx(self, block_height, &chain_tip)
     }
 
+    fn first_burn_block_height(&self) -> u64 {
+        self.context.first_block_height
+    }
+
+    fn pox_constants(&self) -> &PoxConstants {
+        &self.context.pox_constants
+    }
+
     fn sqlite(&self) -> &Connection {
         self.tx()
     }
@@ -1409,6 +1423,14 @@ impl SortitionHandle for SortitionHandleConn<'_> {
         SortitionHandleConn::get_block_snapshot_by_height(self, block_height)
     }
 
+    fn first_burn_block_height(&self) -> u64 {
+        self.context.first_block_height
+    }
+
+    fn pox_constants(&self) -> &PoxConstants {
+        &self.context.pox_constants
+    }
+
     fn sqlite(&self) -> &Connection {
         self.conn()
     }

stackslib/src/chainstate/nakamoto/coordinator/tests.rs

@@ -47,7 +47,7 @@ use crate::net::relay::Relayer;
 use crate::net::test::{TestPeer, TestPeerConfig};
 
 /// Bring a TestPeer into the Nakamoto Epoch
-fn advance_to_nakamoto(peer: &mut TestPeer, aggregate_public_key: &Point) {
+fn advance_to_nakamoto(peer: &mut TestPeer) {
     let mut peer_nonce = 0;
     let private_key = peer.config.private_key.clone();
     let addr = StacksAddress::from_public_keys(
@@ -70,13 +70,7 @@ fn advance_to_nakamoto(peer: &mut TestPeer, aggregate_public_key: &Point) {
                 12,
                 34,
             );
-            let aggregate_tx: StacksTransaction = make_pox_4_aggregate_key(
-                &private_key,
-                1,
-                sortition_height + 1,
-                aggregate_public_key,
-            );
-            vec![stack_tx, aggregate_tx]
+            vec![stack_tx]
         } else {
             vec![]
         };
@@ -95,6 +89,7 @@ pub fn boot_nakamoto(
     aggregate_public_key: Point,
 ) -> TestPeer {
     let mut peer_config = TestPeerConfig::new(test_name, 0, 0);
+    peer_config.aggregate_public_key = Some(aggregate_public_key.clone());
     let private_key = peer_config.private_key.clone();
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
@@ -117,19 +112,19 @@ pub fn boot_nakamoto(
     peer_config.burnchain.pox_constants.pox_4_activation_height = 31;
 
     let mut peer = TestPeer::new(peer_config);
-    advance_to_nakamoto(&mut peer, &aggregate_public_key);
+    advance_to_nakamoto(&mut peer);
     peer
 }
 
 /// Make a replay peer, used for replaying the blockchain
-fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>, aggregate_public_key: &Point) -> TestPeer<'a> {
+fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>) -> TestPeer<'a> {
     let mut replay_config = peer.config.clone();
     replay_config.test_name = format!("{}.replay", &peer.config.test_name);
     replay_config.server_port = 0;
     replay_config.http_port = 0;
 
     let mut replay_peer = TestPeer::new(replay_config);
-    advance_to_nakamoto(&mut replay_peer, aggregate_public_key);
+    advance_to_nakamoto(&mut replay_peer);
 
     // sanity check
     let replay_tip = {
@@ -244,7 +239,11 @@ fn replay_reward_cycle(
 #[test]
 fn test_simple_nakamoto_coordinator_bootup() {
     let mut test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![],
+        test_signers.aggregate_public_key.clone(),
+    );
 
     let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
@@ -303,7 +302,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        test_signers.aggregate_public_key,
+        test_signers.aggregate_public_key.clone(),
     );
 
     let (burn_ops, mut tenure_change, miner_key) =
@@ -376,7 +375,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
 
     // replay the blocks and sortitions in random order, and verify that we still reach the chain
     // tip
-    let mut replay_peer = make_replay_peer(&mut peer, &test_signers.aggregate_public_key);
+    let mut replay_peer = make_replay_peer(&mut peer);
     replay_reward_cycle(&mut replay_peer, &[burn_ops], &blocks);
 
     let tip = {
@@ -424,7 +423,7 @@ fn test_nakamoto_chainstate_getters() {
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        test_signers.aggregate_public_key,
+        test_signers.aggregate_public_key.clone(),
     );
 
     let sort_tip = {
@@ -913,7 +912,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        test_signers.aggregate_public_key,
+        test_signers.aggregate_public_key.clone(),
     );
 
     let mut all_blocks = vec![];
@@ -953,7 +952,6 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         // do a stx transfer in each block to a given recipient
         let recipient_addr =
             StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
-        let aggregate_public_key = test_signers.aggregate_public_key.clone();
         let blocks_and_sizes = peer.make_nakamoto_tenure(
             tenure_change_tx,
             coinbase_tx,
@@ -973,14 +971,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
                         1,
                         &recipient_addr,
                     );
-
-                    let aggregate_tx = make_pox_4_aggregate_key(
-                        &private_key,
-                        account.nonce + 1,
-                        7 + i,
-                        &aggregate_public_key,
-                    );
-                    vec![stx_transfer, aggregate_tx]
+                    vec![stx_transfer]
                 } else {
                     vec![]
                 }
@@ -1196,7 +1187,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
     }
     // replay the blocks and sortitions in random order, and verify that we still reach the chain
     // tip
-    let mut replay_peer = make_replay_peer(&mut peer, &test_signers.aggregate_public_key);
+    let mut replay_peer = make_replay_peer(&mut peer);
     for (burn_ops, blocks) in rc_burn_ops.iter().zip(rc_blocks.iter()) {
         replay_reward_cycle(&mut replay_peer, burn_ops, blocks);
     }
@@ -1241,7 +1232,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        test_signers.aggregate_public_key,
+        test_signers.aggregate_public_key.clone(),
     );
 
     let mut rc_burn_ops = vec![];
@@ -1530,7 +1521,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
 
     // replay the blocks and sortitions in random order, and verify that we still reach the chain
     // tip
-    let mut replay_peer = make_replay_peer(&mut peer, &test_signers.aggregate_public_key);
+    let mut replay_peer = make_replay_peer(&mut peer);
     replay_reward_cycle(&mut replay_peer, &rc_burn_ops, &all_blocks);
 
     let tip = {
@@ -1569,7 +1560,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        test_signers.aggregate_public_key,
+        test_signers.aggregate_public_key.clone(),
     );
 
     let mut all_blocks = vec![];
@@ -1598,7 +1589,6 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
         // do a stx transfer in each block to a given recipient
         let recipient_addr =
             StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
-        let aggregate_public_key = test_signers.aggregate_public_key.clone();
         let blocks_and_sizes = peer.make_nakamoto_tenure(
             tenure_change_tx,
             coinbase_tx,
@@ -1619,13 +1609,6 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
                         &recipient_addr,
                     );
 
-                    let aggregate_tx = make_pox_4_aggregate_key(
-                        &private_key,
-                        account.nonce + 1,
-                        7 + i,
-                        &aggregate_public_key,
-                    );
-
                     let last_block_opt = blocks_so_far
                         .last()
                         .as_ref()
@@ -1642,7 +1625,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
                             miner.make_nakamoto_tenure_change(tenure_extension.clone());
                         txs.push(tenure_extension_tx);
                     }
-                    txs.append(&mut vec![stx_transfer, aggregate_tx]);
+                    txs.append(&mut vec![stx_transfer]);
                     txs
                 } else {
                     vec![]
@@ -1792,7 +1775,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
 
     // replay the blocks and sortitions in random order, and verify that we still reach the chain
     // tip
-    let mut replay_peer = make_replay_peer(&mut peer, &test_signers.aggregate_public_key);
+    let mut replay_peer = make_replay_peer(&mut peer);
     for (burn_ops, blocks) in rc_burn_ops.iter().zip(rc_blocks.iter()) {
         replay_reward_cycle(&mut replay_peer, burn_ops, blocks);
     }

stackslib/src/chainstate/nakamoto/miner.rs

@@ -436,6 +436,7 @@ impl NakamotoBlockBuilder {
             &mut info.chainstate_tx,
             info.clarity_instance,
             burn_dbconn,
+            burn_dbconn.context.first_block_height,
             &burn_dbconn.context.pox_constants,
             info.parent_consensus_hash,
             info.parent_header_hash,